watchwhere 0.2.0

package/src/commands/subs.ts

@@ -0,0 +1,48 @@
+import { checkbox } from "@inquirer/prompts";
+import { c } from "../colors.ts";
+import { loadConfig, saveConfig } from "../config.ts";
+import { resolveLocale, t } from "../i18n.ts";
+import { getCachedRegionProviders } from "../cache.ts";
+
+export async function runSubs(): Promise<void> {
+  const cfg = await loadConfig();
+  if (!cfg) {
+    throw new Error(t(resolveLocale()).noConfigYet);
+  }
+  const m = t(resolveLocale(cfg.language));
+
+  process.stdout.write(c.dim(`  ${m.loadingProviders(cfg.region)}`));
+  const providers = await getCachedRegionProviders(cfg.region, cfg.tmdbToken);
+  console.log(c.dim(m.providersFound(providers.length)));
+
+  if (providers.length === 0) {
+    throw new Error(m.noProviders(cfg.region));
+  }
+
+  const current = new Set(cfg.subscriptions);
+
+  const subscriptions = await checkbox<number>({
+    message: `${m.yourSubsLabel(cfg.region)} ${c.dim(m.toggleHintSave)}:`,
+    choices: providers.map((p) => ({
+      name: p.provider_name,
+      value: p.provider_id,
+      checked: current.has(p.provider_id),
+    })),
+    pageSize: 15,
+    loop: false,
+  });
+
+  const added = subscriptions.filter((id) => !current.has(id)).length;
+  const removed = cfg.subscriptions.filter((id) => !subscriptions.includes(id)).length;
+
+  const saved = await saveConfig({
+    tmdbToken: cfg.tmdbToken,
+    region: cfg.region,
+    language: cfg.language,
+    subscriptions,
+  });
+
+  console.log();
+  console.log(`  ${c.green("✓")} ${m.updatedConfigFile} ${c.dim("~/.watchwhere/config.json")}`);
+  console.log(`    ${m.subscriptionsLabel.padEnd(13)} ${saved.subscriptions.length} ${c.dim(`(+${added} / -${removed})`)}`);
+}

package/src/config.ts

