@accounter/scraper-app 0.0.1

package/src/server/scrapers/amex.ts

@@ -0,0 +1,63 @@
+import { addMonths, startOfMonth } from 'date-fns';
+import type { z } from 'zod';
+import { init, type IsracardCardsTransactionsList } from '@accounter/modern-poalim-scraper';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import { validatePayload } from '../validate-payload.js';
+import type { IsracardAmexAccountSchema } from '../vault.js';
+
+export type AmexCreds = z.infer<typeof IsracardAmexAccountSchema>;
+
+export type Emitter = (msg: ServerMessage) => void;
+
+function buildMonthList(dateFrom: Date, dateTo: Date): Date[] {
+  const months: Date[] = [];
+  let current = startOfMonth(dateFrom);
+  const end = startOfMonth(dateTo);
+  while (current <= end) {
+    months.push(current);
+    current = addMonths(current, 1);
+  }
+  return months;
+}
+
+export async function scrapeAmex(
+  creds: AmexCreds,
+  dateFrom: Date,
+  dateTo: Date,
+  emit: Emitter,
+): Promise<IsracardCardsTransactionsList[]> {
+  const { amex: amexFn, close } = await init({ headless: true });
+
+  try {
+    const scraper = await amexFn(
+      { ID: creds.ownerId, password: creds.password, card6Digits: creds.last6Digits },
+      { validateSchema: true },
+    );
+
+    const months = buildMonthList(dateFrom, dateTo);
+    const results: IsracardCardsTransactionsList[] = [];
+
+    for (const month of months) {
+      emit({ type: 'scrape-progress', sourceId: creds.id, sourceType: 'amex', status: 'running' });
+      const { data, isValid } = await scraper.getMonthTransactions(month);
+
+      if (!data) continue;
+
+      if (!isValid) {
+        throw new Error(`Invalid Amex data for ${month.toISOString().slice(0, 7)}`);
+      }
+
+      if (data.Header?.Status !== '1') {
+        throw new Error(
+          `Amex login/password issue (Header.Status=${data.Header?.Status}) for ${month.toISOString().slice(0, 7)}`,
+        );
+      }
+
+      results.push(validatePayload('amex', data));
+    }
+
+    return results;
+  } finally {
+    await close();
+  }
+}

package/src/server/scrapers/cal.ts

@@ -0,0 +1,56 @@
+import { addMonths, format, startOfMonth } from 'date-fns';
+import type { z } from 'zod';
+import { init } from '@accounter/modern-poalim-scraper';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import type { CalPayload } from '../payload-schemas/cal.schema.js';
+import { validatePayload } from '../validate-payload.js';
+import type { CalAccountSchema } from '../vault.js';
+
+export type CalCreds = z.infer<typeof CalAccountSchema>;
+
+export type Emitter = (msg: ServerMessage) => void;
+
+function buildMonthList(dateFrom: Date, dateTo: Date): Date[] {
+  const months: Date[] = [];
+  let current = startOfMonth(dateFrom);
+  const end = startOfMonth(dateTo);
+  while (current <= end) {
+    months.push(current);
+    current = addMonths(current, 1);
+  }
+  return months;
+}
+
+export async function scrapeCal(
+  creds: CalCreds,
+  dateFrom: Date,
+  dateTo: Date,
+  emit: Emitter,
+): Promise<CalPayload> {
+  const { cal: calFn, close } = await init({ headless: true });
+
+  try {
+    const scraper = await calFn({
+      username: creds.username,
+      password: creds.password,
+      last4Digits: creds.last4Digits,
+    });
+
+    const months = buildMonthList(dateFrom, dateTo);
+    const results: CalPayload = [];
+
+    for (const month of months) {
+      emit({ type: 'scrape-progress', sourceId: creds.id, sourceType: 'cal', status: 'running' });
+      const transactions = await scraper.getMonthTransactions(creds.last4Digits, month);
+      results.push({
+        card: creds.last4Digits,
+        month: format(month, 'yyyy-MM'),
+        transactions,
+      });
+    }
+
+    return validatePayload('cal', results);
+  } finally {
+    await close();
+  }
+}

package/src/server/scrapers/currency-rates.ts

