@letsrunit/playwright 0.1.0

package/dist/index.js

@@ -0,0 +1,3006 @@
+import { getWeekNumber, sleep, chain, hashKey, isRange, isDate, isArray, cartesian } from '@letsrunit/utils';
+import { diffArray, uniqueItem } from '@letsrunit/utils/src/array';
+import rehypeFormat from 'rehype-format';
+import rehypeParse from 'rehype-parse';
+import rehypeStringify from 'rehype-stringify';
+import { unified } from 'unified';
+
+// src/browser.ts
+async function browse(browser, options = {}) {
+  const context = await browser.newContext({
+    viewport: { width: 1920, height: 1080 },
+    userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    locale: "en-US",
+    ...options
+  });
+  await context.addInitScript(() => {
+    window.__name = window.__name || ((fn) => fn);
+  });
+  return await context.newPage();
+}
+
+// src/utils/pick-field-element.ts
+async function pickFieldElement(elements) {
+  const count = await elements.count();
+  if (count === 1) return elements;
+  const candidates = [];
+  for (let i = 0; i < count; i++) {
+    const el = elements.nth(i);
+    const [tag, role, isVisible] = await el.evaluate((e) => [
+      e.tagName.toLowerCase(),
+      e.getAttribute("role")?.toLowerCase() || null,
+      e.getAttribute("type") !== "hidden" && e.getAttribute("aria-hidden") !== "true"
+    ]);
+    candidates.push({ el, tag, role, isVisible });
+  }
+  const formControls = ["input", "textarea", "select"];
+  const controlRoles = ["checkbox", "radio", "textbox", "combobox", "listbox", "slider", "spinbutton"];
+  const primary = candidates.filter(
+    (c) => (formControls.includes(c.tag) || c.role && controlRoles.includes(c.role)) && c.isVisible
+  );
+  if (primary.length === 1) return primary[0].el;
+  const groups = candidates.filter((c) => c.role === "group");
+  if (groups.length === 1) return groups[0].el;
+  const isParent = await elements.evaluateAll((elems) => {
+    const results = elems.map((el, i) => {
+      const others = elems.filter((_, j) => i !== j);
+      return others.every((other) => el.contains(other));
+    });
+    const parentIndex = results.indexOf(true);
+    return parentIndex !== -1 ? parentIndex : null;
+  });
+  if (isParent !== null) {
+    return elements.nth(isParent);
+  }
+  return elements;
+}
+function formatDateForInput(date, type) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const yyyy = date.getFullYear();
+  const mm = pad(date.getMonth() + 1);
+  const dd = pad(date.getDate());
+  const hh = pad(date.getHours());
+  const min = pad(date.getMinutes());
+  switch (type) {
+    case "number":
+      return date.getTime().toString();
+    case "datetime-local":
+      return `${yyyy}-${mm}-${dd}T${hh}:${min}`;
+    case "month":
+      return `${yyyy}-${mm}`;
+    case "week": {
+      const week = getWeekNumber(date);
+      return `${yyyy}-W${pad(week)}`;
+    }
+    case "time":
+      return `${hh}:${min}`;
+    case "date":
+    default:
+      return `${yyyy}-${mm}-${dd}`;
+  }
+}
+function formatDate(d, format) {
+  const dd = String(d.getDate()).padStart(2, "0");
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const yyyy = String(d.getFullYear());
+  return format.replace("DD", dd).replace("MM", mm).replace("YYYY", yyyy);
+}
+function getMonthNames(locale) {
+  const formatter = new Intl.DateTimeFormat(locale, { month: "long" });
+  return Array.from({ length: 12 }, (_, i) => formatter.format(new Date(2e3, i, 1)));
+}
+async function waitForIdle(page, timeout = 2500) {
+  await page.waitForLoadState("domcontentloaded");
+  try {
+    await page.waitForLoadState("networkidle", { timeout });
+  } catch {
+  }
+}
+async function waitForMeta(page, timeout = 2500) {
+  await waitForIdle(page);
+  page.getByRole("navigation");
+  await page.waitForFunction(
+    () => {
+      const head = document.head;
+      if (!head) return false;
+      return Boolean(
+        document.title.trim() || head.querySelector('meta[property^="og:"]') || head.querySelector('meta[name^="twitter:"]') || head.querySelector('script[type="application/ld+json"]')
+      );
+    },
+    { timeout }
+  ).catch(() => {
+  });
+}
+async function waitForDomIdle(page, { quiet = 500, timeout = 1e4 } = {}) {
+  await page.waitForFunction(
+    (q) => new Promise((resolve) => {
+      let last = performance.now();
+      const obs = new MutationObserver(() => last = performance.now());
+      obs.observe(document, {
+        subtree: true,
+        childList: true,
+        attributes: true,
+        characterData: true
+      });
+      const tick = () => {
+        if (performance.now() - last >= q) {
+          obs.disconnect();
+          resolve(true);
+          return;
+        }
+        requestAnimationFrame(tick);
+      };
+      tick();
+    }),
+    quiet,
+    { timeout }
+  );
+}
+async function waitForAnimationsToFinish(root) {
+  await root.page().waitForFunction(
+    (el) => {
+      const animations = el.getAnimations?.({ subtree: true }) ?? [];
+      return animations.every((a) => a.playState !== "running");
+    },
+    await root.elementHandle()
+  );
+  await root.evaluate(() => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(() => r()))));
+}
+async function waitForUrlChange(page, prevUrl, timeout) {
+  try {
+    await page.waitForFunction((u) => location.href !== u, prevUrl, { timeout });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitUntilEnabled(page, target, timeout) {
+  await target.waitFor({ state: "attached", timeout }).catch(() => {
+  });
+  const handle = await target.elementHandle().catch(() => null);
+  if (!handle) return;
+  await page.waitForFunction(
+    (el) => {
+      if (!el || !el.isConnected) return true;
+      const aria = el.getAttribute("aria-disabled");
+      const disabled = el.disabled || aria === "true" || el.getAttribute("disabled") !== null;
+      return !disabled;
+    },
+    handle,
+    { timeout }
+  ).catch(() => {
+  });
+}
+async function waitAfterInteraction(page, target, opts = {}) {
+  const navTimeout = opts.navTimeout ?? 8e3;
+  const settleTimeout = opts.settleTimeout ?? 6e3;
+  const quietMs = opts.quietMs ?? 500;
+  const prevUrl = opts.prevUrl ?? page.url();
+  const kind = await elementKind(target).catch(() => "other");
+  if (kind === "link") {
+    const urlChanged = await waitForUrlChange(page, prevUrl, navTimeout);
+    if (urlChanged) {
+      await page.waitForLoadState("domcontentloaded").catch(() => {
+      });
+      await waitForDomIdle(page, { quiet: quietMs, timeout: navTimeout }).catch(() => {
+      });
+      return;
+    }
+    await waitForDomIdle(page, { quiet: quietMs }).catch(() => {
+    });
+    return;
+  }
+  if (kind === "button" && await target.isDisabled()) {
+    await Promise.race([
+      waitUntilEnabled(page, target, settleTimeout).catch(() => {
+      }),
+      target.waitFor({ state: "hidden", timeout: settleTimeout }).catch(() => {
+      }),
+      target.waitFor({ state: "detached", timeout: settleTimeout }).catch(() => {
+      }),
+      waitForUrlChange(page, prevUrl, settleTimeout).catch(() => {
+      })
+    ]);
+    await sleep(1e3);
+    await waitForDomIdle(page, { quiet: quietMs }).catch(() => {
+    });
+    return;
+  }
+}
+async function elementKind(target) {
+  const role = await target.getAttribute("role").catch(() => null);
+  if (role === "link") return "link";
+  if (role === "button") return "button";
+  const tag = await target.evaluate((el) => el.tagName.toLowerCase()).catch(() => "");
+  if (tag === "a") return "link";
+  if (tag === "button") return "button";
+  if (tag === "input") {
+    const type = await target.getAttribute("type").catch(() => null);
+    if (type === "button" || type === "submit" || type === "reset") return "button";
+  }
+  return "other";
+}
+
+// src/field/calendar.ts
+async function getDialog(root, options) {
+  const role = await root.getAttribute("role", options).catch(() => null);
+  if (role !== "combobox") return null;
+  const ariaControls = await root.getAttribute("aria-controls", options).catch(() => null);
+  if (!ariaControls) return null;
+  const calendar = root.page().locator(`#${ariaControls}`);
+  if (await calendar.count() === 0) {
+    await root.click(options);
+  }
+  const count = await calendar.count();
+  return count > 0 ? calendar : null;
+}
+async function isCalendarGrid(grid) {
+  const cells = grid.locator('td, [role="gridcell"]');
+  const cellCount = await cells.count();
+  if (cellCount < 28 || cellCount > 80) return false;
+  const texts = await cells.allTextContents();
+  const days = texts.map((t) => t.trim()).filter((t) => /^\d{1,2}$/.test(t)).map(Number).filter((n) => n >= 1 && n <= 31);
+  const last = days.reduce((max, cur) => cur === max + 1 ? cur : max, 0);
+  return last >= 28;
+}
+async function getCalendar(root, options) {
+  const gridSelector = 'table, [role="grid"]';
+  let container = await root.locator(gridSelector).count() > 0 ? root : await getDialog(root, options);
+  if (!container && await isCalendarGrid(root)) {
+    return { calendar: root, tables: [root] };
+  }
+  if (!container) return null;
+  const found = await container.locator(gridSelector).all();
+  const tables = [];
+  if (await isCalendarGrid(container)) {
+    tables.push(container);
+  }
+  for (const grid of found) {
+    if (await isCalendarGrid(grid)) {
+      tables.push(grid);
+    }
+  }
+  const uniqueTables = tables.filter((t, i, self) => self.indexOf(t) === i);
+  return uniqueTables.length > 0 ? { calendar: container, tables: uniqueTables } : null;
+}
+function uniqueMonthYearPairs(pairs) {
+  const map = pairs.reduce(
+    (acc, r) => acc.set(`${r.year}-${r.month}`, r),
+    /* @__PURE__ */ new Map()
+  );
+  return Array.from(map.values());
+}
+function inferYearForMonth(target, month) {
+  const ty = target.getFullYear();
+  const tm = target.getMonth();
+  const targetTotal = ty * 12 + tm;
+  const candidates = [ty - 1, ty, ty + 1].map((y) => ({ year: y, total: y * 12 + month }));
+  candidates.sort((a, b) => Math.abs(a.total - targetTotal) - Math.abs(b.total - targetTotal));
+  return candidates[0].year;
+}
+async function getCurrentMonthsAndYears(root, target) {
+  const lang = await root.page().locator("html").getAttribute("lang").catch(() => void 0);
+  const locales = lang && !lang.startsWith("en") ? [lang, "en-US"] : ["en-US"];
+  const text = await root.innerText();
+  const monthSets = locales.map(getMonthNames);
+  const pairs = monthSets.flatMap((months2) => {
+    const matches = text.matchAll(new RegExp(`(${months2.join("|")})\\W*(\\d{4})`, "gi"));
+    return Array.from(matches).map((m) => ({
+      month: months2.findIndex((x) => x.toLowerCase() === m[1].toLowerCase()),
+      year: Number.parseInt(m[2], 10)
+    })).filter((r) => r.month !== -1);
+  });
+  if (pairs.length) {
+    return uniqueMonthYearPairs(pairs);
+  }
+  const months = monthSets.flatMap((ms) => ms.map((name, i) => new RegExp(name, "i").test(text) ? i : -1)).filter(uniqueItem).filter((i) => i >= 0).sort((a, b) => a - b);
+  const years = (text.match(/\b20\d{2}\b/g) ?? []).map((y) => Number.parseInt(y, 10)).filter(uniqueItem).sort((a, b) => a - b);
+  if (!months.length) return [];
+  if (years.length === 1) {
+    return months.map((month) => ({ month, year: years[0] }));
+  }
+  if (years.length === 2) {
+    return months.map((month) => ({ month, year: month >= 6 ? years[0] : years[1] })).sort((a, b) => a.year * 12 + a.month - (b.year * 12 + b.month));
+  }
+  return months.map((month) => ({ month, year: inferYearForMonth(target, month) })).sort((a, b) => a.year * 12 + a.month - (b.year * 12 + b.month));
+}
+async function navigateToMonth(root, target, options) {
+  const currentMonths = await getCurrentMonthsAndYears(root, target);
+  if (currentMonths.length === 0) return false;
+  const targetTotal = target.getFullYear() * 12 + target.getMonth();
+  if (currentMonths.find((m) => m.year * 12 + m.month === targetTotal)) {
+    return true;
+  }
+  const firstMonthTotal = currentMonths[0].year * 12 + currentMonths[0].month;
+  const diff = targetTotal - firstMonthTotal;
+  const btn = diff < 0 ? root.locator('button[aria-label*="prev"], button[class*="prev"]').filter({ visible: true }).first() : root.locator('button[aria-label*="next"], button[class*="next"]').filter({ visible: true }).first();
+  if (!await btn.count()) return false;
+  for (let i = 0; i < Math.abs(diff); i++) {
+    await btn.click(options);
+    await root.page().waitForTimeout(options?.wait ?? 50);
+  }
+  await waitForAnimationsToFinish(root);
+  const afterMonths = await getCurrentMonthsAndYears(root, target);
+  if (afterMonths.some((m) => m.year * 12 + m.month === targetTotal)) return true;
+  if ((options?.retry ?? 0) < 3) {
+    const retry = (options?.retry ?? 0) + 1;
+    return await navigateToMonth(root, target, { ...options, wait: 50 + 50 * retry, retry });
+  }
+  return false;
+}
+async function setDayByAriaLabel(table, value, options) {
+  const formats = ["DD/MM/YYYY", "MM/DD/YYYY", "DD-MM-YYYY", "YYYY-MM-DD"];
+  const candidateLabels = [value.toDateString(), ...formats.map((fmt) => formatDate(value, fmt))];
+  const cells = (await Promise.all(
+    candidateLabels.map(async (label) => {
+      const cell = table.locator(`[aria-label="${label}"], [aria-label*="${label}"]`).first();
+      return await cell.isVisible(options) ? cell : null;
+    })
+  )).filter((l) => l !== null);
+  if (cells.length === 0) return false;
+  if (cells.length === 1) {
+    await cells[0].click(options);
+    return true;
+  }
+  const probeDate = new Date(value.getFullYear(), value.getMonth(), 22);
+  const probeResults = await Promise.all(
+    formats.map(async (fmt) => {
+      const label = formatDate(probeDate, fmt);
+      const cell = table.locator(`[aria-label="${label}"], [aria-label*="${label}"]`).first();
+      return await cell.isVisible(options) ? fmt : null;
+    })
+  );
+  const finalFormat = probeResults.find((fmt) => fmt !== null);
+  const finalCell = finalFormat ? table.locator(`[aria-label="${formatDate(value, finalFormat)}"], [aria-label*="${formatDate(value, finalFormat)}"]`).first() : cells[0];
+  await finalCell.click(options);
+  return true;
+}
+async function setDayByByCellText(table, value, options) {
+  const day = value.getDate();
+  const cells = table.locator('td, [role="gridcell"]').filter({ visible: true });
+  const allTexts = await cells.allInnerTexts();
+  const foundIndices = allTexts.map((text, i) => text.trim() === String(day) ? i : -1).filter((i) => i !== -1);
+  if (foundIndices.length === 0) return false;
+  const index = foundIndices.length === 1 || day < 15 ? foundIndices[0] : foundIndices[foundIndices.length - 1];
+  await cells.nth(index).click(options);
+  return true;
+}
+async function setDates(calendar, tables, dates, options) {
+  let method = void 0;
+  for (const date of dates) {
+    if (!await navigateToMonth(calendar, date, options)) {
+      throw new Error(`Failed to navigate to "${formatDateForInput(date, "month")}"`);
+    }
+    const currentMonths = await getCurrentMonthsAndYears(calendar, date);
+    const targetTotal = date.getFullYear() * 12 + date.getMonth();
+    const tableIndex = currentMonths.findIndex((m) => m.year * 12 + m.month === targetTotal);
+    const table = tables[tableIndex] ?? tables[0];
+    if (method !== "text" && await setDayByAriaLabel(table, date, options)) {
+      method ??= "aria";
+      continue;
+    }
+    if (method !== "aria" && await setDayByByCellText(table, date, options)) {
+      method ??= "text";
+      continue;
+    }
+    throw new Error(`Failed to set date "${formatDateForInput(date, "date")}"`);
+  }
+}
+async function setCalendarDate({ el, tag }, value, options) {
+  if (!(value instanceof Date) && !isArray(value, isDate) && !isRange(value, isDate)) return false;
+  const dates = isArray(value, isDate) ? value : isRange(value) ? [value.from, value.to] : [value];
+  const { calendar, tables } = await getCalendar(el, options) ?? {};
+  if (!calendar || !tables || tables.length === 0) return false;
+  try {
+    await setDates(calendar, tables, dates, options);
+  } finally {
+    if (tag === "input") {
+      await el.page().keyboard.press("Escape").catch();
+      await el.blur().catch();
+    }
+  }
+  return true;
+}
+async function clearSelect(el, opts) {
+  const isMultiple = await el.evaluate((e) => e.multiple, opts);
+  const options = await el.evaluate(
+    (e) => Array.from(e.options).map((o) => ({
+      value: o.value,
+      disabled: o.disabled
+    })),
+    opts
+  );
+  if (isMultiple) {
+    await el.selectOption([], opts);
+    return;
+  }
+  const empty = options.find((o) => o.value === "" && !o.disabled);
+  if (empty) {
+    await el.selectOption({ value: "" }, opts);
+    return;
+  }
+  const firstEnabled = options.find((o) => !o.disabled);
+  if (firstEnabled) {
+    await el.selectOption({ value: firstEnabled.value }, opts);
+  }
+}
+async function multiSelect(el, value, opts) {
+  const isMultiple = await el.evaluate((e) => e.multiple, opts);
+  if (!isMultiple) throw new Error("Select is not multiple");
+  const requested = value.map((v) => String(v));
+  const selected = await el.selectOption(requested, opts);
+  const missing = diffArray(selected, requested);
+  if (missing.length > 0) {
+    throw new Error(`Options not found in select: ${missing.join(", ")}`);
+  }
+}
+async function singleSelect(el, value, opts) {
+  const result = await el.selectOption(value, opts);
+  if (result.length === 0) {
+    throw new Error(`Option "${value}" not found in select`);
+  }
+}
+async function selectNative({ el, tag }, value, options) {
+  if (tag !== "select") return false;
+  if (value instanceof Date || isRange(value)) {
+    return false;
+  }
+  if (value === null) {
+    await clearSelect(el, options);
+    return true;
+  }
+  if (Array.isArray(value)) {
+    if (value.some((v) => v instanceof Date)) return false;
+    await multiSelect(el, value, options);
+    return true;
+  }
+  await singleSelect(el, String(value), options);
+  return true;
+}
+
+// src/field/date-group.ts
+async function getCandidateLocs(el, options) {
+  const candidates = await el.locator("input, select").all();
+  if (candidates.length < 2 || candidates.length > 3) return [];
+  return Promise.all(
+    candidates.map(async (c) => {
+      const info = await c.evaluate((node) => {
+        const e = node;
+        const attrs = {};
+        for (const attr of e.attributes) {
+          attrs[attr.name] = attr.value;
+        }
+        let options2 = [];
+        if (e.tagName.toLowerCase() === "select") {
+          options2 = Array.from(e.options).map((o) => ({
+            value: o.value,
+            text: o.text
+          }));
+        }
+        return {
+          tag: e.tagName.toLowerCase(),
+          type: e.getAttribute("type"),
+          name: e.getAttribute("name"),
+          id: e.getAttribute("id"),
+          ariaLabel: e.getAttribute("aria-label"),
+          placeholder: e.getAttribute("placeholder"),
+          min: e.getAttribute("min"),
+          max: e.getAttribute("max"),
+          inputMode: e.getAttribute("inputmode"),
+          attrs,
+          options: options2
+        };
+      }, options);
+      return { el: c, ...info };
+    })
+  );
+}
+function scoreByAttributes(candidateLocs) {
+  const scores = candidateLocs.map(() => ({ day: 0, month: 0, year: 0 }));
+  candidateLocs.forEach((loc, i) => {
+    const text = [loc.name, loc.id, loc.ariaLabel, loc.placeholder, ...Object.values(loc.attrs)].join(" ").toLowerCase();
+    if (/\b(day|dd|d)\b/i.test(text)) scores[i].day += 5;
+    if (/\b(month|mm|m)\b/i.test(text)) scores[i].month += 5;
+    if (/\b(year|yyyy|yy|y)\b/i.test(text)) scores[i].year += 5;
+    if (loc.max) {
+      const max = parseInt(loc.max, 10);
+      if (max >= 1 && max <= 31) scores[i].day += 2;
+      if (max >= 1 && max <= 12) scores[i].month += 2;
+      if (max > 1900) scores[i].year += 2;
+    }
+    if (loc.tag === "select") {
+      if (loc.options.length >= 12 && loc.options.length <= 13) {
+        scores[i].month += 3;
+      }
+      const allNumeric = loc.options.every((o) => !isNaN(parseInt(o.value, 10)) || !o.value);
+      if (allNumeric && loc.options.length >= 12 && loc.options.length <= 13) {
+        scores[i].month += 2;
+      }
+    }
+  });
+  return scores;
+}
+async function behavioralProbe(candidateLocs, scores, options) {
+  const sorted = [...scores].sort((a, b) => Math.max(b.day, b.month, b.year) - Math.max(a.day, a.month, a.year));
+  if (sorted[0].day < 2 && sorted[0].month < 2 && sorted[0].year < 2) {
+    for (let i = 0; i < candidateLocs.length; i++) {
+      const loc = candidateLocs[i];
+      if (loc.tag === "input") {
+        const can_be_day = await loc.el.evaluate((node) => {
+          const e = node;
+          const old = e.value;
+          e.value = "31";
+          const valid = e.checkValidity();
+          e.value = old;
+          return valid;
+        }, options);
+        if (can_be_day) scores[i].day += 1;
+        const cannot_be_day = await loc.el.evaluate((node) => {
+          const e = node;
+          const old = e.value;
+          e.value = "32";
+          const valid = !e.checkValidity();
+          e.value = old;
+          return valid;
+        }, options);
+        if (cannot_be_day) scores[i].day += 1;
+        const can_be_month = await loc.el.evaluate((node) => {
+          const e = node;
+          const old = e.value;
+          e.value = "12";
+          const valid = e.checkValidity();
+          e.value = old;
+          return valid;
+        }, options);
+        if (can_be_month) scores[i].month += 1;
+        const cannot_be_month = await loc.el.evaluate((node) => {
+          const e = node;
+          const old = e.value;
+          e.value = "13";
+          const valid = !e.checkValidity();
+          e.value = old;
+          return valid;
+        }, options);
+        if (cannot_be_month) scores[i].month += 1;
+        const can_be_year = await loc.el.evaluate((node) => {
+          const e = node;
+          const old = e.value;
+          e.value = "2024";
+          const valid = e.checkValidity();
+          e.value = old;
+          return valid;
+        }, options);
+        if (can_be_year) scores[i].year += 1;
+      }
+    }
+  }
+}
+function applyTieBreakers(candidateLocs, scores) {
+  if (candidateLocs.length === 3) {
+    scores[0].day += 0.1;
+    scores[1].month += 0.1;
+    scores[2].year += 0.1;
+  }
+}
+function resolveDateFields(scores) {
+  const result = {};
+  const used = /* @__PURE__ */ new Set();
+  for (const field of ["year", "month", "day"]) {
+    let bestIdx = -1;
+    let bestScore = -1;
+    for (let i = 0; i < scores.length; i++) {
+      if (!used.has(i) && scores[i][field] > bestScore) {
+        bestScore = scores[i][field];
+        bestIdx = i;
+      }
+    }
+    if (bestIdx !== -1 && bestScore > 0) {
+      result[field] = bestIdx;
+      used.add(bestIdx);
+    }
+  }
+  if (result.day === void 0 || result.month === void 0 || result.year === void 0) {
+    return null;
+  }
+  return result;
+}
+async function setMonthField(monthLoc, monthVal, options) {
+  if (monthLoc.tag === "select") {
+    const options_list = monthLoc.options;
+    const valueMatch = options_list.find((o) => parseInt(o.value, 10) === monthVal);
+    if (valueMatch) {
+      await monthLoc.el.selectOption(valueMatch.value, options);
+    } else {
+      const offset = options_list.length === 13 ? 1 : 0;
+      await monthLoc.el.selectOption({ index: monthVal - 1 + offset }, options);
+    }
+  } else {
+    await monthLoc.el.fill(String(monthVal), options);
+  }
+}
+async function clearFields(locs, options) {
+  for (const loc of locs) {
+    if (loc.tag === "select") {
+      await clearSelect(loc.el, options);
+    } else {
+      await loc.el.clear(options);
+    }
+  }
+}
+async function setDateGroup({ el, tag }, value, options) {
+  if (!(value instanceof Date) && value !== null) return false;
+  if (tag === "input" || tag === "textarea" || tag === "select") return false;
+  const candidateLocs = await getCandidateLocs(el, options);
+  if (candidateLocs.length === 0) return false;
+  if (value === null) {
+    await clearFields(candidateLocs, options);
+    return true;
+  }
+  const scores = scoreByAttributes(candidateLocs);
+  await behavioralProbe(candidateLocs, scores, options);
+  applyTieBreakers(candidateLocs, scores);
+  const result = resolveDateFields(scores);
+  if (!result) {
+    const candidatesStr = candidateLocs.map((c) => `${c.tag}[name=${c.name}]`).join(", ");
+    throw new Error(`Could not reliably detect date fields for ${tag}. Detected candidates: ${candidatesStr}`);
+  }
+  const dayVal = value.getDate();
+  const monthVal = value.getMonth() + 1;
+  const yearVal = value.getFullYear();
+  await candidateLocs[result.day].el.fill(String(dayVal), options);
+  await setMonthField(candidateLocs[result.month], monthVal, options);
+  await candidateLocs[result.year].el.fill(String(yearVal), options);
+  return true;
+}
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function buildDateString(date, order, sep, pad) {
+  const d = date.getDate();
+  const m = date.getMonth() + 1;
+  const y = date.getFullYear();
+  const parts = {
+    day: pad ? pad2(d) : String(d),
+    month: pad ? pad2(m) : String(m),
+    year: String(y)
+  };
+  return order.map((p) => parts[p]).join(sep);
+}
+function parseDateString(value, order, sep) {
+  const raw = value.trim();
+  if (!raw) return null;
+  const tokens = raw.split(sep);
+  if (tokens.length !== 3) return null;
+  const nums = tokens.map((t) => Number(t));
+  if (nums.some((n) => !Number.isFinite(n))) return null;
+  const map = { day: 0, month: 0, year: 0 };
+  for (let i = 0; i < 3; i++) map[order[i]] = nums[i];
+  const year = map.year;
+  const month = map.month;
+  const day = map.day;
+  if (month < 1 || month > 12) return null;
+  if (day < 1 || day > 31) return null;
+  const dt = new Date(year, month - 1, day);
+  if (dt.getFullYear() !== year || dt.getMonth() !== month - 1 || dt.getDate() !== day) return null;
+  return dt;
+}
+async function inferLocaleAndPattern(el, options) {
+  return el.evaluate(() => {
+    const lang = document.documentElement.getAttribute("lang") || navigator.language || "en-US";
+    const dtf = new Intl.DateTimeFormat(lang, { year: "numeric", month: "2-digit", day: "2-digit" });
+    const parts = dtf.formatToParts(new Date(2033, 10, 22));
+    const order = [];
+    let sep = "/";
+    for (const p of parts) {
+      if (p.type === "day" || p.type === "month" || p.type === "year") order.push(p.type);
+      if (p.type === "literal") {
+        const lit = p.value.trim();
+        if (lit) sep = lit;
+      }
+    }
+    const finalOrder = order.length === 3 ? order : ["day", "month", "year"];
+    return { locale: lang, order: finalOrder, sep };
+  }, options);
+}
+async function fillAndReadBack(el, s, options, nextInput) {
+  await el.clear(options);
+  await el.fill(s, options);
+  if (nextInput) {
+    await nextInput.focus(options);
+  } else {
+    await el.evaluate((el2) => el2.blur(), options);
+  }
+  await el.evaluate(() => new Promise(requestAnimationFrame));
+  return await el.inputValue(options);
+}
+function isAmbiguous(value, value2) {
+  if (value2 && value instanceof Date) value = [value, value2];
+  return toDateArray(value).every((date) => date.getDate() <= 12);
+}
+function toDateArray(value) {
+  return isRange(value) ? [value.from, value.to] : isArray(value) ? value : [value];
+}
+async function setDateValue(el, value, order, sep, pad, options, nextInput) {
+  const dates = toDateArray(value);
+  const glue = isRange(value) ? " - " : ",";
+  const s = dates.map((d) => buildDateString(d, order, sep, pad)).join(glue);
+  const back = await fillAndReadBack(el, s, options, nextInput);
+  if (!back) return false;
+  const backParts = back.split(glue);
+  const failed = backParts.length !== dates.length || dates.some((date, i) => {
+    const part = backParts[i]?.trim();
+    const parsed = parseDateString(part, order, sep);
+    return !parsed || !sameYMD(parsed, date);
+  });
+  return !failed;
+}
+async function tryProbe(el, value, order, sep, pad, options, nextInput) {
+  const baseDate = isRange(value) ? value.from : isArray(value) ? value[0] : value;
+  const y = baseDate.getFullYear();
+  const m = baseDate.getMonth();
+  const probeMonths = [m, m - 1, m + 1];
+  for (const month of probeMonths) {
+    const probeValue = isRange(value) ? { from: new Date(y, month, 22), to: new Date(y, month, 23) } : new Date(y, month, 22);
+    const success = await setDateValue(el, probeValue, order, sep, pad, options, nextInput);
+    if (success) return true;
+  }
+  return null;
+}
+function sameYMD(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+async function formatCombinations(el, options) {
+  const { order: localeOrder, sep: localeSep } = await inferLocaleAndPattern(el, options);
+  const orders = [
+    localeOrder,
+    ["year", "month", "day"],
+    // ISO order
+    ["day", "month", "year"],
+    ["month", "day", "year"]
+  ];
+  const seenOrders = /* @__PURE__ */ new Set();
+  const uniqueOrders = [];
+  for (const o of orders) {
+    const key = o.join(",");
+    if (!seenOrders.has(key)) {
+      seenOrders.add(key);
+      uniqueOrders.push(o);
+    }
+  }
+  const seps = Array.from(/* @__PURE__ */ new Set([localeSep, "-", "/", "."]));
+  const pads = [true, false];
+  const combinations = cartesian(uniqueOrders, seps, pads);
+  const score = ([o, s]) => o.join(s) === localeOrder.join(localeSep) ? 0 : o.join(s) === "year-month-day" ? 1 : 2;
+  combinations.sort((a, b) => score(a) - score(b));
+  return { combinations, localeSep };
+}
+async function setInputValue(el, value, el2, value2, options) {
+  if (await el.evaluate((el3) => el3.readOnly, options)) return false;
+  if (el2 && await el2.evaluate((el3) => el3.readOnly, options)) return false;
+  const { combinations, localeSep } = await formatCombinations(el, options);
+  let fallbackMatch = null;
+  for (const [order, sep, pad] of combinations) {
+    if (sep !== localeSep && !pad) continue;
+    const success = await setDateValue(el, value, order, sep, pad, options, el2);
+    if (!success) continue;
+    if (el2 && value2) {
+      const success2 = await setDateValue(el2, value2, order, sep, pad, options);
+      if (!success2) continue;
+    }
+    if (!isAmbiguous(value, value2)) return true;
+    const probeResult = await tryProbe(el, value, order, sep, pad, options, el2);
+    if (probeResult === true) {
+      await setDateValue(el, value, order, sep, pad, options, el2);
+      if (el2 && value2) await setDateValue(el2, value2, order, sep, pad, options);
+      return true;
+    }
+    if (probeResult === null && !fallbackMatch) fallbackMatch = [order, sep, pad];
+  }
+  if (fallbackMatch) {
+    const [order, sep, pad] = fallbackMatch;
+    const success = await setDateValue(el, value, order, sep, pad, options, el2);
+    if (el2 && value2) {
+      const success2 = await setDateValue(el2, value2, order, sep, pad, options);
+      return success && success2;
+    }
+    return success;
+  }
+  return false;
+}
+async function setDateTextInput({ el, tag, type }, value, options) {
+  if (!(value instanceof Date) && !isArray(value, isDate) && !isRange(value, isDate)) return false;
+  if (tag === "textarea" || tag === "select") return false;
+  if (tag !== "input" && isRange(value, isDate)) {
+    const inputs = el.locator("input[type=text], input:not([type])");
+    if (await inputs.count() === 2) {
+      return await setInputValue(inputs.nth(0), value.from, inputs.nth(1), value.to, options);
+    }
+  }
+  if (tag === "input" && type && type !== "text") return false;
+  let input = el;
+  if (tag !== "input") {
+    const inputs = el.locator("input[type=text], input:not([type])");
+    if (await inputs.count() !== 1) return false;
+    input = inputs.nth(0);
+  }
+  return await setInputValue(input, value, void 0, void 0, options);
+}
+
+// src/field/native-checkbox.ts
+async function setNativeCheckbox({ el, tag, type }, value, options) {
+  if (typeof value !== "boolean" && value !== null) return false;
+  if (tag === "select" || tag === "textarea" || tag === "button") return false;
+  let target = el;
+  if (tag !== "input" || type !== "checkbox" && type !== "radio") {
+    target = el.locator("input[type=checkbox], input[type=radio]");
+    if (await target.count() !== 1) return false;
+  }
+  if (value) {
+    await target.check(options);
+  } else {
+    await target.uncheck(options);
+  }
+  return true;
+}
+async function setSingleDate({ el, tag, type }, value, options) {
+  let target = el;
+  let targetType = type;
+  if (tag !== "input" || !type || !["date", "datetime-local", "month", "week", "time"].includes(type)) {
+    const inputs = el.locator(
+      "input[type=date], input[type=datetime-local], input[type=month], input[type=week], input[type=time]"
+    );
+    if (await inputs.count() === 1) {
+      const isVisible = await inputs.evaluate((e) => {
+        const style = window.getComputedStyle(e);
+        return style.display !== "none" && style.visibility !== "hidden" && e.getAttribute("type") !== "hidden";
+      });
+      if (isVisible) {
+        target = inputs;
+        targetType = await target.getAttribute("type", options) || null;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  if (!targetType) return false;
+  const val = formatDateForInput(value, targetType);
+  await target.fill(val, options);
+  return true;
+}
+async function setDateRange({ el, tag }, value, options) {
+  if (tag === "input" || tag === "select" || tag === "textarea" || tag === "button") return false;
+  const inputs = el.locator("input[type=date]");
+  if (await inputs.count() !== 2) return false;
+  const from = formatDateForInput(value.from, "date");
+  const to = formatDateForInput(value.to, "date");
+  await inputs.nth(0).fill(from, options);
+  await inputs.nth(1).fill(to, options);
+  return true;
+}
+async function setNativeDate(loc, value, options) {
+  if (value instanceof Date) {
+    return await setSingleDate(loc, value, options);
+  }
+  if (isRange(value, isDate)) {
+    return await setDateRange(loc, value, options);
+  }
+  return false;
+}
+
+// src/field/native-input.ts
+async function setNativeInput({ el, tag }, value, options) {
+  if (tag !== "input" && tag !== "textarea") return false;
+  if (value === null) {
+    await el.clear(options);
+    return true;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    await el.fill(String(value), options);
+    return true;
+  }
+  return false;
+}
+
+// src/field/otp.ts
+async function setOtpValue({ el, tag }, value, options) {
+  if (typeof value !== "string") return false;
+  if (tag === "input" || tag === "select" || tag === "button" || tag === "textarea") return false;
+  const chars = value.replace(/\W/g, "").split("");
+  if (chars.length < 3 || chars.length > 8) return false;
+  const inputs = await el.locator('input[type="text"], input:not([type])').all();
+  if (inputs.length !== chars.length) return false;
+  for (let i = 0; i < chars.length; i++) {
+    await inputs[i].fill(chars[i], options);
+  }
+  return true;
+}
+
+// src/field/radio-group.ts
+async function setRadioGroup({ el }, value, options) {
+  if (typeof value !== "string" && typeof value !== "number") return false;
+  const stringValue = String(value);
+  if (stringValue.includes("\n") || stringValue.includes('"')) return false;
+  const radio = el.locator(`input[type=radio][value="${stringValue}"]`);
+  if (await radio.count() === 1) {
+    await radio.check(options);
+    return true;
+  }
+  const radioByLabel = el.getByLabel(String(value), { exact: true }).locator("input[type=radio]");
+  if (await radioByLabel.count() === 1) {
+    await radioByLabel.check(options);
+    return true;
+  }
+  return false;
+}
+
+// src/field/slider.ts
+async function setSliderValue({ el, tag }, value, options) {
+  if (typeof value !== "number") return false;
+  if (["input", "select", "button", "textarea"].includes(tag)) return false;
+  const slider = await getSliderElement(el, options);
+  if (!slider) return false;
+  const { min, max, orientation, valuenow: initialValue } = await getSliderAttributes(slider, options);
+  if (value < min || value > max) {
+    throw new Error(`Value ${value} is out of range [${min}, ${max}]`);
+  }
+  if (initialValue === null) return false;
+  if (initialValue === value) return true;
+  const { centerX, centerY } = await prepareMouse(slider, options);
+  const page = slider.page();
+  try {
+    const ratio = await calculateRatio(slider, initialValue, value, centerX, centerY, orientation, options);
+    await seekValue(slider, initialValue, value, centerX, centerY, orientation, ratio, options);
+  } finally {
+    await page.mouse.up();
+  }
+  return true;
+}
+async function prepareMouse(slider, options) {
+  await slider.scrollIntoViewIfNeeded(options);
+  const box = await slider.boundingBox(options);
+  if (!box) throw new Error("Slider has no bounding box");
+  const centerX = box.x + (box.width || 10) / 2;
+  const centerY = box.y + (box.height || 10) / 2;
+  const page = slider.page();
+  await page.mouse.move(centerX, centerY);
+  await page.mouse.down();
+  return { centerX, centerY };
+}
+async function seekValue(slider, initialValue, targetValue, centerX, centerY, orientation, ratio, options) {
+  const page = slider.page();
+  for (let i = 0; i < 4; i++) {
+    const distance = (targetValue - initialValue) / ratio;
+    await moveMouse(page, centerX, centerY, orientation, distance);
+    const currentValAttr = await slider.getAttribute("aria-valuenow", options);
+    const currentVal = parseFloat(currentValAttr || "0");
+    if (currentVal === targetValue) break;
+    if (distance !== 0) {
+      const newRatio = (currentVal - initialValue) / distance;
+      if (newRatio !== 0) ratio = newRatio;
+    }
+  }
+}
+async function calculateRatio(slider, initialValue, targetValue, centerX, centerY, orientation, options) {
+  const page = slider.page();
+  const testMove = targetValue > initialValue ? 20 : -20;
+  await moveMouse(page, centerX, centerY, orientation, testMove);
+  const valAfterMoveAttr = await slider.getAttribute("aria-valuenow", options);
+  const valAfterMove = parseFloat(valAfterMoveAttr || "0");
+  const diff = valAfterMove - initialValue;
+  if (diff === 0) {
+    throw new Error("Slider appears to be disabled or unresponsive");
+  }
+  return diff / testMove;
+}
+async function getSliderElement(el, options) {
+  const role = await el.getAttribute("role", options).catch(() => null);
+  if (role === "slider") return el;
+  const slider = el.getByRole("slider");
+  if (await slider.count() > 0) {
+    return slider.first();
+  }
+  return null;
+}
+async function getSliderAttributes(slider, options) {
+  const [minStr, maxStr, orient, nowStr] = await Promise.all([
+    slider.getAttribute("aria-valuemin", options),
+    slider.getAttribute("aria-valuemax", options),
+    slider.getAttribute("aria-orientation", options),
+    slider.getAttribute("aria-valuenow", options)
+  ]);
+  return {
+    min: parseFloat(minStr || "0"),
+    max: parseFloat(maxStr || "100"),
+    orientation: orient || "horizontal",
+    valuenow: nowStr !== null ? parseFloat(nowStr) : null
+  };
+}
+async function moveMouse(page, centerX, centerY, orientation, distance) {
+  if (orientation === "vertical") {
+    await page.mouse.move(centerX, centerY - distance);
+  } else {
+    await page.mouse.move(centerX + distance, centerY);
+  }
+}
+
+// src/field/index.ts
+function toString(value) {
+  if (isRange(value)) return `${String(value.from)} - ${String(value.to)}`;
+  if (isArray(value)) return value.map((v) => String(v)).join("\n");
+  return String(value);
+}
+async function setFallback({ el }, value, options) {
+  await el.fill(toString(value), options);
+  return true;
+}
+async function setFieldValue(el, value, options) {
+  const setValue = chain(
+    // native
+    selectNative,
+    setNativeCheckbox,
+    setRadioGroup,
+    setNativeDate,
+    setNativeInput,
+    // aria / components
+    setDateTextInput,
+    setDateGroup,
+    setCalendarDate,
+    setOtpValue,
+    setSliderValue,
+    // fallback (eg contenteditable or will fail)
+    setFallback
+  );
+  if (await el.count() > 1) {
+    el = await pickFieldElement(el);
+  }
+  const tag = await el.evaluate((e) => e.tagName.toLowerCase(), options);
+  const type = await el.getAttribute("type", options).then((s) => s && s.toLowerCase()).catch(() => null);
+  const loc = { el, tag, type };
+  await setValue(loc, value, options);
+}
+async function formatHtml(page) {
+  const html = typeof page === "string" ? page : await page.content();
+  const file = await unified().use(rehypeParse, { fragment: true }).use(rehypeFormat, { indent: 2 }).use(rehypeStringify).process(html);
+  return String(file);
+}
+
+// src/locator.ts
+async function locator(page, selector) {
+  const primary = page.locator(selector).first();
+  if (await primary.count()) return primary;
+  return await tryRelaxNameToHasText(page, selector) || await tryTagInsteadOfRole(page, selector) || await tryRoleNameProximity(page, selector) || await tryFieldAlternative(page, selector) || await tryAsField(page, selector) || primary;
+}
+async function firstMatch(page, sel, opts = {}) {
+  for (const selector of Array.isArray(sel) ? sel : [sel]) {
+    const loc = page.locator(selector, opts).first();
+    if (await loc.count()) return loc;
+  }
+  return null;
+}
+async function tryRelaxNameToHasText(page, selector) {
+  const matchAnyNameFull = selector.match(/^(role=.*)\[name="([^"]+)"i?](.*)$/i);
+  if (!matchAnyNameFull) return null;
+  const [, pre, nameText, post] = matchAnyNameFull;
+  const containsSelector = `${pre}${post}`;
+  return firstMatch(page, containsSelector, { hasText: nameText });
+}
+async function tryTagInsteadOfRole(page, selector) {
+  const matchAnyNameFull = selector.match(/^role=(link|button|option)\s*\[name="([^"]+)"i?](.*)$/i);
+  if (!matchAnyNameFull) return null;
+  const [, role, nameText, post] = matchAnyNameFull;
+  const tag = role === "link" ? "a" : role;
+  const containsSelector = `css=${tag}${post}`;
+  return firstMatch(page, containsSelector, { hasText: nameText });
+}
+async function tryRoleNameProximity(page, selector) {
+  const matchRole = selector.match(/^role=(\w+)\s*\[name="([^"]+)"i?](.*)$/i);
+  if (!matchRole) return null;
+  const [, role, name, rest] = matchRole;
+  const proximitySelector = `text=${name} >> .. >> role=${role}${rest}`;
+  return firstMatch(page, proximitySelector);
+}
+async function tryFieldAlternative(page, selector) {
+  const matchField = selector.match(/^field="([^"]+)"i?$/i);
+  if (!matchField) return null;
+  const [, field] = matchField;
+  return firstMatch(page, `#${field} > input`);
+}
+async function tryAsField(page, selector) {
+  const matchRole = selector.match(/^role=(\w+)\s*\[name="([^"]+)"i?](.*)$/i);
+  if (!matchRole) return null;
+  const [, role, name, rest] = matchRole;
+  const fieldRoles = /* @__PURE__ */ new Set([
+    "button",
+    // Sometimes used for date pickers or checkboxes
+    "textbox",
+    "searchbox",
+    "combobox",
+    "spinbutton",
+    "slider",
+    "checkbox",
+    "switch",
+    "radio",
+    "radiogroup",
+    "listbox",
+    "option"
+  ]);
+  if (!fieldRoles.has(role.toLowerCase())) return null;
+  return firstMatch(page, `field=${name}${rest}`);
+}
+
+// src/selector/date-selector.ts
+var createDateEngine = () => ({
+  // Single match (Playwright will call this in some contexts)
+  query(root, body) {
+    const all = this.queryAll(root, body);
+    return all[0] ?? null;
+  },
+  // All matches
+  queryAll(root, body) {
+    const targetDate = this._parseSelector(body);
+    if (!targetDate) return [];
+    const doc = root instanceof Document ? root : root.ownerDocument || document;
+    const locale = doc.documentElement.lang || "en-US";
+    const candidates = [];
+    const walker = doc.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
+    let currentNode = walker.nextNode();
+    while (currentNode) {
+      const el = currentNode;
+      const { matched, type } = this._matchesDate(el, targetDate, locale, body);
+      if (matched) {
+        candidates.push({ el, type });
+      }
+      currentNode = walker.nextNode();
+    }
+    const results = candidates.filter((c) => {
+      const el = c.el;
+      const hasMatchingDescendant = candidates.some((other) => {
+        if (other.el === el || !el.contains(other.el)) return false;
+        return !(c.type === "full" && other.type === "partial");
+      });
+      return !hasMatchingDescendant;
+    }).map((c) => c.el);
+    if (results.length === 0 && candidates.length > 0) ;
+    return results;
+  },
+  _parseSelector(body) {
+    const now = /* @__PURE__ */ new Date();
+    const trimmed = body.toLowerCase().trim();
+    if (trimmed === "today") return now;
+    if (trimmed === "tomorrow") {
+      const d = new Date(now);
+      d.setDate(d.getDate() + 1);
+      return d;
+    }
+    if (trimmed === "yesterday") {
+      const d = new Date(now);
+      d.setDate(d.getDate() - 1);
+      return d;
+    }
+    const relativeMatch = trimmed.match(/^(\d+)\s+(day|month|year)s?\s+(ago|from now)$/);
+    if (relativeMatch) {
+      const [_, amount, unit, direction] = relativeMatch;
+      const d = new Date(now);
+      const sign = direction === "ago" ? -1 : 1;
+      const val = parseInt(amount, 10) * sign;
+      if (unit === "day") d.setDate(d.getDate() + val);
+      else if (unit === "month") d.setMonth(d.getMonth() + val);
+      else if (unit === "year") d.setFullYear(d.getFullYear() + val);
+      return d;
+    }
+    const atMatch = trimmed.match(/^(today|tomorrow|yesterday)\s+at\s+(\d{1,2}):(\d{2})(?::(\d{2}))?(?:\s*(am|pm))?$/);
+    if (atMatch) {
+      const [_, dayStr, hourStr, min, sec, ampm] = atMatch;
+      const d = new Date(now);
+      if (dayStr === "tomorrow") d.setDate(d.getDate() + 1);
+      if (dayStr === "yesterday") d.setDate(d.getDate() - 1);
+      let hour = parseInt(hourStr, 10);
+      if (ampm === "pm" && hour < 12) hour += 12;
+      if (ampm === "am" && hour === 12) hour = 0;
+      d.setHours(hour, parseInt(min, 10), parseInt(sec || "0", 10), 0);
+      return d;
+    }
+    const absDate = new Date(body);
+    if (!isNaN(absDate.getTime())) return absDate;
+    return null;
+  },
+  _matchesDate(el, targetDate, locale, body) {
+    const text = el.textContent?.trim() || "";
+    if (!text) return { matched: false, type: "partial" };
+    const normalizedText = text.replace(/\s+/g, " ").trim();
+    const cleanText = normalizedText.toLowerCase().replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, " ").replace(/\s+/g, " ").trim();
+    const options = [
+      { year: "numeric", month: "short", day: "numeric" },
+      { year: "numeric", month: "long", day: "numeric" },
+      { year: "2-digit", month: "numeric", day: "numeric" },
+      { year: "numeric", month: "numeric", day: "numeric" },
+      { month: "short", day: "numeric" },
+      { month: "long", day: "numeric" }
+    ];
+    let dateMatched = false;
+    let matchType = "partial";
+    for (const opt of options) {
+      const formatter = new Intl.DateTimeFormat(locale, opt);
+      const formatted = formatter.format(targetDate);
+      const normalizedFormatted = formatted.replace(/\s+/g, " ").trim();
+      const cleanFormatted = normalizedFormatted.toLowerCase().replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, " ").replace(/\s+/g, " ").trim();
+      if (normalizedText.includes(normalizedFormatted) || cleanText.includes(cleanFormatted)) {
+        if (opt.year && opt.month === "numeric" && opt.day === "numeric") {
+          const yearVal = targetDate.getFullYear().toString();
+          const shortYearVal = yearVal.slice(-2);
+          if (!normalizedText.includes(yearVal) && !normalizedText.includes(shortYearVal)) {
+            continue;
+          }
+        }
+        if (opt.year && (opt.month === "short" || opt.month === "long")) {
+          const yearVal = targetDate.getFullYear().toString();
+          const otherYearMatch = normalizedText.match(/\b\d{4}\b/g);
+          if (otherYearMatch && !otherYearMatch.includes(yearVal)) {
+            continue;
+          }
+        }
+        dateMatched = true;
+        if (opt.year) matchType = "full";
+        break;
+      }
+      if (opt.month === "numeric" && opt.day === "numeric") {
+        const parts = formatter.formatToParts(targetDate);
+        const day = parts.find((p) => p.type === "day")?.value;
+        const month = parts.find((p) => p.type === "month")?.value;
+        const year = parts.find((p) => p.type === "year")?.value;
+        if (day && month) {
+          const seps = [".", "-", "/", " ", ""];
+          const d2 = day.padStart(2, "0");
+          const m2 = month.padStart(2, "0");
+          const dayVariations = Array.from(/* @__PURE__ */ new Set([day, d2]));
+          const monthVariations = Array.from(/* @__PURE__ */ new Set([month, m2]));
+          let numericMatched = false;
+          for (const sep of seps) {
+            for (const d of dayVariations) {
+              for (const m of monthVariations) {
+                if (year) {
+                  const y2 = year.slice(-2);
+                  const yearVariations = Array.from(/* @__PURE__ */ new Set([year, y2]));
+                  for (const y of yearVariations) {
+                    if (normalizedText.includes(`${d}${sep}${m}${sep}${y}`) || normalizedText.includes(`${m}${sep}${d}${sep}${y}`) || normalizedText.includes(`${y}${sep}${m}${sep}${d}`)) {
+                      numericMatched = true;
+                      matchType = "full";
+                      break;
+                    }
+                  }
+                }
+                if (numericMatched) break;
+                if (normalizedText.includes(`${d}${sep}${m}`) || normalizedText.includes(`${m}${sep}${d}`)) {
+                  if (!normalizedText.match(/\d{4}/)) {
+                    numericMatched = true;
+                    matchType = "partial";
+                  }
+                }
+              }
+              if (numericMatched) break;
+            }
+            if (numericMatched) break;
+          }
+          if (numericMatched) {
+            dateMatched = true;
+            break;
+          }
+        }
+      }
+    }
+    if (!dateMatched && normalizedText.includes(targetDate.toISOString().split("T")[0])) {
+      dateMatched = true;
+      matchType = "full";
+    }
+    if (!dateMatched) return { matched: false, type: "partial" };
+    const queryHasYear = body.match(/\d{4}|'\d{2}/);
+    if (queryHasYear && matchType === "partial") {
+      return { matched: false, type: "partial" };
+    }
+    const elementYearMatch = normalizedText.match(/\b\d{4}\b/g);
+    if (elementYearMatch && elementYearMatch.some((y) => parseInt(y, 10) !== targetDate.getFullYear())) {
+      if (!elementYearMatch.includes(targetDate.getFullYear().toString())) {
+        return { matched: false, type: "partial" };
+      }
+    }
+    const queryStr = body.toLowerCase();
+    const queryHasTime = queryStr.includes(" at ") || queryStr.includes(":") || (queryStr.includes("am") || queryStr.includes("pm"));
+    if (queryHasTime) {
+      const timeMatch = normalizedText.match(/(\d{1,2})[:.](\d{2})(?::(\d{2}))?\s*(am|pm|om|u)?/i);
+      if (timeMatch) {
+        const [_, h, m, s, ampm] = timeMatch;
+        let hour = parseInt(h, 10);
+        if (ampm?.toLowerCase() === "pm" && hour < 12) hour += 12;
+        if (ampm?.toLowerCase() === "am" && hour === 12) hour = 0;
+        if (hour !== targetDate.getHours() || parseInt(m, 10) !== targetDate.getMinutes()) {
+          return { matched: false, type: "full" };
+        }
+        if (s && parseInt(s, 10) !== targetDate.getSeconds()) {
+          return { matched: false, type: "full" };
+        }
+      } else {
+        return { matched: false, type: "full" };
+      }
+    }
+    return { matched: true, type: matchType };
+  }
+});
+
+// src/selector/field-selector.ts
+var createFieldEngine = () => ({
+  // Helper: compile matcher from `field=...` body
+  _compileMatcher(body) {
+    const trimmed = body.trim();
+    if (trimmed.startsWith("/") && trimmed.lastIndexOf("/") > 0) {
+      const last = trimmed.lastIndexOf("/");
+      const pattern = trimmed.slice(1, last);
+      const flags = trimmed.slice(last + 1);
+      const re = new RegExp(pattern, flags);
+      return (s) => !!s && re.test(s);
+    }
+    const sanitize = (s) => s.toLowerCase().replace(/[^\w\s]+/g, "").replace(/\s{2,}/g, " ").replace(/\*\s*$/, "").trim();
+    const needle = sanitize(trimmed.replace(/^"(.*)"(i?)$/, "$1"));
+    return ((s) => !!s && sanitize(s) === needle);
+  },
+  // Single match (Playwright will call this in some contexts)
+  query(root, body) {
+    const all = this.queryAll(root, body);
+    return all[0] ?? null;
+  },
+  // All matches
+  queryAll(root, body) {
+    const match = this._compileMatcher(body);
+    const candidates = Array.from(
+      root.querySelectorAll(
+        [
+          "input",
+          "textarea",
+          "select",
+          '[role="textbox"]',
+          '[role="combobox"]',
+          '[role="spinbutton"]',
+          '[role="slider"]',
+          '[role="switch"]',
+          '[role="checkbox"]',
+          '[role="radio"]',
+          '[role="radiogroup"]',
+          '[contenteditable=""]',
+          '[contenteditable="true"]'
+        ].join(", ")
+      )
+    );
+    const byId = /* @__PURE__ */ new Map();
+    Array.from(root.querySelectorAll("[id]")).forEach((el) => byId.set(el.id, el));
+    function textFor(el) {
+      const texts = [];
+      let parent = el.parentElement;
+      while (parent) {
+        if (parent.tagName === "LABEL") {
+          texts.push(parent.textContent ?? "");
+          break;
+        }
+        parent = parent.parentElement;
+      }
+      let id = el.id;
+      if (!id) {
+        const p = el.parentElement;
+        if (p && (p.tagName === "DIV" || p.tagName === "SPAN") && p.id) {
+          id = p.id;
+        }
+      }
+      if (id) {
+        const forLabels = Array.from(
+          root.querySelectorAll(`label[for="${CSS.escape(id)}"]`)
+        );
+        forLabels.forEach((l) => texts.push(l.textContent ?? ""));
+      }
+      const ariaLabel = el.getAttribute("aria-label");
+      if (ariaLabel) texts.push(ariaLabel);
+      const labelledBy = el.getAttribute("aria-labelledby");
+      if (labelledBy) {
+        const extAriaLabel = labelledBy.split(/\s+/).map((idref) => byId.get(idref)).filter((ref) => !!ref?.textContent.trim()).map((ref) => ref.textContent).join(" ");
+        if (extAriaLabel) texts.push(extAriaLabel);
+      }
+      const name = el.getAttribute("name");
+      if (name) texts.push(name);
+      const ph = el.placeholder ?? el.getAttribute("placeholder");
+      if (ph) texts.push(ph);
+      return texts;
+    }
+    return candidates.map((el) => ({ el, texts: textFor(el) })).filter(({ texts }) => texts.some(match)).map(({ el }) => el);
+  }
+});
+async function screenshot(page, options) {
+  const buffer = options?.mask?.length ? await screenshotWithMask(page, options) : await page.screenshot(options);
+  const filename = await hashKey(`screenshot-{hash}.png`, buffer);
+  return new File([new Uint8Array(buffer)], filename, { type: "image/png" });
+}
+async function screenshotWithMask(page, options) {
+  const { mask: locators, ...otherOptions } = options;
+  if (!locators?.length) throw new Error("No locators specified");
+  await page.evaluate(() => {
+    const doc = document;
+    if (!doc.getElementById("lri-mask-style")) {
+      const style = doc.createElement("style");
+      style.id = "lri-mask-style";
+      style.textContent = `
+        .lri-mask-overlay {
+          position: fixed;
+          inset: 0;
+          background: rgba(0, 0, 0, 0.65);
+          pointer-events: none;
+          z-index: 2147483646;
+        }
+        .lri-mask-highlight {
+          position: relative !important;
+          z-index: 2147483647 !important;
+          box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.95);
+          border-radius: 4px;
+        }
+      `;
+      doc.head.appendChild(style);
+    }
+    if (!doc.getElementById("lri-mask-overlay")) {
+      const overlay = doc.createElement("div");
+      overlay.id = "lri-mask-overlay";
+      overlay.className = "lri-mask-overlay";
+      doc.body.appendChild(overlay);
+    }
+  });
+  const handleGroups = await Promise.all(locators.map((loc) => loc.elementHandles()));
+  const handles = handleGroups.flat();
+  await Promise.all(
+    handles.map(
+      (h) => h.evaluate((el) => {
+        el.classList.add("lri-mask-highlight");
+      })
+    )
+  );
+  try {
+    return await page.screenshot(otherOptions);
+  } finally {
+    await Promise.all(
+      handles.map(
+        (h) => h.evaluate((el) => {
+          el.classList.remove("lri-mask-highlight");
+        })
+      )
+    );
+    await page.evaluate(() => {
+      const overlay = document.getElementById("lri-mask-overlay");
+      if (overlay) overlay.remove();
+      const style = document.getElementById("lri-mask-style");
+      if (style) style.remove();
+    });
+  }
+}
+
+// src/snapshot.ts
+async function snapshot(page) {
+  await sleep(500);
+  await waitForDomIdle(page);
+  const [url, html, file] = await Promise.all([page.url(), getContentWithMarkedHidden(page), screenshot(page)]);
+  return { url, html, screenshot: file };
+}
+async function getContentWithMarkedHidden(page) {
+  try {
+    await page.evaluate(() => {
+      const changed = [];
+      window.__undoAriaHidden = () => {
+        for (const el of changed) el.removeAttribute("aria-hidden");
+        changed.length = 0;
+        delete window.__undoAriaHidden;
+      };
+      const isHidden = (el) => {
+        if (el.hasAttribute("hidden")) return true;
+        if (el.hasAttribute("inert")) return true;
+        if (el.getAttribute("aria-hidden") === "true") return true;
+        const cs = getComputedStyle(el);
+        return cs.display === "none" || cs.visibility === "hidden" || cs.opacity === "0";
+      };
+      const walk = (el) => {
+        if (isHidden(el)) {
+          if (!el.hasAttribute("aria-hidden")) {
+            el.setAttribute("aria-hidden", "true");
+            changed.push(el);
+          }
+          return;
+        }
+        for (const c of el.children) walk(c);
+      };
+      for (const c of document.body.children) walk(c);
+    });
+    return await page.content();
+  } finally {
+    await page.evaluate(() => window.__undoAriaHidden?.()).catch(() => {
+    });
+  }
+}
+
+// src/scroll.ts
+async function scrollToCenter(locator2) {
+  const count = await locator2.count();
+  if (!count) return;
+  await locator2.evaluate((el) => {
+    el.scrollIntoView({ block: "center", inline: "center", behavior: "instant" });
+  });
+}
+
+// src/translations/af.ts
+var translations = {
+  accept: [
+    "Aanvaar",
+    "Aanvaar alles",
+    "Stem saam",
+    "Laat toe",
+    "Laat alles toe",
+    "OK",
+    "Reg so",
+    "Ek verstaan",
+    "Gaan voort",
+    "Stoor en aanvaar",
+    "Bevestig"
+  ],
+  reject: [
+    "Verwerp",
+    "Verwerp alles",
+    "Weier",
+    "Moenie toelaat nie",
+    "Slegs noodsaaklik",
+    "Net noodsaaklike koekies",
+    "Gaan voort sonder koekies",
+    "Nee dankie",
+    "Moenie aanvaar nie",
+    "Weier alles"
+  ],
+  close: [
+    "Sluit",
+    "Kanselleer",
+    "Maak toe",
+    "Verwyder",
+    "Nie nou nie",
+    "Nee dankie",
+    "Later",
+    "\xD7",
+    "Slaan oor",
+    "Maak venster toe"
+  ]
+};
+var af_default = translations;
+
+// src/translations/ar.ts
+var translations2 = {
+  accept: ["\u0645\u0648\u0627\u0641\u0642", "\u0623\u0648\u0627\u0641\u0642", "\u0642\u0628\u0648\u0644", "\u0642\u0628\u0648\u0644 \u0627\u0644\u0643\u0644", "\u0627\u0644\u0645\u0648\u0627\u0641\u0642\u0629 \u0639\u0644\u0649 \u0627\u0644\u0643\u0644", "\u0627\u0644\u0633\u0645\u0627\u062D", "\u062D\u0633\u0646\u064B\u0627", "\u062A\u0645", "\u062A\u0645\u0627\u0645", "\u0645\u062A\u0627\u0628\u0639\u0629", "\u062A\u0627\u0628\u0639", "\u062D\u0641\u0638 \u0648\u0627\u0644\u0645\u0648\u0627\u0641\u0642\u0629", "\u062D\u0641\u0638 \u0648\u0627\u0644\u0642\u0628\u0648\u0644"],
+  reject: ["\u0631\u0641\u0636", "\u0631\u0641\u0636 \u0627\u0644\u0643\u0644", "\u0639\u062F\u0645 \u0627\u0644\u0645\u0648\u0627\u0641\u0642\u0629", "\u0639\u062F\u0645 \u0627\u0644\u0633\u0645\u0627\u062D", "\u0627\u0644\u0636\u0631\u0648\u0631\u064A\u0629 \u0641\u0642\u0637", "\u0627\u0644\u0623\u0633\u0627\u0633\u064A\u0629 \u0641\u0642\u0637", "\u0627\u0644\u0645\u062A\u0627\u0628\u0639\u0629 \u0628\u062F\u0648\u0646 \u0645\u0644\u0641\u0627\u062A \u062A\u0639\u0631\u064A\u0641 \u0627\u0644\u0627\u0631\u062A\u0628\u0627\u0637", "\u0627\u0644\u0627\u0633\u062A\u0645\u0631\u0627\u0631 \u0628\u062F\u0648\u0646 \u0645\u0644\u0641\u0627\u062A \u062A\u0639\u0631\u064A\u0641 \u0627\u0644\u0627\u0631\u062A\u0628\u0627\u0637", "\u0644\u0627 \u0634\u0643\u0631\u064B\u0627", "\u0644\u0627\u060C \u0634\u0643\u0631\u064B\u0627"],
+  close: ["\u0625\u063A\u0644\u0627\u0642", "\u0625\u0644\u063A\u0627\u0621", "\u062A\u062C\u0627\u0647\u0644", "\u0644\u064A\u0633 \u0627\u0644\u0622\u0646", "\u0644\u0627 \u0634\u0643\u0631\u064B\u0627", "\u0644\u0627\u062D\u0642\u064B\u0627", "\xD7", "\u0625\u062E\u0641\u0627\u0621", "\u062A\u062E\u0637\u064A"]
+};
+var ar_default = translations2;
+
+// src/translations/az.ts
+var translations3 = {
+  accept: [
+    "Q\u0259bul et",
+    "Ham\u0131s\u0131n\u0131 q\u0259bul et",
+    "Raz\u0131yam",
+    "T\u0259sdiq et",
+    "\u0130caz\u0259 ver",
+    "Ham\u0131s\u0131na icaz\u0259 ver",
+    "OK",
+    "Oldu",
+    "Ba\u015Fa d\xFC\u015Fd\xFCm",
+    "Anlad\u0131m",
+    "Davam et",
+    "Saxla v\u0259 q\u0259bul et"
+  ],
+  reject: [
+    "R\u0259dd et",
+    "Ham\u0131s\u0131n\u0131 r\u0259dd et",
+    "\u0130mtina et",
+    "\u0130caz\u0259 verm\u0259",
+    "Yaln\u0131z z\u0259ruri kukil\u0259r",
+    "Yaln\u0131z z\u0259ruri",
+    "Kukil\u0259rsiz davam et",
+    "He\xE7 birin\u0259 icaz\u0259 verm\u0259",
+    "Q\u0259bul etmir\u0259m",
+    "Yox, sa\u011F olun"
+  ],
+  close: [
+    "Ba\u011Fla",
+    "L\u0259\u011Fv et",
+    "Geri",
+    "Ke\xE7",
+    "\u0130ndi yox",
+    "Sonra",
+    "Yox, sa\u011F olun",
+    "\xD7"
+  ]
+};
+var az_default = translations3;
+
+// src/translations/bg.ts
+var translations4 = {
+  accept: ["\u041F\u0440\u0438\u0435\u043C\u0438", "\u041F\u0440\u0438\u0435\u043C\u0438 \u0432\u0441\u0438\u0447\u043A\u0438", "\u0421\u044A\u0433\u043B\u0430\u0441\u044F\u0432\u0430\u043C \u0441\u0435", "\u0421\u044A\u0433\u043B\u0430\u0441\u0435\u043D \u0441\u044A\u043C", "\u0420\u0430\u0437\u0440\u0435\u0448\u0438", "\u0420\u0430\u0437\u0440\u0435\u0448\u0438 \u0432\u0441\u0438\u0447\u043A\u0438", "\u041E\u041A", "\u0414\u043E\u0431\u0440\u0435", "\u0420\u0430\u0437\u0431\u0440\u0430\u0445", "\u041F\u0440\u043E\u0434\u044A\u043B\u0436\u0438", "\u0417\u0430\u043F\u0430\u0437\u0438 \u0438 \u043F\u0440\u0438\u0435\u043C\u0438", "\u0414\u0430, \u043F\u0440\u0438\u0435\u043C\u0430\u043C"],
+  reject: ["\u041E\u0442\u043A\u0430\u0436\u0438", "\u041E\u0442\u043A\u0430\u0436\u0438 \u0432\u0441\u0438\u0447\u043A\u0438", "\u041E\u0442\u043A\u0430\u0437\u0432\u0430\u043C", "\u041E\u0442\u0445\u0432\u044A\u0440\u043B\u0438", "\u0421\u0430\u043C\u043E \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u0438\u0442\u0435", "\u0421\u0430\u043C\u043E \u0437\u0430\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u0438\u0442\u0435", "\u0421\u0430\u043C\u043E \u043E\u0441\u043D\u043E\u0432\u043D\u0438\u0442\u0435", "\u041F\u0440\u043E\u0434\u044A\u043B\u0436\u0438 \u0431\u0435\u0437 \u0431\u0438\u0441\u043A\u0432\u0438\u0442\u043A\u0438", "\u041D\u0435, \u0431\u043B\u0430\u0433\u043E\u0434\u0430\u0440\u044F", "\u0417\u0430\u0431\u0440\u0430\u043D\u0438", "\u0417\u0430\u0431\u0440\u0430\u043D\u0438 \u0432\u0441\u0438\u0447\u043A\u0438", "\u041D\u0435 \u043F\u043E\u0437\u0432\u043E\u043B\u044F\u0432\u0430\u043C"],
+  close: ["\u0417\u0430\u0442\u0432\u043E\u0440\u0438", "\u041E\u0442\u043A\u0430\u0437", "\u041E\u0442\u043C\u0435\u043D\u0438", "\u0421\u043A\u0440\u0438\u0439", "\u041D\u0435 \u0441\u0435\u0433\u0430", "\u041F\u043E-\u043A\u044A\u0441\u043D\u043E", "\u041D\u0435, \u0431\u043B\u0430\u0433\u043E\u0434\u0430\u0440\u044F", "\u0413\u043E\u0442\u043E\u0432\u043E", "\xD7"]
+};
+var bg_default = translations4;
+
+// src/translations/bn.ts
+var translations5 = {
+  accept: [
+    "\u09B8\u09CD\u09AC\u09C0\u0995\u09BE\u09B0 \u0995\u09B0\u09C1\u09A8",
+    "\u09B8\u09AC \u09B8\u09CD\u09AC\u09C0\u0995\u09BE\u09B0 \u0995\u09B0\u09C1\u09A8",
+    "\u09B8\u09AE\u09CD\u09AE\u09A4\u09BF \u09A6\u09BF\u099A\u09CD\u099B\u09BF",
+    "\u09B8\u09AE\u09CD\u09AE\u09A4",
+    "\u0985\u09A8\u09C1\u09AE\u09A4\u09BF \u09A6\u09BF\u09A8",
+    "\u09B8\u09AC \u0985\u09A8\u09C1\u09AE\u09A4\u09BF \u09A6\u09BF\u09A8",
+    "\u09A0\u09BF\u0995 \u0986\u099B\u09C7",
+    "\u09AC\u09CB\u099D\u09BE \u0997\u09C7\u09B2",
+    "\u099A\u09BE\u09B2\u09BF\u09AF\u09BC\u09C7 \u09AF\u09BE\u09A8",
+    "\u09B8\u0982\u09B0\u0995\u09CD\u09B7\u09A3 \u0995\u09B0\u09C7 \u09B8\u09CD\u09AC\u09C0\u0995\u09BE\u09B0",
+    "\u09B8\u09C7\u09AD \u0995\u09B0\u09C7 \u099A\u09BE\u09B2\u09BF\u09AF\u09BC\u09C7 \u09AF\u09BE\u09A8",
+    "\u0986\u09AE\u09BF \u09B0\u09BE\u099C\u09BF"
+  ],
+  reject: [
+    "\u09AA\u09CD\u09B0\u09A4\u09CD\u09AF\u09BE\u0996\u09CD\u09AF\u09BE\u09A8 \u0995\u09B0\u09C1\u09A8",
+    "\u09B8\u09AC \u09AA\u09CD\u09B0\u09A4\u09CD\u09AF\u09BE\u0996\u09CD\u09AF\u09BE\u09A8 \u0995\u09B0\u09C1\u09A8",
+    "\u09A8\u09BE\u09AE\u099E\u09CD\u099C\u09C1\u09B0",
+    "\u0985\u09A8\u09C1\u09AE\u09A4\u09BF \u09A6\u09C7\u09AC \u09A8\u09BE",
+    "\u09B6\u09C1\u09A7\u09C1 \u09AA\u09CD\u09B0\u09AF\u09BC\u09CB\u099C\u09A8\u09C0\u09AF\u09BC",
+    "\u09B6\u09C1\u09A7\u09C1\u09AE\u09BE\u09A4\u09CD\u09B0 \u09A6\u09B0\u0995\u09BE\u09B0\u09BF",
+    "\u0995\u09C1\u0995\u09BF \u099B\u09BE\u09A1\u09BC\u09BE\u0987 \u099A\u09BE\u09B2\u09BF\u09AF\u09BC\u09C7 \u09AF\u09BE\u09A8",
+    "\u09A8\u09BE, \u09A7\u09A8\u09CD\u09AF\u09AC\u09BE\u09A6",
+    "\u09A8\u09BE",
+    "\u09B8\u09AE\u09CD\u09AE\u09A4\u09BF \u09A6\u09BF\u099A\u09CD\u099B\u09BF \u09A8\u09BE"
+  ],
+  close: [
+    "\u09AC\u09A8\u09CD\u09A7 \u0995\u09B0\u09C1\u09A8",
+    "\u09AC\u09BE\u09A4\u09BF\u09B2",
+    "\u0995\u09CD\u09AF\u09BE\u09A8\u09CD\u09B8\u09C7\u09B2",
+    "\u098F\u0996\u09A8 \u09A8\u09AF\u09BC",
+    "\u09AA\u09B0\u09C7",
+    "\u09A8\u09BE, \u09A7\u09A8\u09CD\u09AF\u09AC\u09BE\u09A6",
+    "\u09A6\u09C7\u0996\u09C7\u099B\u09BF",
+    "\xD7"
+  ]
+};
+var bn_default = translations5;
+
+// src/translations/bs.ts
+var translations6 = {
+  accept: ["Prihvati", "Prihvati sve", "Sla\u017Eem se", "Dozvoli", "Dozvoli sve", "U redu", "OK", "Razumijem", "Nastavi", "Sa\u010Duvaj i prihvati", "Potvrdi", "Prihvati i nastavi"],
+  reject: ["Odbij", "Odbij sve", "Ne prihvatam", "Ne dozvoli", "Samo neophodni", "Samo obavezni", "Nastavi bez kola\u010Di\u0107a", "Ne, hvala", "Onemogu\u0107i sve"],
+  close: ["Zatvori", "Otka\u017Ei", "Odustani", "Odbaci", "Ne sada", "Ne, hvala", "Kasnije", "\xD7"]
+};
+var bs_default = translations6;
+
+// src/translations/ca.ts
+var translations7 = {
+  accept: [
+    "Acceptar",
+    "Acceptar-ho tot",
+    "D'acord",
+    "Permetre",
+    "Permetre-ho tot",
+    "OK",
+    "Entesos",
+    "Ho entenc",
+    "Continuar",
+    "Desa i accepta",
+    "S\xED, accepto"
+  ],
+  reject: [
+    "Rebutjar",
+    "Rebutjar-ho tot",
+    "Denegar",
+    "No permetre",
+    "Nom\xE9s les necess\xE0ries",
+    "Nom\xE9s essencials",
+    "Continuar sense galetes",
+    "No, gr\xE0cies",
+    "Desactivar totes",
+    "Continuar sense acceptar"
+  ],
+  close: [
+    "Tancar",
+    "Cancel\xB7lar",
+    "Descartar",
+    "Ara no",
+    "No, gr\xE0cies",
+    "M\xE9s tard",
+    "\xD7",
+    "Tanca la finestra",
+    "Ometre",
+    "Fer-ho m\xE9s tard"
+  ]
+};
+var ca_default = translations7;
+
+// src/translations/cs.ts
+var translations8 = {
+  accept: ["P\u0159ijmout", "P\u0159ijmout v\u0161e", "Souhlas\xEDm", "Povolit", "Povolit v\u0161e", "OK", "Rozum\xEDm", "Pokra\u010Dovat", "Ulo\u017Eit a p\u0159ijmout", "Potvrdit"],
+  reject: ["Odm\xEDtnout", "Odm\xEDtnout v\u0161e", "Nesouhlas\xEDm", "Nepovolovat", "Pouze nezbytn\xE9", "Jen nezbytn\xE9", "Pouze nutn\xE9 cookies", "Pouze z\xE1kladn\xED", "Pokra\u010Dovat bez cookies", "Ne, d\xEDky"],
+  close: ["Zav\u0159\xEDt", "Zru\u0161it", "Skr\xFDt", "Ne te\u010F", "Pozd\u011Bji", "Ne, d\xEDky", "\xD7"]
+};
+var cs_default = translations8;
+
+// src/translations/da.ts
+var translations9 = {
+  accept: [
+    "accepter",
+    "accepter alle",
+    "accepter alle cookies",
+    "godkend",
+    "tillad",
+    "tillad alle",
+    "ok",
+    "okay",
+    "forst\xE5et",
+    "forts\xE6t",
+    "g\xE5 videre",
+    "gem og accepter",
+    "gem indstillinger",
+    "accepter valg"
+  ],
+  reject: [
+    "afvis",
+    "afvis alle",
+    "afvis alle cookies",
+    "afsl\xE5",
+    "tillad ikke",
+    "kun n\xF8dvendige",
+    "kun n\xF8dvendige cookies",
+    "kun p\xE5kr\xE6vede",
+    "forts\xE6t uden cookies",
+    "nej tak",
+    "begr\xE6ns til n\xF8dvendige"
+  ],
+  close: [
+    "luk",
+    "annuller",
+    "skjul",
+    "ikke nu",
+    "nej tak",
+    "senere",
+    "\xD7",
+    "m\xE5ske senere",
+    "luk besked"
+  ]
+};
+var da_default = translations9;
+
+// src/translations/de.ts
+var translations10 = {
+  accept: [
+    "Akzeptieren",
+    "Alle akzeptieren",
+    "Zustimmen",
+    "Ich stimme zu",
+    "Erlauben",
+    "Alle erlauben",
+    "Zulassen",
+    "Alles zulassen",
+    "OK",
+    "Okay",
+    "Verstanden",
+    "Weiter",
+    "Speichern & akzeptieren",
+    "Speichern und fortfahren",
+    "Alles klar"
+  ],
+  reject: [
+    "Ablehnen",
+    "Alle ablehnen",
+    "Nicht erlauben",
+    "Nicht zustimmen",
+    "Nur notwendige",
+    "Nur notwendige Cookies",
+    "Nur essenzielle",
+    "Nur erforderliche",
+    "Ohne Cookies fortfahren",
+    "Nein danke",
+    "Zugriff verweigern",
+    "Ablehnen und schlie\xDFen"
+  ],
+  close: [
+    "Schlie\xDFen",
+    "Abbrechen",
+    "Ausblenden",
+    "Jetzt nicht",
+    "Nein danke",
+    "Sp\xE4ter",
+    "\xD7",
+    "Fenster schlie\xDFen",
+    "Verwerfen",
+    "Zur\xFCck"
+  ]
+};
+var de_default = translations10;
+
+// src/translations/el.ts
+var translations11 = {
+  accept: [
+    "\u0391\u03C0\u03BF\u03B4\u03BF\u03C7\u03AE",
+    "\u0391\u03C0\u03BF\u03B4\u03BF\u03C7\u03AE \u03CC\u03BB\u03C9\u03BD",
+    "\u03A3\u03C5\u03BC\u03C6\u03C9\u03BD\u03CE",
+    "\u0395\u03BD\u03C4\u03AC\u03BE\u03B5\u03B9",
+    "\u039F\u039A",
+    "\u03A4\u03BF \u03BA\u03B1\u03C4\u03AC\u03BB\u03B1\u03B2\u03B1",
+    "\u03A3\u03C5\u03BD\u03AD\u03C7\u03B5\u03B9\u03B1",
+    "\u0395\u03C0\u03B9\u03C4\u03C1\u03AD\u03C0\u03C9",
+    "\u0395\u03C0\u03B9\u03C4\u03C1\u03AD\u03C0\u03C9 \u03CC\u03BB\u03B1",
+    "\u0391\u03C0\u03BF\u03B8\u03AE\u03BA\u03B5\u03C5\u03C3\u03B7 \u03BA\u03B1\u03B9 \u03B1\u03C0\u03BF\u03B4\u03BF\u03C7\u03AE",
+    "\u03A0\u03C1\u03BF\u03C7\u03CE\u03C1\u03B7\u03C3\u03B5"
+  ],
+  reject: [
+    "\u0391\u03C0\u03CC\u03C1\u03C1\u03B9\u03C8\u03B7",
+    "\u0391\u03C0\u03CC\u03C1\u03C1\u03B9\u03C8\u03B7 \u03CC\u03BB\u03C9\u03BD",
+    "\u0386\u03C1\u03BD\u03B7\u03C3\u03B7",
+    "\u039C\u03B7 \u03B1\u03C0\u03BF\u03B4\u03BF\u03C7\u03AE",
+    "\u039C\u03CC\u03BD\u03BF \u03C4\u03B1 \u03B1\u03C0\u03B1\u03C1\u03B1\u03AF\u03C4\u03B7\u03C4\u03B1",
+    "\u039C\u03CC\u03BD\u03BF \u03C4\u03B1 \u03B1\u03BD\u03B1\u03B3\u03BA\u03B1\u03AF\u03B1",
+    "\u03A3\u03C5\u03BD\u03AD\u03C7\u03B5\u03B9\u03B1 \u03C7\u03C9\u03C1\u03AF\u03C2 cookies",
+    "\u03A7\u03C9\u03C1\u03AF\u03C2 cookies",
+    "\u038C\u03C7\u03B9, \u03B5\u03C5\u03C7\u03B1\u03C1\u03B9\u03C3\u03C4\u03CE"
+  ],
+  close: [
+    "\u039A\u03BB\u03B5\u03AF\u03C3\u03B9\u03BC\u03BF",
+    "\u039A\u03BB\u03B5\u03AF\u03C3\u03B5",
+    "\u0386\u03BA\u03C5\u03C1\u03BF",
+    "\u0391\u03BA\u03CD\u03C1\u03C9\u03C3\u03B7",
+    "\u03A0\u03B1\u03C1\u03AC\u03B2\u03BB\u03B5\u03C8\u03B7",
+    "\u038C\u03C7\u03B9 \u03C4\u03CE\u03C1\u03B1",
+    "\u0391\u03C1\u03B3\u03CC\u03C4\u03B5\u03C1\u03B1",
+    "\u0395\u03C0\u03B9\u03C3\u03C4\u03C1\u03BF\u03C6\u03AE",
+    "\xD7",
+    "\u03A7"
+  ]
+};
+var el_default = translations11;
+
+// src/translations/en.ts
+var translations12 = {
+  accept: ["accept", "accept all", "agree", "allow", "allow all", "ok", "okay", "got it", "continue", "save & accept"],
+  reject: ["reject", "reject all", "decline", "deny", "only necessary", "necessary only", "only essential", "essential only", "continue without cookies", "no thanks"],
+  close: ["close", "cancel", "dismiss", "not now", "no thanks", "later", "\xD7"]
+};
+var en_default = translations12;
+
+// src/translations/es.ts
+var translations13 = {
+  accept: ["Aceptar", "Aceptar todo", "Estoy de acuerdo", "Permitir", "Permitir todo", "OK", "De acuerdo", "Entendido", "Continuar", "Guardar y aceptar", "S\xED, acepto"],
+  reject: ["Rechazar", "Rechazar todo", "Denegar", "No permitir", "Solo las necesarias", "Solo lo esencial", "Continuar sin cookies", "No, gracias", "Seguir sin aceptar", "No aceptar"],
+  close: ["Cerrar", "Cancelar", "Descartar", "Ahora no", "No, gracias", "M\xE1s tarde", "\xD7", "Omitir", "Ignorar", "Volver"]
+};
+var es_default = translations13;
+
+// src/translations/et.ts
+var translations14 = {
+  accept: ["N\xF5ustun", "Olen n\xF5us", "Luba k\xF5ik", "Luba", "OK", "Olgu", "Sain aru", "J\xE4tka", "Salvesta ja n\xF5ustu", "Kinnita"],
+  reject: ["Keeldu", "Keeldu k\xF5igist k\xFCpsistest", "\xC4ra luba", "Ainult vajalikud", "Vaid h\xE4davajalikud", "J\xE4tka ilma k\xFCpsisteta", "Ei, ait\xE4h", "\xC4ra salvesta"],
+  close: ["Sulge", "T\xFChista", "Loobu", "Mitte praegu", "Ei, ait\xE4h", "Hiljem", "Pane kinni", "\xD7"]
+};
+var et_default = translations14;
+
+// src/translations/eu.ts
+var translations15 = {
+  accept: ["Onartu", "Guztiak onartu", "Ados", "Baimendu", "Guztiak baimendu", "Ulertuta", "Jarraitu", "Onartzen dut", "Gorde eta onartu", "OK"],
+  reject: ["Ez onartu", "Guztiak ukatu", "Ukatu", "Ez baimendu", "Ezeztatu", "Beharrezkoak bakarrik", "Funtsezkoak bakarrik", "Cookie-rik gabe jarraitu", "Onartu gabe jarraitu", "Ez, eskerrik asko"],
+  close: ["Itxi", "Ezeztatu", "Baztertu", "Orain ez", "Ez, eskerrik asko", "Geroago", "Utzi", "\xD7"]
+};
+var eu_default = translations15;
+
+// src/translations/fa.ts
+var translations16 = {
+  accept: ["\u067E\u0630\u06CC\u0631\u0641\u062A\u0646", "\u067E\u0630\u06CC\u0631\u0641\u062A\u0646 \u0647\u0645\u0647", "\u0642\u0628\u0648\u0644 \u0645\u06CC\u200C\u06A9\u0646\u0645", "\u0645\u0648\u0627\u0641\u0642\u0645", "\u0627\u062C\u0627\u0632\u0647 \u0645\u06CC\u200C\u062F\u0647\u0645", "\u0628\u0627\u0634\u0647", "\u062A\u0623\u06CC\u06CC\u062F", "\u0627\u062F\u0627\u0645\u0647", "\u0630\u062E\u06CC\u0631\u0647 \u0648 \u067E\u0630\u06CC\u0631\u0634", "\u062A\u0623\u06CC\u06CC\u062F \u0648 \u0627\u062F\u0627\u0645\u0647"],
+  reject: ["\u0631\u062F \u06A9\u0631\u062F\u0646", "\u0631\u062F \u0647\u0645\u0647", "\u0639\u062F\u0645 \u067E\u0630\u06CC\u0631\u0634", "\u0627\u062C\u0627\u0632\u0647 \u0646\u0645\u06CC\u200C\u062F\u0647\u0645", "\u0641\u0642\u0637 \u0636\u0631\u0648\u0631\u06CC\u200C\u0647\u0627", "\u0641\u0642\u0637 \u0645\u0648\u0627\u0631\u062F \u0644\u0627\u0632\u0645", "\u0627\u062F\u0627\u0645\u0647 \u0628\u062F\u0648\u0646 \u06A9\u0648\u06A9\u06CC", "\u0628\u062F\u0648\u0646 \u06A9\u0648\u06A9\u06CC \u0627\u062F\u0627\u0645\u0647 \u0628\u062F\u0647", "\u0646\u0647\u060C \u0645\u0645\u0646\u0648\u0646", "\u0646\u0645\u06CC\u200C\u062E\u0648\u0627\u0647\u0645", "\u0646\u067E\u0630\u06CC\u0631\u0641\u062A\u0646"],
+  close: ["\u0628\u0633\u062A\u0646", "\u0644\u063A\u0648", "\u0627\u0646\u0635\u0631\u0627\u0641", "\u0627\u0644\u0627\u0646 \u0646\u0647", "\u0641\u0639\u0644\u0627\u064B \u0646\u0647", "\u0628\u0639\u062F\u0627\u064B", "\xD7", "\u0628\u0627\u0632\u06AF\u0634\u062A", "\u062E\u0631\u0648\u062C"]
+};
+var fa_default = translations16;
+
+// src/translations/fi.ts
+var translations17 = {
+  accept: [
+    "Hyv\xE4ksy",
+    "Hyv\xE4ksy kaikki",
+    "Salli",
+    "Salli kaikki",
+    "OK",
+    "Okei",
+    "Selv\xE4",
+    "Jatka",
+    "Tallenna ja hyv\xE4ksy",
+    "Suostun",
+    "Vahvista"
+  ],
+  reject: [
+    "Hylk\xE4\xE4",
+    "Hylk\xE4\xE4 kaikki",
+    "Kielt\xE4ydy",
+    "\xC4l\xE4 salli",
+    "Vain v\xE4ltt\xE4m\xE4tt\xF6m\xE4t",
+    "Vain pakolliset",
+    "Jatka ilman ev\xE4steit\xE4",
+    "Ei kiitos",
+    "Est\xE4",
+    "\xC4l\xE4 hyv\xE4ksy"
+  ],
+  close: [
+    "Sulje",
+    "Peruuta",
+    "Piilota",
+    "Ei nyt",
+    "Ei kiitos",
+    "My\xF6hemmin",
+    "Valmis",
+    "\xD7"
+  ]
+};
+var fi_default = translations17;
+
+// src/translations/fr.ts
+var translations18 = {
+  accept: [
+    "Accepter",
+    "Tout accepter",
+    "J'accepte",
+    "Autoriser",
+    "Tout autoriser",
+    "OK",
+    "D'accord",
+    "Compris",
+    "Continuer",
+    "Enregistrer et accepter",
+    "Valider",
+    "Accepter et continuer"
+  ],
+  reject: [
+    "Refuser",
+    "Tout refuser",
+    "Je refuse",
+    "Refuser tout",
+    "N'autoriser que l'essentiel",
+    "Essentiels uniquement",
+    "Uniquement le n\xE9cessaire",
+    "Continuer sans cookies",
+    "Non merci",
+    "Ne pas autoriser",
+    "Refuser et continuer"
+  ],
+  close: [
+    "Fermer",
+    "Annuler",
+    "Ignorer",
+    "Pas maintenant",
+    "Non merci",
+    "Plus tard",
+    "\xD7",
+    "Fermer la fen\xEAtre",
+    "Masquer"
+  ]
+};
+var fr_default = translations18;
+
+// src/translations/ga.ts
+var translations19 = {
+  accept: [
+    "Glac",
+    "Glac leis",
+    "Glac le gach rud",
+    "Aonta\xEDm",
+    "Ceadaigh",
+    "Ceadaigh gach rud",
+    "OK",
+    "Ceart go leor",
+    "Tuigim",
+    "Lean ar aghaidh",
+    "S\xE1bh\xE1il agus glac"
+  ],
+  reject: [
+    "Di\xFAltaigh",
+    "Di\xFAltaigh gach rud",
+    "Di\xFAlta\xEDm",
+    "N\xE1 glac",
+    "N\xE1 ceadaigh",
+    "Na cinn riachtanacha amh\xE1in",
+    "Gan ach na riachtanacha",
+    "Lean ar aghaidh gan fhian\xE1in",
+    "Gan fhian\xE1in",
+    "N\xEDl, go raibh maith agat"
+  ],
+  close: [
+    "D\xFAn",
+    "Cealaigh",
+    "Cuir ar ceal",
+    "Scoir",
+    "N\xE1 bac leis",
+    "N\xED anois",
+    "N\xEDos d\xE9ana\xED",
+    "Ar ball",
+    "\xD7"
+  ]
+};
+var ga_default = translations19;
+
+// src/translations/he.ts
+var translations20 = {
+  accept: [
+    "\u05D0\u05E9\u05E8",
+    "\u05D0\u05E9\u05E8 \u05D4\u05DB\u05DC",
+    "\u05DE\u05E1\u05DB\u05D9\u05DD",
+    "\u05D0\u05E0\u05D9 \u05DE\u05E1\u05DB\u05D9\u05DD",
+    "\u05D0\u05E4\u05E9\u05E8",
+    "\u05D0\u05E4\u05E9\u05E8 \u05D4\u05DB\u05DC",
+    "\u05D1\u05E1\u05D3\u05E8",
+    "\u05D0\u05D5\u05E7\u05D9\u05D9",
+    "\u05D4\u05D1\u05E0\u05EA\u05D9",
+    "\u05D4\u05DE\u05E9\u05DA",
+    "\u05E9\u05DE\u05D5\u05E8 \u05D5\u05D0\u05E9\u05E8",
+    "\u05E9\u05DE\u05D5\u05E8 \u05D5\u05D4\u05DE\u05E9\u05DA",
+    "\u05E7\u05D1\u05DC \u05D4\u05DB\u05DC"
+  ],
+  reject: [
+    "\u05D3\u05D7\u05D4",
+    "\u05D3\u05D7\u05D4 \u05D4\u05DB\u05DC",
+    "\u05E1\u05E8\u05D1",
+    "\u05D0\u05DC \u05EA\u05D0\u05E9\u05E8",
+    "\u05D0\u05DC \u05EA\u05D0\u05E4\u05E9\u05E8",
+    "\u05E8\u05E7 \u05D4\u05DB\u05E8\u05D7\u05D9",
+    "\u05D4\u05DB\u05E8\u05D7\u05D9 \u05D1\u05DC\u05D1\u05D3",
+    "\u05D4\u05DE\u05E9\u05DA \u05DC\u05DC\u05D0 \u05E7\u05D5\u05D1\u05E6\u05D9 Cookie",
+    "\u05D4\u05DE\u05E9\u05DA \u05D1\u05DC\u05D9 \u05E2\u05D5\u05D2\u05D9\u05D5\u05EA",
+    "\u05DC\u05D0 \u05EA\u05D5\u05D3\u05D4",
+    "\u05D0\u05DC \u05EA\u05E9\u05DE\u05D5\u05E8",
+    "\u05D1\u05D8\u05DC \u05D4\u05E1\u05DB\u05DE\u05D4"
+  ],
+  close: [
+    "\u05E1\u05D2\u05D5\u05E8",
+    "\u05E1\u05D2\u05D9\u05E8\u05D4",
+    "\u05D1\u05D8\u05DC",
+    "\u05D1\u05D9\u05D8\u05D5\u05DC",
+    "\u05DC\u05D0 \u05E2\u05DB\u05E9\u05D9\u05D5",
+    "\u05DE\u05D0\u05D5\u05D7\u05E8 \u05D9\u05D5\u05EA\u05E8",
+    "\u05D0\u05D7\u05E8 \u05DB\u05DA",
+    "\xD7",
+    "\u05E1\u05D2\u05D5\u05E8 \u05D7\u05DC\u05D5\u05DF",
+    "\u05D7\u05D6\u05E8\u05D4"
+  ]
+};
+var he_default = translations20;
+
+// src/translations/hi.ts
+var translations21 = {
+  accept: [
+    "\u0938\u094D\u0935\u0940\u0915\u093E\u0930 \u0915\u0930\u0947\u0902",
+    "\u0938\u092D\u0940 \u0938\u094D\u0935\u0940\u0915\u093E\u0930 \u0915\u0930\u0947\u0902",
+    "\u092E\u0948\u0902 \u0938\u0939\u092E\u0924 \u0939\u0942\u0901",
+    "\u0905\u0928\u0941\u092E\u0924\u093F \u0926\u0947\u0902",
+    "\u0938\u092D\u0940 \u0915\u094B \u0905\u0928\u0941\u092E\u0924\u093F \u0926\u0947\u0902",
+    "\u0920\u0940\u0915 \u0939\u0948",
+    "\u091C\u093E\u0930\u0940 \u0930\u0916\u0947\u0902",
+    "\u0938\u094D\u0935\u0940\u0915\u093E\u0930 \u0915\u0930\u0915\u0947 \u0906\u0917\u0947 \u092C\u0922\u093C\u0947\u0902",
+    "\u0938\u0939\u0947\u091C\u0947\u0902 \u0914\u0930 \u0938\u094D\u0935\u0940\u0915\u093E\u0930\u0947\u0902",
+    "\u0939\u093E\u0901"
+  ],
+  reject: [
+    "\u0905\u0938\u094D\u0935\u0940\u0915\u093E\u0930 \u0915\u0930\u0947\u0902",
+    "\u0938\u092D\u0940 \u0905\u0938\u094D\u0935\u0940\u0915\u093E\u0930 \u0915\u0930\u0947\u0902",
+    "\u0907\u0902\u0915\u093E\u0930 \u0915\u0930\u0947\u0902",
+    "\u0905\u0928\u0941\u092E\u0924\u093F \u0928 \u0926\u0947\u0902",
+    "\u0915\u0947\u0935\u0932 \u0906\u0935\u0936\u094D\u092F\u0915",
+    "\u0938\u093F\u0930\u094D\u092B \u0906\u0935\u0936\u094D\u092F\u0915",
+    "\u0915\u0947\u0935\u0932 \u0906\u0935\u0936\u094D\u092F\u0915 \u0915\u0941\u0915\u0940\u091C\u093C",
+    "\u0915\u0941\u0915\u0940\u091C\u093C \u0915\u0947 \u092C\u093F\u0928\u093E \u091C\u093E\u0930\u0940 \u0930\u0916\u0947\u0902",
+    "\u0928\u0939\u0940\u0902, \u0927\u0928\u094D\u092F\u0935\u093E\u0926",
+    "\u0938\u094D\u0935\u0940\u0915\u093E\u0930 \u0928 \u0915\u0930\u0947\u0902"
+  ],
+  close: [
+    "\u092C\u0902\u0926 \u0915\u0930\u0947\u0902",
+    "\u0930\u0926\u094D\u0926 \u0915\u0930\u0947\u0902",
+    "\u0916\u093E\u0930\u093F\u091C \u0915\u0930\u0947\u0902",
+    "\u0905\u092D\u0940 \u0928\u0939\u0940\u0902",
+    "\u0928\u0939\u0940\u0902, \u0927\u0928\u094D\u092F\u0935\u093E\u0926",
+    "\u092C\u093E\u0926 \u092E\u0947\u0902",
+    "\xD7",
+    "\u0935\u093E\u092A\u0938",
+    "\u092C\u093E\u0939\u0930 \u0928\u093F\u0915\u0932\u0947\u0902"
+  ]
+};
+var hi_default = translations21;
+
+// src/translations/hr.ts
+var translations22 = {
+  accept: ["Prihvati", "Prihvati sve", "Sla\u017Eem se", "Dopusti", "Dopusti sve", "U redu", "OK", "Razumijem", "Nastavi", "Spremi i prihvati", "Spremi postavke", "Potvrdi"],
+  reject: ["Odbij", "Odbij sve", "Odbijam", "Ne prihva\u0107am", "Ne dopu\u0161tam", "Samo nu\u017Eni", "Samo osnovno", "Nastavi bez kola\u010Di\u0107a", "Bez dodatnih kola\u010Di\u0107a", "Ne, hvala"],
+  close: ["Zatvori", "Odustani", "Odbaci", "Zanemari", "Ne sada", "Ne, hvala", "Kasnije", "\xD7", "Zatvori prozor", "Zatvori obavijest"]
+};
+var hr_default = translations22;
+
+// src/translations/hu.ts
+var translations23 = {
+  accept: ["Elfogadom", "Mindet elfogadom", "Hozz\xE1j\xE1rulok", "Enged\xE9lyezem", "\xD6sszes elfogad\xE1sa", "\xD6sszes enged\xE9lyez\xE9se", "OK", "Ok\xE9", "\xC9rtettem", "Tov\xE1bb", "Rendben", "Be\xE1ll\xEDt\xE1sok ment\xE9se", "Ment\xE9s \xE9s elfogadom"],
+  reject: ["Elutas\xEDtom", "Mindet elutas\xEDtom", "Nem fogadom el", "Nem enged\xE9lyezem", "Csak a sz\xFCks\xE9geseket", "Csak a n\xE9lk\xFCl\xF6zhetetlenek", "Csak alapbe\xE1ll\xEDt\xE1sok", "Csak k\xF6telez\u0151k", "Folytat\xE1s s\xFCtik n\xE9lk\xFCl", "K\xF6sz\xF6n\xF6m, nem", "Nem k\xE9rem"],
+  close: ["Bez\xE1r\xE1s", "Bez\xE1r", "M\xE9gse", "Most nem", "Nem most", "K\xE9s\u0151bb", "Nem k\xE9rem", "\xD7"]
+};
+var hu_default = translations23;
+
+// src/translations/hy.ts
+var translations24 = {
+  accept: ["\u0538\u0576\u0564\u0578\u0582\u0576\u0565\u056C", "\u0538\u0576\u0564\u0578\u0582\u0576\u0565\u056C \u0562\u0578\u056C\u0578\u0580\u0568", "\u0540\u0561\u0574\u0561\u0571\u0561\u0575\u0576 \u0565\u0574", "\u0539\u0578\u0582\u0575\u056C\u0561\u057F\u0580\u0565\u056C", "\u0539\u0578\u0582\u0575\u056C\u0561\u057F\u0580\u0565\u056C \u0562\u0578\u056C\u0578\u0580\u0568", "\u053C\u0561\u057E", "OK", "\u0540\u0561\u057D\u056F\u0561\u0581\u0561", "\u0547\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u0565\u056C", "\u054A\u0561\u0570\u057A\u0561\u0576\u0565\u056C \u0587 \u0568\u0576\u0564\u0578\u0582\u0576\u0565\u056C", "\u0540\u0561\u057D\u057F\u0561\u057F\u0565\u056C"],
+  reject: ["\u0544\u0565\u0580\u056A\u0565\u056C", "\u0544\u0565\u0580\u056A\u0565\u056C \u0562\u0578\u056C\u0578\u0580\u0568", "\u0549\u0565\u0574 \u0570\u0561\u0574\u0561\u0571\u0561\u0575\u0576\u057E\u0578\u0582\u0574", "\u0549\u0569\u0578\u0582\u0575\u056C\u0561\u057F\u0580\u0565\u056C", "\u0544\u056B\u0561\u0575\u0576 \u0561\u0576\u0570\u0580\u0561\u056A\u0565\u0577\u057F\u0568", "\u0544\u056B\u0561\u0575\u0576 \u0567\u0561\u056F\u0561\u0576\u0568", "\u0544\u056B\u0561\u0575\u0576 \u057A\u0561\u0580\u057F\u0561\u0564\u056B\u0580\u0576\u0565\u0580\u0568", "\u0547\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u0565\u056C \u0561\u057C\u0561\u0576\u0581 \u0584\u0578\u0582\u0584\u056B\u0576\u0565\u0580\u056B", "\u0548\u0579, \u0577\u0576\u0578\u0580\u0570\u0561\u056F\u0561\u056C\u0578\u0582\u0569\u0575\u0578\u0582\u0576"],
+  close: ["\u0553\u0561\u056F\u0565\u056C", "\u0549\u0565\u0572\u0561\u0580\u056F\u0565\u056C", "\u0531\u0576\u057F\u0565\u057D\u0565\u056C", "\u0548\u0579 \u0570\u056B\u0574\u0561", "\u0548\u0579, \u0577\u0576\u0578\u0580\u0570\u0561\u056F\u0561\u056C\u0578\u0582\u0569\u0575\u0578\u0582\u0576", "\u0540\u0565\u057F\u0578", "\u0553\u0561\u056F\u0565\u056C \u057A\u0561\u057F\u0578\u0582\u0570\u0561\u0576\u0568", "\xD7"]
+};
+var hy_default = translations24;
+
+// src/translations/id.ts
+var translations25 = {
+  accept: ["Setuju", "Setujui semua", "Terima", "Terima semua", "Izinkan", "Izinkan semua", "OK", "Oke", "Baik", "Saya mengerti", "Lanjutkan", "Simpan & setujui", "Simpan pengaturan"],
+  reject: ["Tolak", "Tolak semua", "Jangan izinkan", "Hanya yang diperlukan", "Esensial saja", "Yang penting saja", "Lanjut tanpa cookie", "Tidak, terima kasih"],
+  close: ["Tutup", "Batal", "Abaikan", "Tidak sekarang", "Nanti saja", "Lewati dulu", "\xD7"]
+};
+var id_default = translations25;
+
+// src/translations/is.ts
+var translations26 = {
+  accept: ["Sam\xFEykkja", "Sam\xFEykkja allt", "\xC9g sam\xFEykki", "Leyfa", "Leyfa allt", "Allt \xED lagi", "\xCD lagi", "OK", "Skil", "Halda \xE1fram", "Vista og sam\xFEykkja", "Sta\xF0festa", "Sam\xFEykkja og halda \xE1fram"],
+  reject: ["Hafna", "Hafna \xF6llu", "Neita", "Neita \xF6llum", "Leyfi ekki", "A\xF0eins nau\xF0synlegar", "Einungis nau\xF0synlegar", "Halda \xE1fram \xE1n vafrakaka", "Engar vafrak\xF6kur", "Nei, takk"],
+  close: ["Loka", "H\xE6tta vi\xF0", "Hunsa", "Ekki n\xFAna", "Nei, takk", "S\xED\xF0ar", "Seinna", "\xD7", "Loka glugga"]
+};
+var is_default = translations26;
+
+// src/translations/it.ts
+var translations27 = {
+  accept: ["Aceptar", "Aceptar todo", "Estoy de acuerdo", "Permitir", "Permitir todo", "OK", "Vale", "Entendido", "Continuar", "Guardar y aceptar", "Aceptar y continuar", "S\xED, acepto"],
+  reject: ["Rechazar", "Rechazar todo", "Declinar", "Denegar", "Solo necesarias", "Solo lo esencial", "Continuar sin cookies", "No, gracias", "Rechazar opcionales", "No aceptar", "Usar solo las imprescindibles"],
+  close: ["Cerrar", "Cancelar", "Descartar", "Ahora no", "No, gracias", "M\xE1s tarde", "\xD7", "Omitir", "Volver", "Cerrar ventana"]
+};
+var it_default = translations27;
+
+// src/translations/ja.ts
+var translations28 = {
+  accept: ["\u540C\u610F\u3059\u308B", "\u3059\u3079\u3066\u540C\u610F", "\u8A31\u53EF\u3059\u308B", "\u3059\u3079\u3066\u8A31\u53EF", "OK", "\u306F\u3044", "\u308F\u304B\u308A\u307E\u3057\u305F", "\u7D9A\u884C", "\u540C\u610F\u3057\u3066\u7D9A\u884C", "\u4FDD\u5B58\u3057\u3066\u540C\u610F", "\u4FDD\u5B58\u3057\u3066\u7D9A\u884C"],
+  reject: ["\u62D2\u5426\u3059\u308B", "\u3059\u3079\u3066\u62D2\u5426", "\u540C\u610F\u3057\u306A\u3044", "\u8A31\u53EF\u3057\u306A\u3044", "\u5FC5\u9808\u306E\u307F", "\u5FC5\u8981\u6700\u4F4E\u9650\u306E\u307F", "\u5FC5\u8981\u306A\u3082\u306E\u306E\u307F\u8A31\u53EF", "\u540C\u610F\u305B\u305A\u306B\u7D9A\u884C", "Cookie\u306A\u3057\u3067\u7D9A\u884C", "\u4ECA\u56DE\u306F\u898B\u9001\u308B"],
+  close: ["\u9589\u3058\u308B", "\u30AD\u30E3\u30F3\u30BB\u30EB", "\u4ECA\u306F\u3057\u306A\u3044", "\u5F8C\u3067", "\xD7", "\u30B9\u30AD\u30C3\u30D7", "\u53D6\u308A\u6D88\u3057", "\u4ECA\u306F\u3084\u3081\u3066\u304A\u304F"]
+};
+var ja_default = translations28;
+
+// src/translations/ka.ts
+var translations29 = {
+  accept: [
+    "\u10D5\u10D4\u10D7\u10D0\u10DC\u10EE\u10DB\u10D4\u10D1\u10D8",
+    "\u10DB\u10D8\u10E6\u10D4\u10D1\u10D0",
+    "\u10D3\u10D0\u10D3\u10D0\u10E1\u10E2\u10E3\u10E0\u10D4\u10D1\u10D0",
+    "\u10D3\u10D0\u10E8\u10D5\u10D4\u10D1\u10D0",
+    "\u10E7\u10D5\u10D4\u10DA\u10D0\u10E4\u10E0\u10D8\u10E1 \u10DB\u10D8\u10E6\u10D4\u10D1\u10D0",
+    "\u10E7\u10D5\u10D4\u10DA\u10D0\u10E1 \u10D3\u10D0\u10E8\u10D5\u10D4\u10D1\u10D0",
+    "\u10D9\u10D0\u10E0\u10D2\u10D8",
+    "\u10D2\u10D0\u10E1\u10D0\u10D2\u10D4\u10D1\u10D8\u10D0",
+    "\u10D2\u10D0\u10D2\u10E0\u10EB\u10D4\u10DA\u10D4\u10D1\u10D0",
+    "\u10E8\u10D4\u10DC\u10D0\u10EE\u10D5\u10D0 \u10D3\u10D0 \u10D7\u10D0\u10DC\u10EE\u10DB\u10DD\u10D1\u10D0",
+    "\u10E8\u10D4\u10DC\u10D0\u10EE\u10D5\u10D0 \u10D3\u10D0 \u10DB\u10D8\u10E6\u10D4\u10D1\u10D0"
+  ],
+  reject: [
+    "\u10E3\u10D0\u10E0\u10E7\u10DD\u10E4\u10D0",
+    "\u10E7\u10D5\u10D4\u10DA\u10D0\u10E4\u10E0\u10D8\u10E1 \u10E3\u10D0\u10E0\u10E7\u10DD\u10E4\u10D0",
+    "\u10E3\u10D0\u10E0\u10D8\u10E1 \u10D7\u10E5\u10DB\u10D0",
+    "\u10D0\u10E0 \u10D3\u10D0\u10D5\u10E3\u10E8\u10D5\u10D0",
+    "\u10DB\u10EE\u10DD\u10DA\u10DD\u10D3 \u10D0\u10E3\u10EA\u10D8\u10DA\u10D4\u10D1\u10D4\u10DA\u10D8",
+    "\u10DB\u10EE\u10DD\u10DA\u10DD\u10D3 \u10D0\u10E3\u10EA\u10D8\u10DA\u10D4\u10D1\u10D4\u10DA\u10D8 \u10E5\u10E3\u10E5\u10D8-\u10E4\u10D0\u10D8\u10DA\u10D4\u10D1\u10D8",
+    "\u10D2\u10D0\u10D2\u10E0\u10EB\u10D4\u10DA\u10D4\u10D1\u10D0 \u10E5\u10E3\u10E5\u10D8-\u10E4\u10D0\u10D8\u10DA\u10D4\u10D1\u10D8\u10E1 \u10D2\u10D0\u10E0\u10D4\u10E8\u10D4",
+    "\u10D0\u10E0\u10D0, \u10DB\u10D0\u10D3\u10DA\u10DD\u10D1\u10D0"
+  ],
+  close: [
+    "\u10D3\u10D0\u10EE\u10E3\u10E0\u10D5\u10D0",
+    "\u10D2\u10D0\u10E3\u10E5\u10DB\u10D4\u10D1\u10D0",
+    "\u10D3\u10D0\u10DB\u10D0\u10DA\u10D5\u10D0",
+    "\u10D0\u10EE\u10DA\u10D0 \u10D0\u10E0\u10D0",
+    "\u10D0\u10E0\u10D0, \u10DB\u10D0\u10D3\u10DA\u10DD\u10D1\u10D0",
+    "\u10DB\u10DD\u10D2\u10D5\u10D8\u10D0\u10DC\u10D4\u10D1\u10D8\u10D7",
+    "\xD7"
+  ]
+};
+var ka_default = translations29;
+
+// src/translations/ko.ts
+var translations30 = {
+  accept: ["\uB3D9\uC758", "\uBAA8\uB450 \uB3D9\uC758", "\uD5C8\uC6A9", "\uC804\uCCB4 \uD5C8\uC6A9", "\uD655\uC778", "\uC54C\uACA0\uC2B5\uB2C8\uB2E4", "\uACC4\uC18D", "\uB3D9\uC758\uD558\uACE0 \uACC4\uC18D", "\uC800\uC7A5\uD558\uACE0 \uB3D9\uC758", "\uC801\uC6A9"],
+  reject: ["\uAC70\uBD80", "\uBAA8\uB450 \uAC70\uBD80", "\uB3D9\uC758 \uC548 \uD568", "\uD5C8\uC6A9 \uC548 \uD568", "\uD544\uC218\uB9CC \uD5C8\uC6A9", "\uD544\uC218 \uD56D\uBAA9\uB9CC", "\uCFE0\uD0A4 \uC5C6\uC774 \uACC4\uC18D", "\uAC74\uB108\uB6F0\uAE30", "\uAD1C\uCC2E\uC2B5\uB2C8\uB2E4"],
+  close: ["\uB2EB\uAE30", "\uCDE8\uC18C", "\uC228\uAE30\uAE30", "\uC9C0\uAE08\uC740 \uC548 \uD568", "\uB098\uC911\uC5D0", "\xD7"]
+};
+var ko_default = translations30;
+
+// src/translations/lt.ts
+var translations31 = {
+  accept: ["Sutinku", "Leisti", "Leisti visk\u0105", "Gerai", "Supratau", "T\u0119sti", "Patvirtinti", "I\u0161saugoti ir sutikti", "OK"],
+  reject: ["Atmesti", "Atmesti visus", "Atsisakyti", "Neleisti", "Tik b\u016Btini slapukai", "Tik esminiai slapukai", "T\u0119sti be slapuk\u0173", "Ne, a\u010Di\u016B"],
+  close: ["U\u017Edaryti", "U\u017Everti", "At\u0161aukti", "Ne dabar", "V\u0117liau", "A\u010Di\u016B, ne", "Gr\u012F\u017Eti", "\xD7"]
+};
+var lt_default = translations31;
+
+// src/translations/lv.ts
+var translations32 = {
+  accept: [
+    "Piekr\u012Btu",
+    "Pie\u0146emt",
+    "Pie\u0146emt visu",
+    "At\u013Caut",
+    "At\u013Caut visu",
+    "Labi",
+    "OK",
+    "Sapratu",
+    "Turpin\u0101t",
+    "Apstiprin\u0101t",
+    "Apstiprin\u0101t izv\u0113li",
+    "Saglab\u0101t un piekrist",
+    "Saglab\u0101t iestat\u012Bjumus"
+  ],
+  reject: [
+    "Noraid\u012Bt",
+    "Noraid\u012Bt visu",
+    "Nepiekrist",
+    "Neat\u013Caut",
+    "Neat\u013Caut nevienu",
+    "Tikai nepiecie\u0161am\u0101s",
+    "Tikai b\u016Btisk\u0101s s\u012Bkdatnes",
+    "Turpin\u0101t bez s\u012Bkdatn\u0113m",
+    "N\u0113, paldies",
+    "Aizliegt",
+    "Atteikties"
+  ],
+  close: [
+    "Aizv\u0113rt",
+    "Aizv\u0113rt logu",
+    "Atcelt",
+    "Ner\u0101d\u012Bt tagad",
+    "Ne tagad",
+    "N\u0113, paldies",
+    "V\u0113l\u0101k",
+    "\xD7",
+    "Aizv\u0113rt pazi\u0146ojumu"
+  ]
+};
+var lv_default = translations32;
+
+// src/translations/nl.ts
+var translations33 = {
+  accept: [
+    "Accepteren",
+    "Alles accepteren",
+    "Ik ga akkoord",
+    "Toestaan",
+    "Alles toestaan",
+    "OK",
+    "Ok\xE9",
+    "Begrepen",
+    "Doorgaan",
+    "Opslaan en accepteren",
+    "Akkoord",
+    "Verder",
+    "Ja, prima"
+  ],
+  reject: [
+    "Weigeren",
+    "Alles weigeren",
+    "Afwijzen",
+    "Niet toestaan",
+    "Alleen noodzakelijke cookies",
+    "Alleen essenti\xEBle cookies",
+    "Alleen strikt noodzakelijke cookies",
+    "Verder zonder cookies",
+    "Nee, bedankt",
+    "Alleen functioneel",
+    "Minimale instellingen"
+  ],
+  close: [
+    "Sluiten",
+    "Annuleren",
+    "Afbreken",
+    "Niet nu",
+    "Nee, bedankt",
+    "Later",
+    "\xD7",
+    "Terug",
+    "Venster sluiten"
+  ]
+};
+var nl_default = translations33;
+
+// src/translations/no.ts
+var translations34 = {
+  accept: [
+    "Godta",
+    "Godta alle",
+    "Aksepter",
+    "Aksepter alle",
+    "Tillat",
+    "Tillat alle",
+    "OK",
+    "Greit",
+    "Forst\xE5tt",
+    "Fortsett",
+    "G\xE5 videre",
+    "Lagre og godta",
+    "Lagre og aksepter",
+    "Jeg samtykker",
+    "Bekreft"
+  ],
+  reject: [
+    "Avsl\xE5",
+    "Avsl\xE5 alle",
+    "Avvis",
+    "Avvis alle",
+    "Ikke tillat",
+    "Kun n\xF8dvendige",
+    "Bare n\xF8dvendige",
+    "Kun essensielle",
+    "Kun n\xF8dvendige informasjonskapsler",
+    "Fortsett uten informasjonskapsler",
+    "Fortsett uten cookies",
+    "Nei takk"
+  ],
+  close: [
+    "Lukk",
+    "Avbryt",
+    "Skjul",
+    "Ikke n\xE5",
+    "Nei takk",
+    "Senere",
+    "Tilbake",
+    "Lukk uten \xE5 lagre",
+    "\xD7"
+  ]
+};
+var no_default = translations34;
+
+// src/translations/pl.ts
+var translations35 = {
+  accept: [
+    "Akceptuj\u0119",
+    "Akceptuj\u0119 wszystkie",
+    "Zgadzam si\u0119",
+    "Zezw\xF3l",
+    "Zezw\xF3l na wszystkie",
+    "OK",
+    "Okej",
+    "Rozumiem",
+    "Kontynuuj",
+    "Zapisz i zaakceptuj",
+    "Potwierd\u017A"
+  ],
+  reject: [
+    "Odrzu\u0107",
+    "Odrzu\u0107 wszystkie",
+    "Nie zgadzam si\u0119",
+    "Odm\xF3w",
+    "Tylko niezb\u0119dne",
+    "Wy\u0142\u0105cznie niezb\u0119dne",
+    "Kontynuuj bez zgody",
+    "Kontynuuj bez plik\xF3w cookie",
+    "Nie, dzi\u0119kuj\u0119",
+    "Zabro\u0144"
+  ],
+  close: [
+    "Zamknij",
+    "Anuluj",
+    "Ukryj",
+    "Nie teraz",
+    "Nie, dzi\u0119kuj\u0119",
+    "P\xF3\u017Aniej",
+    "\xD7",
+    "Zamknij okno"
+  ]
+};
+var pl_default = translations35;
+
+// src/translations/pt.ts
+var translations36 = {
+  accept: [
+    "Aceitar",
+    "Aceitar tudo",
+    "Concordo",
+    "Permitir",
+    "Permitir tudo",
+    "OK",
+    "Percebi",
+    "Entendi",
+    "Continuar",
+    "Guardar e aceitar",
+    "Aceitar e continuar",
+    "Concordar e prosseguir"
+  ],
+  reject: [
+    "Rejeitar",
+    "Rejeitar tudo",
+    "Recusar",
+    "N\xE3o permitir",
+    "Apenas o necess\xE1rio",
+    "S\xF3 o essencial",
+    "Apenas cookies essenciais",
+    "Continuar sem cookies",
+    "Continuar sem aceitar",
+    "N\xE3o, obrigado"
+  ],
+  close: [
+    "Fechar",
+    "Cancelar",
+    "Dispensar",
+    "Agora n\xE3o",
+    "N\xE3o, obrigado",
+    "Mais tarde",
+    "Voltar",
+    "Fechar janela",
+    "\xD7"
+  ]
+};
+var pt_default = translations36;
+
+// src/translations/ro.ts
+var translations37 = {
+  accept: [
+    "Accept",
+    "Accept toate",
+    "Sunt de acord",
+    "Permite",
+    "Permite tot",
+    "OK",
+    "\xCEn regul\u0103",
+    "Am \xEEn\u021Beles",
+    "Continu\u0103",
+    "Salveaz\u0103 \u0219i accept\u0103",
+    "De acord",
+    "Accept cookie\u2011urile"
+  ],
+  reject: [
+    "Refuz",
+    "Refuz toate",
+    "Respinge",
+    "Nu permit",
+    "Doar necesare",
+    "Numai esen\u021Biale",
+    "Continu\u0103 f\u0103r\u0103 cookie\u2011uri",
+    "Nu, mul\u021Bumesc",
+    "Respinge op\u021Bionale",
+    "Dezactiveaz\u0103 tot"
+  ],
+  close: [
+    "\xCEnchide",
+    "Anuleaz\u0103",
+    "Renun\u021B\u0103",
+    "Nu acum",
+    "Nu, mul\u021Bumesc",
+    "Mai t\xE2rziu",
+    "\xD7",
+    "\xCEnchide fereastra"
+  ]
+};
+var ro_default = translations37;
+
+// src/translations/ru.ts
+var translations38 = {
+  accept: ["\u041F\u0440\u0438\u043D\u044F\u0442\u044C", "\u041F\u0440\u0438\u043D\u044F\u0442\u044C \u0432\u0441\u0435", "\u0421\u043E\u0433\u043B\u0430\u0441\u0438\u0442\u044C\u0441\u044F", "\u0420\u0430\u0437\u0440\u0435\u0448\u0438\u0442\u044C", "\u0420\u0430\u0437\u0440\u0435\u0448\u0438\u0442\u044C \u0432\u0441\u0435", "\u041E\u041A", "\u0425\u043E\u0440\u043E\u0448\u043E", "\u041F\u043E\u043D\u044F\u0442\u043D\u043E", "\u041F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C", "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0438 \u043F\u0440\u0438\u043D\u044F\u0442\u044C", "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0432\u044B\u0431\u043E\u0440"],
+  reject: ["\u041E\u0442\u043A\u043B\u043E\u043D\u0438\u0442\u044C", "\u041E\u0442\u043A\u043B\u043E\u043D\u0438\u0442\u044C \u0432\u0441\u0435", "\u041E\u0442\u043A\u0430\u0437\u0430\u0442\u044C\u0441\u044F", "\u0417\u0430\u043F\u0440\u0435\u0442\u0438\u0442\u044C", "\u0422\u043E\u043B\u044C\u043A\u043E \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u044B\u0435", "\u0422\u043E\u043B\u044C\u043A\u043E \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u044B\u0435", "\u0422\u043E\u043B\u044C\u043A\u043E \u0441\u0442\u0440\u043E\u0433\u043E \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u044B\u0435", "\u041F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C \u0431\u0435\u0437 \u0444\u0430\u0439\u043B\u043E\u0432 cookie", "\u041D\u0435 \u043F\u0440\u0438\u043D\u0438\u043C\u0430\u0442\u044C", "\u041D\u0435\u0442, \u0441\u043F\u0430\u0441\u0438\u0431\u043E"],
+  close: ["\u0417\u0430\u043A\u0440\u044B\u0442\u044C", "\u041E\u0442\u043C\u0435\u043D\u0430", "\u0421\u043A\u0440\u044B\u0442\u044C", "\u041D\u0435 \u0441\u0435\u0439\u0447\u0430\u0441", "\u041D\u0435\u0442, \u0441\u043F\u0430\u0441\u0438\u0431\u043E", "\u041F\u043E\u0437\u0436\u0435", "\xD7"]
+};
+var ru_default = translations38;
+
+// src/translations/sk.ts
+var translations39 = {
+  accept: ["S\xFAhlas\xEDm", "S\xFAhlas\xEDm so v\u0161etk\xFDm", "Prija\u0165", "Prija\u0165 v\u0161etko", "Povoli\u0165", "Povoli\u0165 v\u0161etko", "OK", "Dobre", "Rozumiem", "Pokra\u010Dova\u0165", "Ulo\u017Ei\u0165 a prija\u0165", "S\xFAhlas\xEDm s cookies"],
+  reject: ["Odmietnu\u0165", "Odmietnu\u0165 v\u0161etko", "Nes\xFAhlas\xEDm", "Nepovoli\u0165", "Len nevyhnutn\xE9", "Iba nevyhnutn\xE9", "Len z\xE1kladn\xE9", "Pokra\u010Dova\u0165 bez cookies", "Nie, \u010Fakujem", "Bez \u010Fal\u0161\xEDch cookies"],
+  close: ["Zavrie\u0165", "Zru\u0161i\u0165", "Skry\u0165", "Teraz nie", "Nesk\xF4r", "Nie, \u010Fakujem", "Sp\xE4\u0165", "\xD7"]
+};
+var sk_default = translations39;
+
+// src/translations/sl.ts
+var translations40 = {
+  accept: ["Sprejmi", "Sprejmi vse", "Strinjam se", "Dovoli", "Dovoli vse", "V redu", "OK", "Razumem", "Nadaljuj", "Shrani in sprejmi", "Potrdi", "Shrani nastavitve"],
+  reject: ["Zavrni", "Zavrni vse", "Ne sprejemam", "Ne dovoli", "Samo nujno", "Le nujni pi\u0161kotki", "Nadaljuj brez pi\u0161kotkov", "Ne, hvala", "Onemogo\u010Di vse", "Zavrni neobvezne"],
+  close: ["Zapri", "Prekli\u010Di", "Ne zdaj", "Kasneje", "\xD7", "Skrij", "Zapri obvestilo", "Nazaj", "Zapri okno"]
+};
+var sl_default = translations40;
+
+// src/translations/sv.ts
+var translations41 = {
+  accept: [
+    "Godk\xE4nn",
+    "Godk\xE4nn alla",
+    "Acceptera",
+    "Acceptera alla",
+    "Jag samtycker",
+    "Till\xE5t",
+    "Till\xE5t alla",
+    "OK",
+    "Okej",
+    "Jag f\xF6rst\xE5r",
+    "Forts\xE4tt",
+    "Spara och godk\xE4nn",
+    "Bekr\xE4fta",
+    "G\xE5 vidare",
+    "Klart"
+  ],
+  reject: [
+    "Avvisa",
+    "Avvisa alla",
+    "Avb\xF6j",
+    "Neka",
+    "Neka alla",
+    "Endast n\xF6dv\xE4ndiga",
+    "Enbart n\xF6dv\xE4ndiga",
+    "Forts\xE4tt utan kakor",
+    "Nej tack",
+    "Avst\xE5"
+  ],
+  close: [
+    "St\xE4ng",
+    "Avbryt",
+    "St\xE4ng f\xF6nster",
+    "Inte nu",
+    "Nej tack",
+    "Senare",
+    "Hoppa \xF6ver",
+    "Tillbaka",
+    "\xD7"
+  ]
+};
+var sv_default = translations41;
+
+// src/translations/sw.ts
+var translations42 = {
+  accept: ["Kubali", "Kubali yote", "Ruhusu", "Ruhusu yote", "Sawa", "Sawa sawa", "Nimeelewa", "Endelea", "Hifadhi na kubali", "Nakubali"],
+  reject: ["Kataa", "Kataa yote", "Usiruhusu", "Usikubali", "Muhimu tu", "Ya lazima pekee", "Endelea bila vidakuzi", "Hapana, asante"],
+  close: ["Funga", "Ghairi", "Ondoa", "Puuza", "Tupilia mbali", "Si sasa", "Baadaye", "\xD7"]
+};
+var sw_default = translations42;
+
+// src/translations/ta.ts
+var translations43 = {
+  accept: ["\u0B8F\u0BB1\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B85\u0BA9\u0BC8\u0BA4\u0BCD\u0BA4\u0BC8\u0BAF\u0BC1\u0BAE\u0BCD \u0B8F\u0BB1\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B89\u0B9F\u0BA9\u0BCD\u0BAA\u0B9F\u0BC1\u0B95\u0BBF\u0BB1\u0BC7\u0BA9\u0BCD", "\u0B85\u0BA9\u0BC1\u0BAE\u0BA4\u0BBF\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B85\u0BA9\u0BC8\u0BA4\u0BCD\u0BA4\u0BC8\u0BAF\u0BC1\u0BAE\u0BCD \u0B85\u0BA9\u0BC1\u0BAE\u0BA4\u0BBF\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B9A\u0BB0\u0BBF", "\u0B93\u0B95\u0BC7", "\u0BAA\u0BC1\u0BB0\u0BBF\u0BA8\u0BCD\u0BA4\u0BA4\u0BC1", "\u0BA4\u0BCA\u0B9F\u0BB0\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B9A\u0BC7\u0BAE\u0BBF\u0BA4\u0BCD\u0BA4\u0BC1 \u0B8F\u0BB1\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD"],
+  reject: ["\u0BA8\u0BBF\u0BB0\u0BBE\u0B95\u0BB0\u0BBF\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B85\u0BA9\u0BC8\u0BA4\u0BCD\u0BA4\u0BC8\u0BAF\u0BC1\u0BAE\u0BCD \u0BA8\u0BBF\u0BB0\u0BBE\u0B95\u0BB0\u0BBF\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0BAE\u0BB1\u0BC1\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B85\u0BA9\u0BC1\u0BAE\u0BA4\u0BBF\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BBE\u0BAE\u0BCD", "\u0BA4\u0BC7\u0BB5\u0BC8\u0BAF\u0BBE\u0BA9\u0BB5\u0BC8 \u0BAE\u0B9F\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD", "\u0BAE\u0BC1\u0B95\u0BCD\u0B95\u0BBF\u0BAF\u0BAE\u0BBE\u0BA9\u0BB5\u0BC8 \u0BAE\u0B9F\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD", "\u0B95\u0BC1\u0B95\u0BCD\u0B95\u0BC0\u0B95\u0BB3\u0BCD \u0B87\u0BB2\u0BCD\u0BB2\u0BBE\u0BAE\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0BB0\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B87\u0BB2\u0BCD\u0BB2\u0BC8, \u0BA8\u0BA9\u0BCD\u0BB1\u0BBF"],
+  close: ["\u0BAE\u0BC2\u0B9F\u0BB5\u0BC1\u0BAE\u0BCD", "\u0BB0\u0BA4\u0BCD\u0BA4\u0BC1 \u0B9A\u0BC6\u0BAF\u0BCD\u0BAF\u0BB5\u0BC1\u0BAE\u0BCD", "\u0BA4\u0BB5\u0BBF\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD", "\u0B87\u0BAA\u0BCD\u0BAA\u0BCB\u0BA4\u0BC1 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BBE\u0BAE\u0BCD", "\u0B87\u0BB2\u0BCD\u0BB2\u0BC8, \u0BA8\u0BA9\u0BCD\u0BB1\u0BBF", "\u0BAA\u0BBF\u0BA9\u0BCD\u0BA9\u0BB0\u0BCD", "\xD7"]
+};
+var ta_default = translations43;
+
+// src/translations/th.ts
+var translations44 = {
+  accept: [
+    "\u0E22\u0E2D\u0E21\u0E23\u0E31\u0E1A",
+    "\u0E22\u0E2D\u0E21\u0E23\u0E31\u0E1A\u0E17\u0E31\u0E49\u0E07\u0E2B\u0E21\u0E14",
+    "\u0E40\u0E2B\u0E47\u0E19\u0E14\u0E49\u0E27\u0E22",
+    "\u0E2D\u0E19\u0E38\u0E0D\u0E32\u0E15",
+    "\u0E2D\u0E19\u0E38\u0E0D\u0E32\u0E15\u0E17\u0E31\u0E49\u0E07\u0E2B\u0E21\u0E14",
+    "\u0E15\u0E01\u0E25\u0E07",
+    "\u0E42\u0E2D\u0E40\u0E04",
+    "\u0E23\u0E31\u0E1A\u0E17\u0E23\u0E32\u0E1A",
+    "\u0E14\u0E33\u0E40\u0E19\u0E34\u0E19\u0E01\u0E32\u0E23\u0E15\u0E48\u0E2D",
+    "\u0E1A\u0E31\u0E19\u0E17\u0E36\u0E01\u0E41\u0E25\u0E30\u0E22\u0E2D\u0E21\u0E23\u0E31\u0E1A",
+    "\u0E1A\u0E31\u0E19\u0E17\u0E36\u0E01\u0E01\u0E32\u0E23\u0E15\u0E31\u0E49\u0E07\u0E04\u0E48\u0E32\u0E41\u0E25\u0E30\u0E22\u0E2D\u0E21\u0E23\u0E31\u0E1A",
+    "\u0E22\u0E37\u0E19\u0E22\u0E31\u0E19"
+  ],
+  reject: [
+    "\u0E1B\u0E0F\u0E34\u0E40\u0E2A\u0E18",
+    "\u0E1B\u0E0F\u0E34\u0E40\u0E2A\u0E18\u0E17\u0E31\u0E49\u0E07\u0E2B\u0E21\u0E14",
+    "\u0E44\u0E21\u0E48\u0E22\u0E2D\u0E21\u0E23\u0E31\u0E1A",
+    "\u0E44\u0E21\u0E48\u0E2D\u0E19\u0E38\u0E0D\u0E32\u0E15",
+    "\u0E40\u0E09\u0E1E\u0E32\u0E30\u0E04\u0E38\u0E01\u0E01\u0E35\u0E49\u0E17\u0E35\u0E48\u0E08\u0E33\u0E40\u0E1B\u0E47\u0E19",
+    "\u0E43\u0E0A\u0E49\u0E40\u0E09\u0E1E\u0E32\u0E30\u0E17\u0E35\u0E48\u0E08\u0E33\u0E40\u0E1B\u0E47\u0E19",
+    "\u0E44\u0E1B\u0E15\u0E48\u0E2D\u0E42\u0E14\u0E22\u0E44\u0E21\u0E48\u0E43\u0E0A\u0E49\u0E04\u0E38\u0E01\u0E01\u0E35\u0E49",
+    "\u0E44\u0E21\u0E48 \u0E02\u0E2D\u0E1A\u0E04\u0E38\u0E13",
+    "\u0E02\u0E49\u0E32\u0E21"
+  ],
+  close: [
+    "\u0E1B\u0E34\u0E14",
+    "\u0E22\u0E01\u0E40\u0E25\u0E34\u0E01",
+    "\u0E1B\u0E34\u0E14\u0E2B\u0E19\u0E49\u0E32\u0E15\u0E48\u0E32\u0E07",
+    "\u0E1B\u0E34\u0E14\u0E01\u0E32\u0E23\u0E41\u0E08\u0E49\u0E07\u0E40\u0E15\u0E37\u0E2D\u0E19",
+    "\u0E22\u0E31\u0E07\u0E44\u0E21\u0E48\u0E43\u0E0A\u0E48\u0E15\u0E2D\u0E19\u0E19\u0E35\u0E49",
+    "\u0E44\u0E27\u0E49\u0E17\u0E35\u0E2B\u0E25\u0E31\u0E07",
+    "\u0E17\u0E35\u0E2B\u0E25\u0E31\u0E07",
+    "\xD7"
+  ]
+};
+var th_default = translations44;
+
+// src/translations/tl.ts
+var translations45 = {
+  accept: ["Tanggapin", "Tanggapin lahat", "Sumang-ayon", "Payagan", "Payagan lahat", "OK", "Okay", "Sige", "Naintindihan", "Magpatuloy", "I-save at tanggapin"],
+  reject: ["Tanggihan", "Tanggihan lahat", "Huwag payagan", "Kinakailangan lang", "Mga kinakailangan lang", "Mahahalaga lang", "Magpatuloy nang walang mga cookie", "Hindi, salamat", "Huwag na lang"],
+  close: ["Isara", "Kanselahin", "Isantabi", "Hindi ngayon", "Huwag muna", "Mamaya", "\xD7"]
+};
+var tl_default = translations45;
+
+// src/translations/tr.ts
+var translations46 = {
+  accept: [
+    "Kabul et",
+    "T\xFCm\xFCn\xFC kabul et",
+    "Onayla",
+    "\u0130zin ver",
+    "T\xFCm\xFCne izin ver",
+    "Anlad\u0131m",
+    "Devam et",
+    "Kaydet ve kabul et",
+    "Ayarlar\u0131 kaydet",
+    "Kabul ediyorum"
+  ],
+  reject: [
+    "Reddet",
+    "T\xFCm\xFCn\xFC reddet",
+    "Kabul etmiyorum",
+    "\u0130zin verme",
+    "Yaln\u0131zca gerekli olanlar",
+    "Sadece zorunlu olanlar",
+    "Gerekli olanlarla devam et",
+    "\xC7erez olmadan devam et",
+    "\xC7erezsiz devam et",
+    "Hay\u0131r, te\u015Fekk\xFCrler",
+    "Yaln\u0131zca zorunlu \xE7erezlere izin ver"
+  ],
+  close: [
+    "Kapat",
+    "\u0130ptal",
+    "Vazge\xE7",
+    "\u015Eimdilik de\u011Fil",
+    "Daha sonra",
+    "Geri",
+    "Pencereyi kapat",
+    "\xD7",
+    "X",
+    "Tamam"
+  ]
+};
+var tr_default = translations46;
+
+// src/translations/uk.ts
+var translations47 = {
+  accept: ["\u041F\u0440\u0438\u0439\u043D\u044F\u0442\u0438", "\u041F\u0440\u0438\u0439\u043D\u044F\u0442\u0438 \u0432\u0441\u0435", "\u041F\u043E\u0433\u043E\u0434\u0438\u0442\u0438\u0441\u044F", "\u0414\u043E\u0437\u0432\u043E\u043B\u0438\u0442\u0438", "\u0414\u043E\u0437\u0432\u043E\u043B\u0438\u0442\u0438 \u0432\u0441\u0435", "\u041E\u041A", "\u0414\u043E\u0431\u0440\u0435", "\u0417\u0440\u043E\u0437\u0443\u043C\u0456\u043B\u043E", "\u041F\u0440\u043E\u0434\u043E\u0432\u0436\u0438\u0442\u0438", "\u0417\u0431\u0435\u0440\u0435\u0433\u0442\u0438 \u0442\u0430 \u043F\u0440\u0438\u0439\u043D\u044F\u0442\u0438", "\u041F\u0456\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u0442\u0438", "\u0422\u0430\u043A", "\u0413\u0430\u0440\u0430\u0437\u0434", "\u0414\u0430\u043B\u0456"],
+  reject: ["\u0412\u0456\u0434\u0445\u0438\u043B\u0438\u0442\u0438", "\u0412\u0456\u0434\u0445\u0438\u043B\u0438\u0442\u0438 \u0432\u0441\u0435", "\u0412\u0456\u0434\u043C\u043E\u0432\u0438\u0442\u0438\u0441\u044F", "\u041D\u0435 \u043F\u0440\u0438\u0439\u043C\u0430\u0442\u0438", "\u041D\u0435 \u0434\u043E\u0437\u0432\u043E\u043B\u044F\u0442\u0438", "\u041B\u0438\u0448\u0435 \u043D\u0435\u043E\u0431\u0445\u0456\u0434\u043D\u0456", "\u0422\u0456\u043B\u044C\u043A\u0438 \u043D\u0435\u043E\u0431\u0445\u0456\u0434\u043D\u0456", "\u041B\u0438\u0448\u0435 \u043E\u0431\u043E\u0432\u2019\u044F\u0437\u043A\u043E\u0432\u0456", "\u041F\u0440\u043E\u0434\u043E\u0432\u0436\u0438\u0442\u0438 \u0431\u0435\u0437 \u0444\u0430\u0439\u043B\u0456\u0432 cookie", "\u0411\u0435\u0437 \u0444\u0430\u0439\u043B\u0456\u0432 cookie", "\u041D\u0456, \u0434\u044F\u043A\u0443\u044E"],
+  close: ["\u0417\u0430\u043A\u0440\u0438\u0442\u0438", "\u0421\u043A\u0430\u0441\u0443\u0432\u0430\u0442\u0438", "\u0417\u0430\u043A\u0440\u0438\u0442\u0438 \u0432\u0456\u043A\u043D\u043E", "\u041D\u0435 \u0437\u0430\u0440\u0430\u0437", "\u041F\u0456\u0437\u043D\u0456\u0448\u0435", "\u041F\u0440\u043E\u043F\u0443\u0441\u0442\u0438\u0442\u0438", "\u0413\u043E\u0442\u043E\u0432\u043E", "\xD7"]
+};
+var uk_default = translations47;
+
+// src/translations/ur.ts
+var translations48 = {
+  accept: [
+    "\u0642\u0628\u0648\u0644 \u06A9\u0631\u06CC\u06BA",
+    "\u0633\u0628 \u0642\u0628\u0648\u0644 \u06A9\u0631\u06CC\u06BA",
+    "\u0642\u0628\u0648\u0644 \u06C1\u06D2",
+    "\u0645\u06CC\u06BA \u0645\u062A\u0641\u0642 \u06C1\u0648\u06BA",
+    "\u0627\u062C\u0627\u0632\u062A \u062F\u06CC\u06BA",
+    "\u062A\u0645\u0627\u0645 \u06A9\u06CC \u0627\u062C\u0627\u0632\u062A \u062F\u06CC\u06BA",
+    "\u0679\u06BE\u06CC\u06A9 \u06C1\u06D2",
+    "\u0627\u0648\u06A9\u06D2",
+    "\u062C\u0627\u0631\u06CC \u0631\u06A9\u06BE\u06CC\u06BA",
+    "\u0622\u06AF\u06D2 \u0628\u0691\u06BE\u06CC\u06BA",
+    "\u0645\u062D\u0641\u0648\u0638 \u06A9\u0631\u06CC\u06BA \u0627\u0648\u0631 \u0642\u0628\u0648\u0644 \u06A9\u0631\u06CC\u06BA",
+    "\u06C1\u0627\u06BA"
+  ],
+  reject: [
+    "\u0631\u062F \u06A9\u0631\u06CC\u06BA",
+    "\u0633\u0628 \u0631\u062F \u06A9\u0631\u06CC\u06BA",
+    "\u0627\u0646\u06A9\u0627\u0631 \u06A9\u0631\u06CC\u06BA",
+    "\u0627\u062C\u0627\u0632\u062A \u0646\u06C1 \u062F\u06CC\u06BA",
+    "\u0635\u0631\u0641 \u0636\u0631\u0648\u0631\u06CC",
+    "\u0635\u0631\u0641 \u0644\u0627\u0632\u0645\u06CC",
+    "\u0635\u0631\u0641 \u0628\u0646\u06CC\u0627\u062F\u06CC",
+    "\u06A9\u0648\u06A9\u06CC\u0632 \u06A9\u06D2 \u0628\u063A\u06CC\u0631 \u062C\u0627\u0631\u06CC \u0631\u06A9\u06BE\u06CC\u06BA",
+    "\u0646\u06C1\u06CC\u06BA\u060C \u0634\u06A9\u0631\u06CC\u06C1",
+    "\u0642\u0628\u0648\u0644 \u0646\u06C1\u06CC\u06BA",
+    "\u0645\u0646\u0639 \u06A9\u0631\u06CC\u06BA",
+    "\u0627\u062E\u062A\u06CC\u0627\u0631\u0627\u062A \u0645\u062D\u062F\u0648\u062F \u06A9\u0631\u06CC\u06BA"
+  ],
+  close: [
+    "\u0628\u0646\u062F \u06A9\u0631\u06CC\u06BA",
+    "\u0645\u0646\u0633\u0648\u062E \u06A9\u0631\u06CC\u06BA",
+    "\u062E\u0627\u0631\u062C \u06A9\u0631\u06CC\u06BA",
+    "\u0627\u0628\u06BE\u06CC \u0646\u06C1\u06CC\u06BA",
+    "\u0628\u0639\u062F \u0645\u06CC\u06BA",
+    "\u0646\u06C1\u06CC\u06BA\u060C \u0634\u06A9\u0631\u06CC\u06C1",
+    "\xD7",
+    "\u0648\u0627\u067E\u0633",
+    "\u0686\u06BE\u067E\u0627\u0626\u06CC\u06BA"
+  ]
+};
+var ur_default = translations48;
+
+// src/translations/vi.ts
+var translations49 = {
+  accept: ["\u0110\u1ED3ng \xFD", "T\xF4i \u0111\u1ED3ng \xFD", "Ch\u1EA5p nh\u1EADn", "Ch\u1EA5p nh\u1EADn t\u1EA5t c\u1EA3", "Cho ph\xE9p", "Cho ph\xE9p t\u1EA5t c\u1EA3", "OK", "\u0110\xE3 hi\u1EC3u", "Ti\u1EBFp t\u1EE5c", "L\u01B0u v\xE0 ch\u1EA5p nh\u1EADn"],
+  reject: ["T\u1EEB ch\u1ED1i", "T\u1EEB ch\u1ED1i t\u1EA5t c\u1EA3", "Kh\xF4ng \u0111\u1ED3ng \xFD", "Kh\xF4ng cho ph\xE9p", "Ch\u1EC9 b\u1EAFt bu\u1ED9c", "Ch\u1EC9 cho ph\xE9p c\u1EA7n thi\u1EBFt", "Ti\u1EBFp t\u1EE5c m\xE0 kh\xF4ng c\u1EA7n cookie", "Kh\xF4ng, c\u1EA3m \u01A1n"],
+  close: ["\u0110\xF3ng", "H\u1EE7y", "B\u1ECF qua", "Kh\xF4ng ph\u1EA3i b\xE2y gi\u1EDD", "\u0110\u1EC3 sau", "Kh\xF4ng, c\u1EA3m \u01A1n", "\xD7", "T\u1EAFt", "\u1EA8n"]
+};
+var vi_default = translations49;
+
+// src/translations/zh.ts
+var translations50 = {
+  accept: ["\u540C\u610F", "\u5168\u90E8\u540C\u610F", "\u63A5\u53D7", "\u5168\u90E8\u63A5\u53D7", "\u5141\u8BB8", "\u5168\u90E8\u5141\u8BB8", "\u786E\u5B9A", "\u597D\u7684", "\u6211\u77E5\u9053\u4E86", "\u7EE7\u7EED", "\u4FDD\u5B58\u5E76\u63A5\u53D7", "\u7EE7\u7EED\u5E76\u540C\u610F"],
+  reject: ["\u62D2\u7EDD", "\u5168\u90E8\u62D2\u7EDD", "\u4E0D\u540C\u610F", "\u4E0D\u5141\u8BB8", "\u4EC5\u4FDD\u7559\u5FC5\u8981\u9879", "\u4EC5\u9650\u5FC5\u8981", "\u4EC5\u542F\u7528\u5FC5\u8981\u529F\u80FD", "\u4EC5\u4F7F\u7528\u5FC5\u8981 Cookie", "\u7EE7\u7EED\u4F46\u4E0D\u4F7F\u7528 Cookie", "\u4E0D\u7528\u4E86\uFF0C\u8C22\u8C22", "\u6682\u4E0D\u540C\u610F"],
+  close: ["\u5173\u95ED", "\u53D6\u6D88", "\u5FFD\u7565", "\u6682\u4E0D", "\u7A0D\u540E", "\u4EE5\u540E\u518D\u8BF4", "\u8FD4\u56DE", "\xD7"]
+};
+var zh_default = translations50;
+
+// src/translations/index.ts
+var languages = {
+  af: af_default,
+  ar: ar_default,
+  az: az_default,
+  bg: bg_default,
+  bn: bn_default,
+  bs: bs_default,
+  ca: ca_default,
+  cs: cs_default,
+  da: da_default,
+  de: de_default,
+  el: el_default,
+  en: en_default,
+  es: es_default,
+  et: et_default,
+  eu: eu_default,
+  fa: fa_default,
+  fi: fi_default,
+  fr: fr_default,
+  ga: ga_default,
+  he: he_default,
+  hi: hi_default,
+  hr: hr_default,
+  hu: hu_default,
+  hy: hy_default,
+  id: id_default,
+  is: is_default,
+  it: it_default,
+  ja: ja_default,
+  ka: ka_default,
+  ko: ko_default,
+  lt: lt_default,
+  lv: lv_default,
+  nl: nl_default,
+  no: no_default,
+  pl: pl_default,
+  pt: pt_default,
+  ro: ro_default,
+  ru: ru_default,
+  sk: sk_default,
+  sl: sl_default,
+  sv: sv_default,
+  sw: sw_default,
+  ta: ta_default,
+  th: th_default,
+  tl: tl_default,
+  tr: tr_default,
+  uk: uk_default,
+  ur: ur_default,
+  vi: vi_default,
+  zh: zh_default
+};
+function normalizeLang(input) {
+  const code = input.toLowerCase();
+  if (code in languages) return code;
+  return "en";
+}
+function getTranslations(lang) {
+  const code = normalizeLang(lang);
+  return languages[code];
+}
+
+// src/suppress-interferences.ts
+var knownCMPSelectors = [
+  { name: "OneTrust", accept: ["#onetrust-accept-btn-handler"], reject: ["#onetrust-reject-all-handler"] },
+  {
+    name: "Cookiebot",
+    accept: ["#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll"],
+    reject: ["#CybotCookiebotDialogBodyLevelButtonDecline"]
+  },
+  { name: "Didomi", accept: ["button.didomi-accept-all"], reject: ["button.didomi-reject-all"] },
+  {
+    name: "Quantcast",
+    accept: ['button[qc-cmp2-action="accept_all"]'],
+    reject: ['button[qc-cmp2-action="reject_all"]']
+  },
+  {
+    name: "TrustArc",
+    accept: ["#truste-consent-button"],
+    reject: ["#truste-reject-button", "#truste-consent-required"]
+  },
+  { name: "Iubenda", accept: ["button.iubenda-cs-accept-btn"], reject: ["button.iubenda-cs-reject-btn"] },
+  {
+    name: "CookieYes",
+    accept: ["#wt-cli-accept-all-btn", "#cookie_action_close_header"],
+    reject: ["#wt-cli-reject-btn"]
+  },
+  { name: "Osano", accept: [".osano-cm-accept-all"], reject: [".osano-cm-reject-all"] },
+  { name: "Klaro", accept: [".cm-btn-accept"], reject: [".cm-btn-decline"] }
+];
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizePhrase(p) {
+  return escapeRegex(p.trim()).replace(/\s+/g, "\\s+");
+}
+function buildRegexFromTranslations(phrases, opts) {
+  const unique = Array.from(new Set(phrases.map(normalizePhrase))).filter((s) => s.length > 0);
+  const body = unique.length ? unique.join("|") : "";
+  const source = opts?.anchorWhole ? `^(?:${body})$` : `(?:${body})`;
+  return new RegExp(source, opts?.flags ?? "i");
+}
+async function tryClick(page, selectors, _label) {
+  for (const s of selectors) {
+    const el = page.locator(s).first();
+    if (await el.count().catch(() => 0)) {
+      try {
+        await el.scrollIntoViewIfNeeded({ timeout: 250 });
+        await el.click({ timeout: 500 });
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+async function closeNativeJsAlerts(page) {
+  page.on("dialog", (d) => d.accept().catch(() => {
+  }));
+}
+async function sweepKnownCMPs(page, preferReject) {
+  for (const cmp of knownCMPSelectors) {
+    if (preferReject && await tryClick(page, cmp.reject, `${cmp.name} reject`)) return true;
+    if (await tryClick(page, cmp.accept, `${cmp.name} accept`)) return true;
+    if (!preferReject && await tryClick(page, cmp.reject, `${cmp.name} reject`)) return true;
+  }
+  return false;
+}
+async function clickByRoleAndText(page, preferReject, regex) {
+  const dialogs = page.getByRole("dialog");
+  if (await dialogs.count().catch(() => 0)) {
+    const target = preferReject ? dialogs.getByRole("button", { name: regex.reject }).first() : dialogs.getByRole("button", { name: regex.accept }).first();
+    if (await target.count().catch(() => 0)) {
+      try {
+        await target.click({ timeout: 700 });
+        return true;
+      } catch {
+      }
+    }
+    const any = await dialogs.getByRole("button", { name: regex.accept }).first().count() || await dialogs.getByRole("button", { name: regex.reject }).first().count();
+    if (any) {
+      try {
+        const btn = dialogs.getByRole("button", { name: regex.accept }).first();
+        await (await btn.count() ? btn : dialogs.getByRole("button", { name: regex.reject }).first()).click({
+          timeout: 700
+        });
+        return true;
+      } catch {
+      }
+    }
+    const close = dialogs.getByRole("button", { name: regex.close }).first();
+    if (await close.count().catch(() => 0)) {
+      try {
+        await close.click({ timeout: 700 });
+        return true;
+      } catch {
+      }
+    }
+  }
+  const generic = page.getByRole("button", { name: preferReject ? regex.reject : regex.accept }).first();
+  if (await generic.count().catch(() => 0)) {
+    try {
+      await generic.click({ timeout: 700 });
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function sweepNewsletter(page, regex) {
+  const modalLike = page.locator("*:visible").filter({
+    has: page.locator('input[type="email"],input[placeholder*="email" i]')
+  });
+  if (await modalLike.count().catch(() => 0)) {
+    const close = modalLike.getByRole("button", { name: regex.close }).first();
+    if (await close.count().catch(() => 0)) {
+      try {
+        await close.click({ timeout: 700 });
+        return true;
+      } catch {
+      }
+    }
+    const overlay = page.locator('div[role="presentation"], .modal-backdrop, .overlay, .ReactModal__Overlay');
+    if (await overlay.count().catch(() => 0)) {
+      try {
+        await overlay.first().click({ timeout: 500, position: { x: 5, y: 5 } });
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+async function sweepOverlays(page, regex) {
+  const acceptRxSource = regex.accept.source;
+  const acceptRxFlags = regex.accept.flags;
+  return await page.evaluate(
+    ([source, flags]) => {
+      const acceptRx = new RegExp(source, flags);
+      const isBig = (el) => {
+        const r = el.getBoundingClientRect?.();
+        return r && r.width > window.innerWidth * 0.6 && r.height > window.innerHeight * 0.4;
+      };
+      const candidates = Array.from(document.querySelectorAll("body *")).filter((el) => {
+        const s = getComputedStyle(el);
+        if (!s) return false;
+        const fixed = s.position === "fixed" || s.position === "sticky";
+        const z = parseInt(s.zIndex || "0", 10);
+        return fixed && z >= 1e3 && isBig(el) && el.offsetParent !== null;
+      }).slice(0, 5);
+      for (const el of candidates) {
+        const btn = el.querySelector(
+          '[aria-label*="close" i], button[aria-label*="close" i], button:has(svg), .close, [data-close], .btn-close'
+        );
+        if (btn) {
+          btn.click();
+          return true;
+        }
+        const clickByText = (rx) => {
+          const walker = document.createTreeWalker(el, NodeFilter.SHOW_ELEMENT);
+          let n;
+          while (n = walker.nextNode()) {
+            const e = n;
+            if (!e) continue;
+            if (!e.offsetParent) continue;
+            const text = e.innerText?.trim();
+            if (text && rx.test(text)) {
+              e.click();
+              return true;
+            }
+          }
+          return false;
+        };
+        if (clickByText(acceptRx)) return true;
+      }
+      return false;
+    },
+    [acceptRxSource, acceptRxFlags]
+  ).catch(() => false);
+}
+async function suppressInterferences(page, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 4e3;
+  const preferReject = opts.preferReject ?? false;
+  const pollIntervalMs = opts.pollIntervalMs ?? 120;
+  const settleAfterActionMs = opts.settleAfterActionMs ?? 500;
+  const quietPeriodMs = opts.quietPeriodMs ?? 800;
+  const minSweepMs = opts.minSweepMs ?? 500;
+  const maxActions = opts.maxActions ?? 6;
+  const { accept, reject, close } = getTranslations(opts.lang ?? "en");
+  const regex = {
+    accept: buildRegexFromTranslations(accept, { anchorWhole: true }),
+    reject: buildRegexFromTranslations(reject, { anchorWhole: true }),
+    close: buildRegexFromTranslations(close, { anchorWhole: false })
+  };
+  await closeNativeJsAlerts(page);
+  let actions = 0;
+  const startedAt = Date.now();
+  let lastActivityAt = startedAt;
+  while (Date.now() < lastActivityAt + timeoutMs) {
+    const did = await sweepKnownCMPs(page, preferReject) || await clickByRoleAndText(page, preferReject, regex) || await sweepNewsletter(page, regex) || await sweepOverlays(page, regex);
+    if (did) {
+      actions += 1;
+      lastActivityAt = Date.now();
+      if (actions >= maxActions) {
+        if (opts.verbose) console.log(`[suppressInterferences] Max actions ${maxActions} reached, stopping.`);
+        break;
+      }
+      await sleep(settleAfterActionMs);
+      continue;
+    }
+    const quietFor = Date.now() - lastActivityAt;
+    const ranFor = Date.now() - startedAt;
+    if (quietFor >= quietPeriodMs && ranFor >= minSweepMs) {
+      if (opts.verbose) console.log(`[suppressInterferences] Quiet for ${quietFor}ms, stopping early.`);
+      break;
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+
+export { browse, createDateEngine, createFieldEngine, formatDate, formatDateForInput, formatHtml, getMonthNames, locator, screenshot, scrollToCenter, setFieldValue, snapshot, suppressInterferences, waitAfterInteraction, waitForAnimationsToFinish, waitForDomIdle, waitForIdle, waitForMeta, waitForUrlChange, waitUntilEnabled };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map