@@ -0,0 +1,79 @@
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveLocale, t } from "./i18n.ts";
+
+export interface Config {
+  readonly tmdbToken: string;
+  readonly region: string;
+  readonly language: string;
+  readonly subscriptions: ReadonlyArray<number>;
+  readonly updatedAt: string;
+}
+
+const DEFAULT_LANGUAGE = "en-US";
+
+const CONFIG_DIR = join(homedir(), ".watchwhere");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export const configPath = CONFIG_FILE;
+
+interface RawConfig {
+  tmdbToken: unknown;
+  region: unknown;
+  language?: unknown;
+  subscriptions: unknown;
+  updatedAt?: unknown;
+}
+
+function parseConfig(value: unknown): Config | null {
+  if (typeof value !== "object" || value === null) return null;
+  const v = value as RawConfig;
+  if (
+    typeof v.tmdbToken !== "string" ||
+    typeof v.region !== "string" ||
+    !Array.isArray(v.subscriptions) ||
+    !v.subscriptions.every((n) => typeof n === "number")
+  ) {
+    return null;
+  }
+  return {
+    tmdbToken: v.tmdbToken,
+    region: v.region,
+    language: typeof v.language === "string" ? v.language : DEFAULT_LANGUAGE,
+    subscriptions: v.subscriptions,
+    updatedAt: typeof v.updatedAt === "string" ? v.updatedAt : new Date(0).toISOString(),
+  };
+}
+
+export async function loadConfig(): Promise<Config | null> {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf8");
+    const cfg = parseConfig(JSON.parse(raw) as unknown);
+    if (!cfg) throw new Error(t(resolveLocale()).corruptConfig(CONFIG_FILE));
+    return cfg;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+export async function saveConfig(
+  cfg: Omit<Config, "updatedAt">,
+): Promise<Config> {
+  const full: Config = { ...cfg, updatedAt: new Date().toISOString() };
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+
+  // write to tmp then rename — avoids half-written config on crash
+  const tmp = `${CONFIG_FILE}.tmp.${process.pid}`;
+  await writeFile(tmp, JSON.stringify(full, null, 2), {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  if (process.platform !== "win32") {
+    // windows ignores chmod
+    await chmod(tmp, 0o600);
+  }
+  await rename(tmp, CONFIG_FILE);
+  return full;
+}

package/src/i18n.ts

@@ -0,0 +1,345 @@
+export type Locale = "en" | "tr";
+
+const SUPPORTED: ReadonlySet<Locale> = new Set<Locale>(["en", "tr"]);
+const DEFAULT_LOCALE: Locale = "en";
+
+function head(input: string): string {
+  // tr-TR / tr_TR.UTF-8 → tr
+  return input.toLowerCase().split(/[-_.]/)[0] ?? "";
+}
+
+function fromEnv(): Locale {
+  const raw = process.env.LANG ?? process.env.LC_ALL ?? "";
+  const h = head(raw);
+  return SUPPORTED.has(h as Locale) ? (h as Locale) : DEFAULT_LOCALE;
+}
+
+export function resolveLocale(input?: string): Locale {
+  if (!input) return fromEnv();
+  const h = head(input);
+  return SUPPORTED.has(h as Locale) ? (h as Locale) : DEFAULT_LOCALE;
+}
+
+interface Catalog {
+  // generic
+  error: string;
+  ok: string;
+  done: string;
+  offline: string;
+  failed: string;
+
+  // media tags
+  tagMovie: string;
+  tagTv: string;
+
+  // search
+  searchEmpty: string;
+  searching: (query: string) => string;
+  resultsCount: (n: number) => string;
+  noMatch: string;
+  whichOne: string;
+  emptyResult: string;
+  fetchingProviders: (region: string) => string;
+  notAvailable: (region: string) => string;
+  notAvailableHint: string;
+  onYourSubsPrefix: string;
+  streamingNotOnSubs: (region: string) => string;
+  noStreamingSub: (region: string) => string;
+  owned: string;
+  notOwned: string;
+  onPrefix: string;
+  free: string;
+  ads: string;
+  rent: string;
+  buy: string;
+  link: string;
+
+  // config (show)
+  noConfigYet: string;
+  resolvingNames: string;
+  configTitle: string;
+  regionLabel: string;
+  languageLabel: string;
+  tokenLabel: string;
+  updatedLabel: string;
+  pathLabel: string;
+  subscriptionsLabel: string;
+  noSubs: string;
+
+  // init
+  firstTimeSetup: string;
+  configNotWritten: string;
+  existingConfig: (region: string) => string;
+  tokenPrompt: string;
+  tokenHint: string;
+  invalidToken: string;
+  tokenTooShort: string;
+  verifying: string;
+  usingProxyNotice: string;
+  regionPrompt: string;
+  regionInvalid: string;
+  displayLanguagePrompt: string;
+  loadingProviders: (region: string) => string;
+  providersFound: (n: number) => string;
+  noProviders: (region: string) => string;
+  yourSubsLabel: (region: string) => string;
+  toggleHintConfirm: string;
+  toggleHintSave: string;
+  savedTo: string;
+  updatedConfigFile: string;
+
+  // validation
+  corruptConfig: (path: string) => string;
+
+  // lang / region commands + cancellation
+  languageUpdated: (code: string) => string;
+  cancelled: string;
+  currentLanguage: (code: string) => string;
+  currentRegion: (code: string) => string;
+  regionUpdated: (code: string) => string;
+  regionHintReviewSubs: string;
+
+  // usage / --help
+  usageTagline: string;
+  usageSectionUsage: string;
+  usageSectionConfig: string;
+  usageDescTitle: string;
+  usageDescInit: string;
+  usageDescSubs: string;
+  usageDescLang: string;
+  usageDescRegion: string;
+  usageDescConfig: string;
+  usageDescHelp: string;
+
+  // routing / hints
+  unknownOption: (opt: string) => string;
+  unknownCommand: (cmd: string) => string;
+  didYouMean: (cmd: string) => string;
+  noConfigHint: string;
+  tokenExpired: string;
+  networkOffline: string;
+  networkTimeout: string;
+  relativeNow: string;
+  relativeMinutes: (n: number) => string;
+  relativeHours: (n: number) => string;
+  relativeDays: (n: number) => string;
+
+  // non-TTY
+  ttyRequired: (cmd: string) => string;
+  ambiguousQuery: (n: number) => string;
+}
+
+const en: Catalog = {
+  error: "error",
+  ok: "ok",
+  done: "done",
+  offline: "offline",
+  failed: "failed",
+
+  tagMovie: "movie",
+  tagTv: "tv",
+
+  searchEmpty: "search title is empty",
+  searching: (q) => `searching "${q}"… `,
+  resultsCount: (n) => `${n} result${n === 1 ? "" : "s"}`,
+  noMatch: "no match. try a different spelling or original title.",
+  whichOne: "which one?",
+  emptyResult: "empty result",
+  fetchingProviders: (region) => `fetching providers (${region})… `,
+  notAvailable: (region) => `not available in ${region}.`,
+  notAvailableHint:
+    "(TMDB has no data for this region — VPN to another region may help.)",
+  onYourSubsPrefix: "on your subs:",
+  streamingNotOnSubs: (region) =>
+    `streaming in ${region}, but not on your subs.`,
+  noStreamingSub: (region) => `no streaming subscription in ${region}.`,
+  owned: "owned",
+  notOwned: "not owned",
+  onPrefix: "on",
+  free: "free",
+  ads: "ads",
+  rent: "rent",
+  buy: "buy",
+  link: "link",
+
+  noConfigYet: "no config yet — run `ww init` first.",
+  resolvingNames: "resolving subscription names… ",
+  configTitle: "watchwhere config",
+  regionLabel: "region",
+  languageLabel: "language",
+  tokenLabel: "token",
+  updatedLabel: "updated",
+  pathLabel: "path",
+  subscriptionsLabel: "subscriptions",
+  noSubs: "none — run `ww subs` to add some",
+
+  firstTimeSetup: "first-time setup",
+  configNotWritten: "config not written",
+  existingConfig: (region) =>
+    `existing config found (${region}) — will overwrite`,
+  tokenPrompt: "TMDB Read Access Token (v4)",
+  tokenHint: "themoviedb.org/settings/api",
+  invalidToken: "invalid TMDB token. use the v4 'Read Access Token'.",
+  tokenTooShort: "token looks too short",
+  verifying: "verifying token… ",
+  usingProxyNotice: "using proxy — skipping token setup",
+  regionPrompt: "region code (ISO-3166-1, e.g. TR / US / DE):",
+  regionInvalid: "two-letter region code (e.g. TR)",
+  displayLanguagePrompt: "display language:",
+  loadingProviders: (region) => `loading providers for ${region}… `,
+  providersFound: (n) => `${n} found`,
+  noProviders: (region) =>
+    `no providers found for region ${region}. check the code.`,
+  yourSubsLabel: (region) => `your subscriptions in ${region}`,
+  toggleHintConfirm: "(space to toggle, enter to confirm)",
+  toggleHintSave: "(space to toggle, enter to save)",
+  savedTo: "saved to",
+  updatedConfigFile: "updated",
+
+  corruptConfig: (path) => `corrupt config file: ${path}`,
+
+  languageUpdated: (code) => `language updated to ${code}`,
+  cancelled: "cancelled",
+  currentLanguage: (code) => `current: ${code}`,
+  currentRegion: (code) => `current: ${code}`,
+  regionUpdated: (code) => `region updated to ${code}`,
+  regionHintReviewSubs: "providers vary by region — run `ww subs` to review your list.",
+
+  usageTagline: "where can I stream it?",
+  usageSectionUsage: "usage",
+  usageSectionConfig: "config",
+  usageDescTitle: "search a movie or show in your region",
+  usageDescInit: "set up token, region, language, subscriptions",
+  usageDescSubs: "edit your subscriptions only",
+  usageDescLang: "change display language",
+  usageDescRegion: "change region",
+  usageDescConfig: "show current config",
+  usageDescHelp: "this message",
+
+  unknownOption: (opt) => `unknown option: ${opt}. run \`ww --help\`.`,
+  unknownCommand: (cmd) => `unknown command: ${cmd}`,
+  didYouMean: (cmd) => `did you mean \`ww ${cmd}\`?`,
+  noConfigHint: "no config yet — run `ww init` to get started.",
+  tokenExpired: "TMDB token rejected (401). run `ww init` to re-enter it.",
+  networkOffline: "couldn't reach TMDB. check your internet connection.",
+  networkTimeout: "TMDB request timed out. try again, or check your connection.",
+  relativeNow: "just now",
+  relativeMinutes: (n) => `${n} min ago`,
+  relativeHours: (n) => `${n} hr ago`,
+  relativeDays: (n) => `${n} day${n === 1 ? "" : "s"} ago`,
+
+  ttyRequired: (cmd) => `\`ww ${cmd}\` is interactive — run it in a terminal, not a pipe.`,
+  ambiguousQuery: (n) => `${n} matches — query is ambiguous. refine, or run interactively.`,
+};
+
+const tr: Catalog = {
+  error: "hata",
+  ok: "tamam",
+  done: "tamam",
+  offline: "çevrimdışı",
+  failed: "başarısız",
+
+  tagMovie: "film",
+  tagTv: "dizi",
+
+  searchEmpty: "aranacak başlık boş",
+  searching: (q) => `"${q}" aranıyor… `,
+  resultsCount: (n) => `${n} sonuç`,
+  noMatch: "eşleşme yok. farklı bir yazım veya orijinal başlık deneyin.",
+  whichOne: "hangisi?",
+  emptyResult: "boş sonuç",
+  fetchingProviders: (region) =>
+    `sağlayıcılar getiriliyor (${region})… `,
+  notAvailable: (region) => `${region} bölgesinde mevcut değil.`,
+  notAvailableHint:
+    "(TMDB'de bu bölge için veri yok — başka bir bölgeye VPN yardımcı olabilir.)",
+  onYourSubsPrefix: "aboneliklerinde:",
+  streamingNotOnSubs: (region) =>
+    `${region} bölgesinde yayında, ama aboneliklerinde yok.`,
+  noStreamingSub: (region) =>
+    `${region} bölgesinde streaming aboneliği yok.`,
+  owned: "var",
+  notOwned: "yok",
+  onPrefix: "şurada",
+  free: "ücretsiz",
+  ads: "reklamlı",
+  rent: "kirala",
+  buy: "satın al",
+  link: "bağlantı",
+
+  noConfigYet: "henüz config yok — önce `ww init` çalıştır.",
+  resolvingNames: "abonelik isimleri çözümleniyor… ",
+  configTitle: "watchwhere config",
+  regionLabel: "bölge",
+  languageLabel: "dil",
+  tokenLabel: "token",
+  updatedLabel: "güncellendi",
+  pathLabel: "yol",
+  subscriptionsLabel: "abonelikler",
+  noSubs: "yok — eklemek için `ww subs` çalıştır",
+
+  firstTimeSetup: "ilk kurulum",
+  configNotWritten: "config yazılmadı",
+  existingConfig: (region) =>
+    `mevcut config bulundu (${region}) — üzerine yazılacak`,
+  tokenPrompt: "TMDB Read Access Token (v4)",
+  tokenHint: "themoviedb.org/settings/api",
+  invalidToken: "geçersiz TMDB token. v4 'Read Access Token' kullanın.",
+  tokenTooShort: "token çok kısa görünüyor",
+  verifying: "token doğrulanıyor… ",
+  usingProxyNotice: "proxy kullanılıyor — token kurulumu atlanıyor",
+  regionPrompt: "bölge kodu (ISO-3166-1, örn. TR / US / DE):",
+  regionInvalid: "iki harfli bölge kodu (örn. TR)",
+  displayLanguagePrompt: "görüntüleme dili:",
+  loadingProviders: (region) =>
+    `${region} için sağlayıcılar yükleniyor… `,
+  providersFound: (n) => `${n} bulundu`,
+  noProviders: (region) =>
+    `${region} bölgesi için sağlayıcı bulunamadı. kodu kontrol edin.`,
+  yourSubsLabel: (region) => `${region} bölgesindeki aboneliklerin`,
+  toggleHintConfirm: "(seçmek için space, onaylamak için enter)",
+  toggleHintSave: "(seçmek için space, kaydetmek için enter)",
+  savedTo: "kaydedildi:",
+  updatedConfigFile: "güncellendi",
+
+  corruptConfig: (path) => `bozuk config dosyası: ${path}`,
+
+  languageUpdated: (code) => `dil ${code} olarak güncellendi`,
+  cancelled: "iptal edildi",
+  currentLanguage: (code) => `mevcut: ${code}`,
+  currentRegion: (code) => `mevcut: ${code}`,
+  regionUpdated: (code) => `bölge ${code} olarak güncellendi`,
+  regionHintReviewSubs: "sağlayıcılar bölgeye göre değişir — `ww subs` ile gözden geçir.",
+
+  usageTagline: "nerede izleyebilirim?",
+  usageSectionUsage: "kullanım",
+  usageSectionConfig: "config",
+  usageDescTitle: "bölgendeki bir film veya diziyi ara",
+  usageDescInit: "token, bölge, dil ve abonelikleri ayarla",
+  usageDescSubs: "sadece abonelikleri düzenle",
+  usageDescLang: "görüntüleme dilini değiştir",
+  usageDescRegion: "bölgeyi değiştir",
+  usageDescConfig: "mevcut config'i göster",
+  usageDescHelp: "bu mesaj",
+
+  unknownOption: (opt) => `bilinmeyen seçenek: ${opt}. \`ww --help\` çalıştır.`,
+  unknownCommand: (cmd) => `bilinmeyen komut: ${cmd}`,
+  didYouMean: (cmd) => `\`ww ${cmd}\` mi demek istedin?`,
+  noConfigHint: "henüz config yok — başlamak için `ww init` çalıştır.",
+  tokenExpired: "TMDB token reddedildi (401). yenilemek için `ww init` çalıştır.",
+  networkOffline: "TMDB'ye ulaşılamadı. internet bağlantını kontrol et.",
+  networkTimeout: "TMDB isteği zaman aşımına uğradı. tekrar dene veya bağlantını kontrol et.",
+  relativeNow: "şimdi",
+  relativeMinutes: (n) => `${n} dk önce`,
+  relativeHours: (n) => `${n} saat önce`,
+  relativeDays: (n) => `${n} gün önce`,
+
+  ttyRequired: (cmd) => `\`ww ${cmd}\` interaktif — pipe'da değil, terminalde çalıştır.`,
+  ambiguousQuery: (n) => `${n} eşleşme var — sorgu belirsiz. daralt veya interaktif çalıştır.`,
+};
+
+const CATALOGS: Record<Locale, Catalog> = { en, tr };
+
+export function t(locale: Locale): Catalog {
+  return CATALOGS[locale];
+}

package/src/index.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+import pkg from "../package.json" with { type: "json" };
+import { c } from "./colors.ts";
+import { loadConfig } from "./config.ts";
+import { resolveLocale, t } from "./i18n.ts";
+import { runInit } from "./commands/init.ts";
+import { runSearch } from "./commands/search.ts";
+import { runConfig } from "./commands/config.ts";
+import { runSubs } from "./commands/subs.ts";
+import { runLang } from "./commands/lang.ts";
+import { runRegion } from "./commands/region.ts";
+import { TmdbError } from "./tmdb.ts";
+
+function usage(m: ReturnType<typeof t>): string {
+  return [
+    `  ${c.bold("ww")} ${c.dim(`/ watchwhere — ${m.usageTagline}`)}`,
+    ``,
+    `  ${c.dim(m.usageSectionUsage)}`,
+    `    ww ${c.dim("<title>")}     ${m.usageDescTitle}`,
+    `    ww init        ${m.usageDescInit}`,
+    `    ww subs        ${m.usageDescSubs}`,
+    `    ww lang        ${m.usageDescLang}`,
+    `    ww region      ${m.usageDescRegion}`,
+    `    ww config      ${m.usageDescConfig}`,
+    `    ww --help      ${m.usageDescHelp}`,
+    ``,
+    `  ${c.dim(m.usageSectionConfig)} ~/.watchwhere/config.json`,
+  ].join("\n");
+}
+
+const COMMANDS = ["init", "subs", "lang", "region", "config"] as const;
+type Command = (typeof COMMANDS)[number];
+const INTERACTIVE_COMMANDS: ReadonlySet<Command> = new Set(["init", "subs", "lang", "region"]);
+
+function levenshtein(a: string, b: string): number {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const dp = Array.from({ length: a.length + 1 }, () =>
+    new Array<number>(b.length + 1).fill(0),
+  );
+  for (let i = 0; i <= a.length; i++) dp[i]![0] = i;
+  for (let j = 0; j <= b.length; j++) dp[0]![j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i]![j] = Math.min(
+        dp[i - 1]![j]! + 1,
+        dp[i]![j - 1]! + 1,
+        dp[i - 1]![j - 1]! + cost,
+      );
+    }
+  }
+  return dp[a.length]![b.length]!;
+}
+
+function nearestCommand(input: string): Command | null {
+  let best: { cmd: Command; dist: number } | null = null;
+  for (const cmd of COMMANDS) {
+    const d = levenshtein(input, cmd);
+    if (d <= 2 && (best === null || d < best.dist)) {
+      best = { cmd, dist: d };
+    }
+  }
+  return best?.cmd ?? null;
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const first = args[0];
+
+  let cfg = await loadConfig();
+  const m = t(resolveLocale(cfg?.language));
+
+  if (first === "--version" || first === "-v") {
+    console.log(`watchwhere ${pkg.version}`);
+    return;
+  }
+
+  if (!first || first === "--help" || first === "-h") {
+    console.log(usage(m));
+    if (!cfg) console.log(`\n  ${c.yellow("›")} ${m.noConfigHint}`);
+    return;
+  }
+
+  if (first.startsWith("-")) {
+    throw new Error(m.unknownOption(first));
+  }
+
+  if ((COMMANDS as ReadonlyArray<string>).includes(first)) {
+    const cmd = first as Command;
+    if (INTERACTIVE_COMMANDS.has(cmd) && !process.stdin.isTTY) {
+      throw new Error(m.ttyRequired(cmd));
+    }
+    switch (cmd) {
+      case "init":
+        return runInit();
+      case "subs":
+        return runSubs();
+      case "lang":
+        return runLang();
+      case "region":
+        return runRegion();
+      case "config":
+        return runConfig();
+    }
+  }
+
+  if (args.length === 1 && !first.includes(" ")) {
+    const suggestion = nearestCommand(first);
+    if (suggestion && first.length <= suggestion.length + 1 && first !== suggestion) {
+      console.log(c.dim(`  ${c.yellow("›")} ${m.didYouMean(suggestion)}`));
+      console.log();
+    }
+  }
+
+  if (!cfg) {
+    console.log(c.dim(`  ${m.firstTimeSetup}\n`));
+    await runInit();
+    cfg = await loadConfig();
+    if (!cfg) throw new Error(m.configNotWritten);
+    console.log();
+  }
+
+  await runSearch(args.join(" "), cfg);
+}
+
+main().catch(async (err: unknown) => {
+  const cfg = await loadConfig().catch(() => null);
+  const m = t(resolveLocale(cfg?.language));
+
+  if (err instanceof Error && err.name === "ExitPromptError") {
+    console.log(c.dim(`\n  ${m.cancelled}`));
+    process.exit(130);
+  }
+
+  let displayMsg = err instanceof Error ? err.message : String(err);
+  if (err instanceof TmdbError) {
+    if (err.status === 401) displayMsg = m.tokenExpired;
+    else if (err.status === 0 && err.message.includes("timed out")) {
+      displayMsg = m.networkTimeout;
+    } else if (err.status === 0) {
+      displayMsg = m.networkOffline;
+    }
+  }
+
+  console.error(`\n  ${c.red(m.error)} ${displayMsg}`);
+  process.exit(1);
+});