@@ -0,0 +1,64 @@
+import { format } from 'date-fns';
+import { XMLParser } from 'fast-xml-parser';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import type { CurrencyRatesPayload } from '../payload-schemas/currency-rates.schema.js';
+import { validatePayload } from '../validate-payload.js';
+
+const BOI_URL =
+  'https://edge.boi.gov.il/FusionEdgeServer/sdmx/v2/data/dataflow/BOI.STATISTICS/EXR/1.0/RER_USD_ILS,RER_EUR_ILS,RER_GBP_ILS,RER_CAD_ILS,RER_JPY_ILS,RER_AUD_ILS,RER_SEK_ILS';
+
+const CURRENCIES = ['USD', 'EUR', 'GBP', 'CAD', 'JPY', 'AUD', 'SEK'] as const;
+type SupportedCurrency = (typeof CURRENCIES)[number];
+
+export type Emitter = (msg: ServerMessage) => void;
+
+export async function scrapeCurrencyRates(_emit: Emitter): Promise<CurrencyRatesPayload> {
+  const res = await fetch(BOI_URL);
+  if (!res.ok) throw new Error(`BOI fetch failed: ${res.status} ${res.statusText}`);
+
+  const xml = await res.text();
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    isArray: name => name === 'Series' || name === 'Obs',
+    removeNSPrefix: true,
+  });
+  const parsed = parser.parse(xml);
+  const series: unknown[] = parsed?.StructureSpecificData?.DataSet?.Series ?? [];
+
+  if (series.length === 0) {
+    return validatePayload('currency-rates', []);
+  }
+
+  const today = format(new Date(), 'yyyy-MM-dd');
+
+  // Collect per-date, per-currency rates
+  const rateMap = new Map<string, Map<SupportedCurrency, number>>();
+
+  for (const currencyData of series) {
+    const cd = currencyData as Record<string, unknown>;
+    const currency = cd['@_BASE_CURRENCY'] as SupportedCurrency;
+    if (!CURRENCIES.includes(currency)) continue;
+
+    const obs: unknown[] = Array.isArray(cd['Obs']) ? (cd['Obs'] as unknown[]) : [];
+    for (const entry of obs) {
+      const e = entry as Record<string, string>;
+      const date = e['@_TIME_PERIOD'];
+      const value = Number(e['@_OBS_VALUE']);
+      if (!date || Number.isNaN(value) || date === today) continue;
+
+      const rate = currency === 'JPY' ? value * 0.01 : value;
+
+      if (!rateMap.has(date)) rateMap.set(date, new Map());
+      rateMap.get(date)!.set(currency, rate);
+    }
+  }
+
+  const entries: { date: string; currency: SupportedCurrency; rate: number }[] = [];
+  for (const [date, currencyRates] of rateMap) {
+    for (const [currency, rate] of currencyRates) {
+      entries.push({ date, currency, rate });
+    }
+  }
+
+  return validatePayload('currency-rates', entries);
+}

package/src/server/scrapers/discount.ts

@@ -0,0 +1,62 @@
+import { addMonths, format, startOfMonth } from 'date-fns';
+import type { z } from 'zod';
+import { init } from '@accounter/modern-poalim-scraper';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import type { DiscountPayload } from '../payload-schemas/discount.schema.js';
+import { validatePayload } from '../validate-payload.js';
+import type { DiscountAccountSchema } from '../vault.js';
+
+export type DiscountCreds = z.infer<typeof DiscountAccountSchema>;
+
+export type Emitter = (msg: ServerMessage) => void;
+
+function buildMonthList(dateFrom: Date, dateTo: Date): Date[] {
+  const months: Date[] = [];
+  let current = startOfMonth(dateFrom);
+  const end = startOfMonth(dateTo);
+  while (current <= end) {
+    months.push(current);
+    current = addMonths(current, 1);
+  }
+  return months;
+}
+
+export async function scrapeDiscount(
+  creds: DiscountCreds,
+  dateFrom: Date,
+  dateTo: Date,
+  emit: Emitter,
+): Promise<DiscountPayload> {
+  const { discount: discountFn, close } = await init({ headless: true });
+
+  try {
+    const scraper = await discountFn({
+      ID: creds.ID,
+      password: creds.password,
+      ...(creds.code ? { code: creds.code } : {}),
+    });
+
+    const months = buildMonthList(dateFrom, dateTo);
+    const results: DiscountPayload = [];
+
+    for (const month of months) {
+      emit({
+        type: 'scrape-progress',
+        sourceId: creds.id,
+        sourceType: 'discount',
+        status: 'running',
+      });
+      const { accountNumber, balance, transactions } = await scraper.getMonthTransactions(month);
+      results.push({
+        accountNumber,
+        month: format(month, 'yyyy-MM'),
+        balance,
+        transactions,
+      });
+    }
+
+    return validatePayload('discount', results);
+  } finally {
+    await close();
+  }
+}

package/src/server/scrapers/isracard.ts

@@ -0,0 +1,68 @@
+import { addMonths, startOfMonth } from 'date-fns';
+import type { z } from 'zod';
+import { init, type IsracardCardsTransactionsList } from '@accounter/modern-poalim-scraper';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import { validatePayload } from '../validate-payload.js';
+import type { IsracardAmexAccountSchema } from '../vault.js';
+
+export type IsracardCreds = z.infer<typeof IsracardAmexAccountSchema>;
+
+export type Emitter = (msg: ServerMessage) => void;
+
+function buildMonthList(dateFrom: Date, dateTo: Date): Date[] {
+  const months: Date[] = [];
+  let current = startOfMonth(dateFrom);
+  const end = startOfMonth(dateTo);
+  while (current <= end) {
+    months.push(current);
+    current = addMonths(current, 1);
+  }
+  return months;
+}
+
+export async function scrapeIsracard(
+  creds: IsracardCreds,
+  dateFrom: Date,
+  dateTo: Date,
+  emit: Emitter,
+): Promise<IsracardCardsTransactionsList[]> {
+  const { isracard: isracardFn, close } = await init({ headless: true });
+
+  try {
+    const scraper = await isracardFn(
+      { ID: creds.ownerId, password: creds.password, card6Digits: creds.last6Digits },
+      { validateSchema: true },
+    );
+
+    const months = buildMonthList(dateFrom, dateTo);
+    const results: IsracardCardsTransactionsList[] = [];
+
+    for (const month of months) {
+      emit({
+        type: 'scrape-progress',
+        sourceId: creds.id,
+        sourceType: 'isracard',
+        status: 'running',
+      });
+      const { data, isValid } = await scraper.getMonthTransactions(month);
+
+      if (!data) continue;
+
+      if (!isValid) {
+        throw new Error(`Invalid Isracard data for ${month.toISOString().slice(0, 7)}`);
+      }
+
+      if (data.Header?.Status !== '1') {
+        throw new Error(
+          `Isracard login/password issue (Header.Status=${data.Header?.Status}) for ${month.toISOString().slice(0, 7)}`,
+        );
+      }
+
+      results.push(validatePayload('isracard', data));
+    }
+
+    return results;
+  } finally {
+    await close();
+  }
+}

package/src/server/scrapers/max.ts

@@ -0,0 +1,32 @@
+import type { z } from 'zod';
+import { init } from '@accounter/modern-poalim-scraper';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import type { MaxPayload } from '../payload-schemas/max.schema.js';
+import { validatePayload } from '../validate-payload.js';
+import type { MaxAccountSchema } from '../vault.js';
+
+export type MaxCreds = z.infer<typeof MaxAccountSchema>;
+
+export type Emitter = (msg: ServerMessage) => void;
+
+export async function scrapeMax(
+  creds: MaxCreds,
+  dateFrom: Date,
+  _dateTo: Date,
+  emit: Emitter,
+): Promise<MaxPayload> {
+  const { max: maxFn, close } = await init({ headless: true });
+
+  try {
+    const scraper = await maxFn(
+      { username: creds.username, password: creds.password },
+      { startDate: dateFrom },
+    );
+
+    emit({ type: 'scrape-progress', sourceId: creds.id, sourceType: 'max', status: 'running' });
+    const accounts = await scraper.getTransactions();
+    return validatePayload('max', accounts);
+  } finally {
+    await close();
+  }
+}

package/src/server/scrapers/poalim.ts

@@ -0,0 +1,103 @@
+import type { z } from 'zod';
+import { init } from '@accounter/modern-poalim-scraper';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+import type { OtpManager } from '../otp-manager.js';
+import type { PoalimForeignPayload } from '../payload-schemas/poalim-foreign.schema.js';
+import type { PoalimIlsPayload } from '../payload-schemas/poalim-ils.schema.js';
+import type { PoalimSwiftPayload } from '../payload-schemas/poalim-swift.schema.js';
+import { validatePayload } from '../validate-payload.js';
+import type { PoalimAccountSchema } from '../vault.js';
+
+export type PoalimCreds = z.infer<typeof PoalimAccountSchema>;
+
+const OTP_TIMEOUT_MS = 5 * 60 * 1000;
+
+// Local options type that extends the scraper's options with an OTP callback.
+// The hapoalim scraper uses inquirer for OTP today; otpCallback is the hook
+// for WS-based OTP flow. The cast below is required until the scraper package
+// exposes otpCallback in its public HapoalimOptions type.
+type ScraperCallOptions = {
+  isBusiness?: boolean;
+  duration?: number;
+  otpCallback?: () => Promise<string>;
+};
+
+export async function scrapePoalim(
+  creds: PoalimCreds,
+  dateFrom: Date,
+  _dateTo: Date,
+  headless: boolean,
+  otpManager: OtpManager,
+  emit: (msg: ServerMessage) => void,
+): Promise<{
+  ils: PoalimIlsPayload[];
+  foreign: PoalimForeignPayload[];
+  swift: PoalimSwiftPayload[];
+}> {
+  const otpCallback = () => otpManager.waitForOtp(creds.id, emit, OTP_TIMEOUT_MS);
+
+  const { hapoalim: hapoalimFn, close } = await init({ headless });
+
+  type HapoalimFn = (
+    c: { userCode: string; password: string },
+    o?: ScraperCallOptions,
+  ) => ReturnType<typeof hapoalimFn>;
+
+  const scrape = hapoalimFn as unknown as HapoalimFn;
+
+  // calculate duration based ondateFrom and today. return number of months between the two dates, with a minimum of 1 month
+  const months = Math.max(
+    1,
+    (_dateTo.getFullYear() - dateFrom.getFullYear()) * 12 +
+      (_dateTo.getMonth() - dateFrom.getMonth()) +
+      1,
+  );
+
+  try {
+    const scraper = await scrape(
+      { userCode: creds.userCode, password: creds.password },
+      { isBusiness: creds.options?.isBusinessAccount ?? true, otpCallback, duration: months },
+    );
+
+    if (scraper === 'Unknown Error') {
+      throw new Error('Hapoalim login failed: Unknown Error');
+    }
+
+    const { data: accounts } = await scraper.getAccountsData();
+    if (!accounts || accounts.length === 0) {
+      return { ils: [], foreign: [], swift: [] };
+    }
+
+    const ils: PoalimIlsPayload[] = [];
+    const foreign: PoalimForeignPayload[] = [];
+    const swift: PoalimSwiftPayload[] = [];
+    const isBusiness = creds.options?.isBusinessAccount ?? true;
+
+    for (const account of accounts) {
+      const accountRef = {
+        bankNumber: account.bankNumber,
+        branchNumber: account.branchNumber,
+        accountNumber: account.accountNumber,
+      };
+
+      const { data: ilsData } = await scraper.getILSTransactions(accountRef);
+      if (ilsData) {
+        ils.push(validatePayload('poalim-ils', ilsData));
+      }
+
+      const { data: foreignData } = await scraper.getForeignTransactions(accountRef, isBusiness);
+      if (foreignData) {
+        foreign.push(validatePayload('poalim-foreign', foreignData));
+      }
+
+      const { data: swiftData } = await scraper.getForeignSwiftTransactions(accountRef);
+      if (swiftData) {
+        swift.push(validatePayload('poalim-swift', swiftData));
+      }
+    }
+
+    return { ils, foreign, swift };
+  } finally {
+    await close();
+  }
+}

package/src/server/settings-routes.ts

@@ -0,0 +1,27 @@
+import type { FastifyInstance } from 'fastify';
+import { getVault, isLocked, updateVault } from './vault-store.js';
+import { SettingsSchema, type Settings } from './vault.js';
+
+function guardLocked(reply: { status(code: number): { send(body: unknown): unknown } }) {
+  if (isLocked()) return reply.status(401).send({ error: 'vault-locked' });
+  return null;
+}
+
+export async function registerSettingsRoutes(app: FastifyInstance): Promise<void> {
+  app.get('/api/vault/settings', async (_req, reply) => {
+    const blocked = guardLocked(reply);
+    if (blocked) return blocked;
+    return getVault().settings;
+  });
+
+  app.put<{ Body: Partial<Settings> }>('/api/vault/settings', async (req, reply) => {
+    const blocked = guardLocked(reply);
+    if (blocked) return blocked;
+
+    const parsed = SettingsSchema.partial().safeParse(req.body);
+    if (!parsed.success) return reply.status(400).send({ error: parsed.error.issues });
+
+    await updateVault(v => ({ ...v, settings: { ...v.settings, ...parsed.data } }));
+    return getVault().settings;
+  });
+}

package/src/server/sources-routes.ts

@@ -0,0 +1,182 @@
+import { randomUUID } from 'node:crypto';
+import type { FastifyInstance } from 'fastify';
+import { z } from 'zod';
+import { getVault, isLocked, updateVault } from './vault-store.js';
+import {
+  CalAccountSchema,
+  DiscountAccountSchema,
+  IsracardAmexAccountSchema,
+  MaxAccountSchema,
+  PoalimAccountSchema,
+  type Vault,
+} from './vault.js';
+
+const SourceConfigSchema = z.discriminatedUnion('type', [
+  PoalimAccountSchema.extend({ type: z.literal('poalim') }),
+  DiscountAccountSchema.extend({ type: z.literal('discount') }),
+  IsracardAmexAccountSchema.extend({ type: z.literal('isracard') }),
+  IsracardAmexAccountSchema.extend({ type: z.literal('amex') }),
+  CalAccountSchema.extend({ type: z.literal('cal') }),
+  MaxAccountSchema.extend({ type: z.literal('max') }),
+]);
+
+export type SourceConfig = z.infer<typeof SourceConfigSchema>;
+type SourceType = SourceConfig['type'];
+
+function collectSources(vault: Vault): SourceConfig[] {
+  return [
+    ...vault.poalimAccounts.map(a => ({ ...a, type: 'poalim' as const })),
+    ...vault.discountAccounts.map(a => ({ ...a, type: 'discount' as const })),
+    ...vault.isracardAccounts.map(a => ({ ...a, type: 'isracard' as const })),
+    ...vault.amexAccounts.map(a => ({ ...a, type: 'amex' as const })),
+    ...vault.calAccounts.map(a => ({ ...a, type: 'cal' as const })),
+    ...vault.maxAccounts.map(a => ({ ...a, type: 'max' as const })),
+  ];
+}
+
+function appendSource(vault: Vault, source: SourceConfig): Vault {
+  const { type, ...rest } = source;
+  const v = { ...vault };
+  switch (type) {
+    case 'poalim':
+      v.poalimAccounts = [...vault.poalimAccounts, rest as (typeof vault.poalimAccounts)[number]];
+      break;
+    case 'discount':
+      v.discountAccounts = [
+        ...vault.discountAccounts,
+        rest as (typeof vault.discountAccounts)[number],
+      ];
+      break;
+    case 'isracard':
+      v.isracardAccounts = [
+        ...vault.isracardAccounts,
+        rest as (typeof vault.isracardAccounts)[number],
+      ];
+      break;
+    case 'amex':
+      v.amexAccounts = [...vault.amexAccounts, rest as (typeof vault.amexAccounts)[number]];
+      break;
+    case 'cal':
+      v.calAccounts = [...vault.calAccounts, rest as (typeof vault.calAccounts)[number]];
+      break;
+    case 'max':
+      v.maxAccounts = [...vault.maxAccounts, rest as (typeof vault.maxAccounts)[number]];
+      break;
+  }
+  return v;
+}
+
+type ArrayKey = Extract<
+  keyof Vault,
+  | 'poalimAccounts'
+  | 'discountAccounts'
+  | 'isracardAccounts'
+  | 'amexAccounts'
+  | 'calAccounts'
+  | 'maxAccounts'
+>;
+
+const typeToKey: Record<SourceType, ArrayKey> = {
+  poalim: 'poalimAccounts',
+  discount: 'discountAccounts',
+  isracard: 'isracardAccounts',
+  amex: 'amexAccounts',
+  cal: 'calAccounts',
+  max: 'maxAccounts',
+};
+
+const typeToPatchSchema: Record<SourceType, z.ZodType> = {
+  poalim: PoalimAccountSchema.omit({ id: true }).partial(),
+  discount: DiscountAccountSchema.omit({ id: true }).partial(),
+  isracard: IsracardAmexAccountSchema.omit({ id: true }).partial(),
+  amex: IsracardAmexAccountSchema.omit({ id: true }).partial(),
+  cal: CalAccountSchema.omit({ id: true }).partial(),
+  max: MaxAccountSchema.omit({ id: true }).partial(),
+};
+
+function findSourceKey(
+  vault: Vault,
+  id: string,
+): { key: ArrayKey; idx: number; type: SourceType } | null {
+  for (const [type, key] of Object.entries(typeToKey) as [SourceType, ArrayKey][]) {
+    const arr = vault[key] as Array<{ id: string }>;
+    const idx = arr.findIndex(a => a.id === id);
+    if (idx !== -1) return { key, idx, type };
+  }
+  return null;
+}
+
+function patchSource(
+  vault: Vault,
+  found: { key: ArrayKey; idx: number },
+  patch: Record<string, unknown>,
+): Vault {
+  const { key, idx } = found;
+  const arr = vault[key] as Array<{ id: string }>;
+  const newArr = [...arr];
+  newArr[idx] = { ...arr[idx], ...patch } as (typeof newArr)[number];
+  return { ...vault, [key]: newArr };
+}
+
+function removeSource(vault: Vault, id: string): Vault | null {
+  const found = findSourceKey(vault, id);
+  if (!found) return null;
+
+  const { key } = found;
+  const arr = vault[key] as Array<{ id: string }>;
+  return { ...vault, [key]: arr.filter(a => a.id !== id) };
+}
+
+function guardLocked(reply: { status(code: number): { send(body: unknown): unknown } }) {
+  if (isLocked()) {
+    return reply.status(401).send({ error: 'vault-locked' });
+  }
+  return null;
+}
+
+export async function registerSourcesRoutes(app: FastifyInstance): Promise<void> {
+  app.get('/api/vault/sources', async (_req, reply) => {
+    const blocked = guardLocked(reply);
+    if (blocked) return blocked;
+    return collectSources(getVault());
+  });
+
+  app.post<{ Body: SourceConfig }>('/api/vault/sources', async (req, reply) => {
+    const blocked = guardLocked(reply);
+    if (blocked) return blocked;
+
+    const parsed = SourceConfigSchema.safeParse({ ...req.body, id: randomUUID() });
+    if (!parsed.success) return reply.status(400).send({ error: parsed.error.issues });
+
+    await updateVault(v => appendSource(v, parsed.data));
+    return collectSources(getVault());
+  });
+
+  app.put<{ Params: { id: string }; Body: unknown }>(
+    '/api/vault/sources/:id',
+    async (req, reply) => {
+      const blocked = guardLocked(reply);
+      if (blocked) return blocked;
+
+      const found = findSourceKey(getVault(), req.params.id);
+      if (!found) return reply.status(404).send({ error: 'not-found' });
+
+      const parsed = typeToPatchSchema[found.type].safeParse(req.body);
+      if (!parsed.success) return reply.status(400).send({ error: parsed.error.issues });
+
+      await updateVault(v => patchSource(v, found, parsed.data as Record<string, unknown>));
+      return collectSources(getVault());
+    },
+  );
+
+  app.delete<{ Params: { id: string } }>('/api/vault/sources/:id', async (req, reply) => {
+    const blocked = guardLocked(reply);
+    if (blocked) return blocked;
+
+    const updated = removeSource(getVault(), req.params.id);
+    if (!updated) return reply.status(404).send({ error: 'not-found' });
+
+    await updateVault(() => updated);
+    return collectSources(getVault());
+  });
+}