@bash-app/bash-common 30.247.0 → 30.253.0

package/src/utils/__tests__/dateTimeUtils.test.ts

@@ -0,0 +1,233 @@
+/**
+ * dateTimeUtils — parsing, comparison, and normalization helpers.
+ * Pin UTC normalization and comparison semantics with fixed instants.
+ */
+import { DateTime } from "luxon";
+import { describe, expect, test, beforeEach, afterEach, jest } from "@jest/globals";
+import {
+  getLocalTimezoneName,
+  ensureIsDateTime,
+  normalizeDate,
+  normalizeDates,
+  dateWithinDateRange,
+  findLatestDateTime,
+  isDateTimeLaterThanNow,
+  areDateTimesEqual,
+  compareDateTime,
+  parseTimeString,
+  timestampMinutesFromNow,
+} from "../dateTimeUtils.js";
+
+describe("getLocalTimezoneName", () => {
+  test("returns a non-empty timezone string", () => {
+    const tz = getLocalTimezoneName();
+    expect(typeof tz).toBe("string");
+    expect(tz.length).toBeGreaterThan(0);
+  });
+});
+
+describe("ensureIsDateTime", () => {
+  test("returns undefined for null/undefined", () => {
+    expect(ensureIsDateTime(null)).toBeUndefined();
+    expect(ensureIsDateTime(undefined)).toBeUndefined();
+  });
+
+  test("returns Date for Date input", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(ensureIsDateTime(d)).toBe(d);
+  });
+
+  test("parses ISO string to Date", () => {
+    const result = ensureIsDateTime("2026-03-07T12:00:00Z");
+    expect(result).toBeInstanceOf(Date);
+    expect(result?.toISOString()).toBe("2026-03-07T12:00:00.000Z");
+  });
+});
+
+describe("normalizeDate", () => {
+  test("returns undefined for null/undefined", () => {
+    expect(normalizeDate(null)).toBeUndefined();
+    expect(normalizeDate(undefined)).toBeUndefined();
+  });
+
+  test("returns undefined for invalid date", () => {
+    const spy = jest.spyOn(console, "error").mockImplementation(() => {});
+    expect(normalizeDate("not-a-date")).toBeUndefined();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+  });
+
+  test("normalizes to UTC start of minute", () => {
+    const input = new Date("2026-03-07T12:34:56.789Z");
+    const result = normalizeDate(input);
+    expect(result).toEqual(
+      DateTime.fromJSDate(input).toUTC().startOf("minute").toJSDate()
+    );
+  });
+
+  test("accepts ISO string input", () => {
+    const result = normalizeDate("2026-03-07T12:34:56.789Z");
+    expect(result?.getUTCSeconds()).toBe(0);
+    expect(result?.getUTCMilliseconds()).toBe(0);
+  });
+});
+
+describe("normalizeDates", () => {
+  test("filters out invalid dates", () => {
+    const spy = jest.spyOn(console, "error").mockImplementation(() => {});
+    const results = normalizeDates([
+      "2026-03-07T12:00:00Z",
+      null,
+      "bad",
+      "2026-03-08T12:00:00Z",
+    ]);
+    expect(results).toHaveLength(2);
+    spy.mockRestore();
+  });
+});
+
+describe("compareDateTime", () => {
+  test("returns 0 when both dates are null/undefined", () => {
+    expect(compareDateTime(null, null)).toBe(0);
+    expect(compareDateTime(undefined, undefined)).toBe(0);
+  });
+
+  test("null date1 is treated as earlier", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(compareDateTime(null, d)).toBe(-1);
+  });
+
+  test("null date2 is treated as earlier than date1", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(compareDateTime(d, null)).toBe(1);
+  });
+
+  test("compares Date objects", () => {
+    const earlier = new Date("2026-03-07T10:00:00Z");
+    const later = new Date("2026-03-07T12:00:00Z");
+    expect(compareDateTime(later, earlier)).toBe(1);
+    expect(compareDateTime(earlier, later)).toBe(-1);
+    expect(compareDateTime(earlier, earlier)).toBe(0);
+  });
+
+  test("compares ISO strings", () => {
+    expect(compareDateTime("2026-03-07T12:00:00Z", "2026-03-07T10:00:00Z")).toBe(1);
+    expect(compareDateTime("2026-03-07T10:00:00Z", "2026-03-07T12:00:00Z")).toBe(-1);
+  });
+});
+
+describe("areDateTimesEqual", () => {
+  test("returns true for equal instants", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(areDateTimesEqual(d, d)).toBe(true);
+    expect(areDateTimesEqual("2026-03-07T12:00:00Z", d)).toBe(true);
+  });
+
+  test("returns false for different instants", () => {
+    expect(
+      areDateTimesEqual("2026-03-07T12:00:00Z", "2026-03-07T10:00:00Z")
+    ).toBe(false);
+  });
+});
+
+describe("findLatestDateTime", () => {
+  test("returns the later date", () => {
+    const earlier = "2026-03-07T10:00:00Z";
+    const later = "2026-03-07T12:00:00Z";
+    expect(findLatestDateTime(earlier, later)?.toISOString()).toBe(
+      new Date(later).toISOString()
+    );
+    expect(findLatestDateTime(later, earlier)?.toISOString()).toBe(
+      new Date(later).toISOString()
+    );
+  });
+});
+
+describe("isDateTimeLaterThanNow", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-07T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("returns true for future dates", () => {
+    expect(isDateTimeLaterThanNow("2026-03-07T13:00:00Z")).toBe(true);
+  });
+
+  test("returns false for past dates", () => {
+    expect(isDateTimeLaterThanNow("2026-03-07T11:00:00Z")).toBe(false);
+  });
+});
+
+describe("dateWithinDateRange", () => {
+  test("returns true when date is within inclusive start, exclusive end", () => {
+    const inRange = dateWithinDateRange("2026-03-07T15:00:00Z", {
+      startDate: new Date("2026-03-07T00:00:00Z"),
+      endDate: new Date("2026-03-08T00:00:00Z"),
+    });
+    expect(inRange).toBe(true);
+  });
+
+  test("returns false when date is on or after end day", () => {
+    const onEndDay = dateWithinDateRange("2026-03-08T12:00:00Z", {
+      startDate: new Date("2026-03-07T00:00:00Z"),
+      endDate: new Date("2026-03-08T00:00:00Z"),
+    });
+    expect(onEndDay).toBe(false);
+  });
+
+  test("defaults to today when range is undefined", () => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-07T15:00:00Z"));
+    expect(dateWithinDateRange("2026-03-07T16:00:00Z", undefined)).toBe(true);
+    expect(dateWithinDateRange("2026-03-09T12:00:00Z", undefined)).toBe(false);
+    jest.useRealTimers();
+  });
+});
+
+describe("parseTimeString", () => {
+  test("parses 10:30 AM", () => {
+    expect(parseTimeString("10:30 AM")).toEqual({ hours: 10, minutes: 30, ampm: "AM" });
+  });
+
+  test("parses 10:30 PM as 24h hours", () => {
+    expect(parseTimeString("10:30 PM")).toEqual({ hours: 22, minutes: 30, ampm: "PM" });
+  });
+
+  test("parses 12:00 PM", () => {
+    expect(parseTimeString("12:00 PM")).toEqual({ hours: 12, minutes: 0, ampm: "PM" });
+  });
+
+  test("parses 1:05 AM", () => {
+    expect(parseTimeString("1:05 AM")).toEqual({ hours: 1, minutes: 5, ampm: "AM" });
+  });
+
+  test("returns null for invalid formats", () => {
+    expect(parseTimeString("")).toBeNull();
+    expect(parseTimeString("25:00 AM")).toBeNull();
+    expect(parseTimeString("10:60 AM")).toBeNull();
+    expect(parseTimeString("10:30")).toBeNull();
+    expect(parseTimeString("noon")).toBeNull();
+  });
+});
+
+describe("timestampMinutesFromNow", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-07T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("returns unix seconds floored for N minutes ahead", () => {
+    const expected = Math.floor(
+      DateTime.fromJSDate(new Date("2026-03-07T12:00:00Z")).plus({ minutes: 30 }).toSeconds()
+    );
+    expect(timestampMinutesFromNow(30)).toBe(expected);
+  });
+});

package/src/utils/__tests__/discountEngine/discountCalculator.test.ts

@@ -0,0 +1,410 @@
+import {
+  OfferDiscountType,
+  SpecialOffer,
+  SpecialOfferType,
+} from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import {
+  calculatePromoCodeDiscount,
+  calculateSpecialOfferDiscount,
+  calculateBOGODiscount,
+  calculateGroupDiscount,
+  calculateVolumeDiscount,
+  calculateEarlyBirdDiscount,
+  calculateBundleDiscount,
+  formatDiscountDescription,
+  type BashEventPromoCodeWithPromoter,
+} from "../../discountEngine/discountCalculator.js";
+
+const NOW = new Date("2026-01-01T00:00:00Z");
+
+function basePromoCode(
+  overrides: Partial<BashEventPromoCodeWithPromoter> &
+    Pick<BashEventPromoCodeWithPromoter, "id" | "code">
+): BashEventPromoCodeWithPromoter {
+  return {
+    ticketTierId: "tier-1",
+    discountAmountInCents: null,
+    discountAmountPercentage: null,
+    maxRedemptions: null,
+    redeemBy: null,
+    promoterId: null,
+    stripeCouponId: null,
+    meta: null,
+    bashPointsRewardPerTicket: null,
+    ...overrides,
+  };
+}
+
+function baseSpecialOffer(
+  overrides: Partial<SpecialOffer> & Pick<SpecialOffer, "id" | "title" | "offerType">
+): SpecialOffer {
+  return {
+    createdAt: NOW,
+    updatedAt: NOW,
+    ticketTierId: "tier-1",
+    description: null,
+    discountType: OfferDiscountType.PERCENTAGE,
+    discountValue: 10,
+    isActive: true,
+    displayBadge: true,
+    badgeText: null,
+    buyQuantity: null,
+    getQuantity: null,
+    getDiscountPercent: null,
+    minGroupSize: null,
+    maxGroupSize: null,
+    tieredDiscounts: null,
+    startDate: null,
+    endDate: null,
+    availableUntil: null,
+    maxRedemptions: null,
+    maxPerUser: null,
+    limitedQuantity: null,
+    currentRedemptions: 0,
+    viewCount: 0,
+    clickCount: 0,
+    lastRedemptionAt: null,
+    priceIncreasesAt: null,
+    newPriceAfterIncrease: null,
+    countdownEnabled: false,
+    bundledItems: null,
+    bundleSavings: null,
+    requiresAttribution: false,
+    referralDiscountForBuyer: null,
+    referralDiscountForFriend: null,
+    commissionRate: null,
+    requiresEventAttendance: null,
+    hostSpecificLoyalty: false,
+    canStackWithPromoCodes: true,
+    canStackWithOtherOffers: false,
+    priority: 0,
+    urgencyMessage: null,
+    showSocialProof: false,
+    highlightColor: null,
+    sortOrder: 0,
+    minPriceFloor: null,
+    maxDiscountPercent: null,
+    ...overrides,
+  };
+}
+
+describe("calculatePromoCodeDiscount", () => {
+  test("applies percentage discount", () => {
+    const promo = basePromoCode({
+      id: "promo-1",
+      code: "SAVE20",
+      discountAmountPercentage: 20,
+    });
+    const result = calculatePromoCodeDiscount(promo, 5000, 2);
+    expect(result).toMatchObject({
+      sourceType: "PROMO_CODE",
+      discountType: "PERCENTAGE",
+      discountValue: 20,
+      originalPrice: 10000,
+      amountDiscounted: 2000,
+      finalPrice: 8000,
+    });
+  });
+
+  test("applies fixed amount discount capped at order total", () => {
+    const promo = basePromoCode({
+      id: "promo-2",
+      code: "FLAT10",
+      discountAmountInCents: 1500,
+    });
+    const result = calculatePromoCodeDiscount(promo, 1000, 1);
+    expect(result.amountDiscounted).toBe(1000);
+    expect(result.finalPrice).toBe(0);
+  });
+
+  test("includes attribution when promoter has userId", () => {
+    const promo = basePromoCode({
+      id: "promo-3",
+      code: "PROMO",
+      discountAmountPercentage: 10,
+      promoterId: "promoter-row-1",
+      promoter: { userId: "user-abc" },
+    });
+    const result = calculatePromoCodeDiscount(promo, 5000, 1);
+    expect(result.attribution).toEqual({
+      userId: "user-abc",
+      commissionRate: 5.0,
+      commissionAmount: 25,
+    });
+  });
+
+  test("omits attribution when promoter userId is missing", () => {
+    const promo = basePromoCode({
+      id: "promo-4",
+      code: "PROMO",
+      discountAmountPercentage: 10,
+      promoterId: "promoter-row-1",
+      promoter: { userId: null },
+    });
+    expect(calculatePromoCodeDiscount(promo, 5000, 1).attribution).toBeUndefined();
+  });
+});
+
+describe("calculateBOGODiscount", () => {
+  test("buy 2 get 1 free (100% off)", () => {
+    const offer = baseSpecialOffer({
+      id: "bogo-1",
+      title: "BOGO",
+      offerType: SpecialOfferType.BOGO,
+      buyQuantity: 2,
+      getQuantity: 1,
+      getDiscountPercent: 100,
+    });
+    // 3 tickets → 1 set → 1 free ticket at $50
+    expect(calculateBOGODiscount(offer, 3, 5000)).toBe(5000);
+    expect(calculateBOGODiscount(offer, 2, 5000)).toBe(0);
+  });
+
+  test("partial discount on free tickets", () => {
+    const offer = baseSpecialOffer({
+      id: "bogo-2",
+      title: "Half off extra",
+      offerType: SpecialOfferType.BOGO,
+      buyQuantity: 1,
+      getQuantity: 1,
+      getDiscountPercent: 50,
+    });
+    expect(calculateBOGODiscount(offer, 2, 4000)).toBe(2000);
+  });
+});
+
+describe("calculateGroupDiscount", () => {
+  test("returns 0 when below min group size", () => {
+    const offer = baseSpecialOffer({
+      id: "group-1",
+      title: "Group",
+      offerType: SpecialOfferType.GROUP_DISCOUNT,
+      minGroupSize: 5,
+      discountValue: 20,
+    });
+    expect(calculateGroupDiscount(offer, 3, 5000)).toBe(0);
+  });
+
+  test("returns 0 when above max group size", () => {
+    const offer = baseSpecialOffer({
+      id: "group-2",
+      title: "Group",
+      offerType: SpecialOfferType.GROUP_DISCOUNT,
+      maxGroupSize: 10,
+      discountValue: 20,
+    });
+    expect(calculateGroupDiscount(offer, 11, 5000)).toBe(0);
+  });
+
+  test("uses highest applicable tiered discount", () => {
+    const offer = baseSpecialOffer({
+      id: "group-3",
+      title: "Tiered",
+      offerType: SpecialOfferType.GROUP_DISCOUNT,
+      tieredDiscounts: [
+        { qty: 5, discount: 10 },
+        { qty: 10, discount: 20 },
+      ],
+    });
+    expect(calculateGroupDiscount(offer, 10, 5000)).toBe(10000);
+    expect(calculateGroupDiscount(offer, 5, 5000)).toBe(2500);
+  });
+
+  test("falls back to percentage discount", () => {
+    const offer = baseSpecialOffer({
+      id: "group-4",
+      title: "Simple group",
+      offerType: SpecialOfferType.GROUP_DISCOUNT,
+      discountType: OfferDiscountType.PERCENTAGE,
+      discountValue: 15,
+    });
+    expect(calculateGroupDiscount(offer, 4, 5000)).toBe(3000);
+  });
+
+  test("falls back to fixed amount per ticket", () => {
+    const offer = baseSpecialOffer({
+      id: "group-5",
+      title: "Fixed group",
+      offerType: SpecialOfferType.GROUP_DISCOUNT,
+      discountType: OfferDiscountType.FIXED_AMOUNT,
+      discountValue: 500,
+    });
+    expect(calculateGroupDiscount(offer, 3, 5000)).toBe(1500);
+  });
+});
+
+describe("calculateVolumeDiscount", () => {
+  test("delegates to group discount logic", () => {
+    const offer = baseSpecialOffer({
+      id: "vol-1",
+      title: "Volume",
+      offerType: SpecialOfferType.VOLUME_DISCOUNT,
+      discountType: OfferDiscountType.PERCENTAGE,
+      discountValue: 10,
+    });
+    expect(calculateVolumeDiscount(offer, 2, 5000)).toBe(
+      calculateGroupDiscount(offer, 2, 5000)
+    );
+  });
+});
+
+describe("calculateEarlyBirdDiscount", () => {
+  test("returns 0 after availableUntil", () => {
+    const offer = baseSpecialOffer({
+      id: "eb-1",
+      title: "Early bird",
+      offerType: SpecialOfferType.EARLY_BIRD,
+      availableUntil: new Date("2026-01-01T00:00:00Z"),
+      discountValue: 20,
+    });
+    expect(
+      calculateEarlyBirdDiscount(offer, 5000, new Date("2026-02-01T00:00:00Z"))
+    ).toBe(0);
+  });
+
+  test("applies percentage before cutoff", () => {
+    const offer = baseSpecialOffer({
+      id: "eb-2",
+      title: "Early bird",
+      offerType: SpecialOfferType.EARLY_BIRD,
+      availableUntil: new Date("2026-06-01T00:00:00Z"),
+      discountType: OfferDiscountType.PERCENTAGE,
+      discountValue: 20,
+    });
+    expect(
+      calculateEarlyBirdDiscount(offer, 5000, new Date("2026-03-01T00:00:00Z"))
+    ).toBe(1000);
+  });
+
+  test("applies fixed amount capped at ticket price", () => {
+    const offer = baseSpecialOffer({
+      id: "eb-3",
+      title: "Early bird flat",
+      offerType: SpecialOfferType.EARLY_BIRD,
+      discountType: OfferDiscountType.FIXED_AMOUNT,
+      discountValue: 8000,
+    });
+    expect(
+      calculateEarlyBirdDiscount(offer, 5000, new Date("2026-03-01T00:00:00Z"))
+    ).toBe(5000);
+  });
+});
+
+describe("calculateBundleDiscount", () => {
+  test("returns bundleSavings from offer", () => {
+    const offer = baseSpecialOffer({
+      id: "bundle-1",
+      title: "Bundle",
+      offerType: SpecialOfferType.BUNDLE,
+      bundleSavings: 2500,
+    });
+    expect(
+      calculateBundleDiscount(offer, [{ type: "ticket", price: 5000 }])
+    ).toBe(2500);
+  });
+
+  test("returns 0 when bundleSavings is null", () => {
+    const offer = baseSpecialOffer({
+      id: "bundle-2",
+      title: "Bundle",
+      offerType: SpecialOfferType.BUNDLE,
+      bundleSavings: null,
+    });
+    expect(calculateBundleDiscount(offer, [])).toBe(0);
+  });
+});
+
+describe("calculateSpecialOfferDiscount", () => {
+  test("EARLY_BIRD percentage via switch", () => {
+    const offer = baseSpecialOffer({
+      id: "so-1",
+      title: "Early Bird",
+      offerType: SpecialOfferType.EARLY_BIRD,
+      discountType: OfferDiscountType.PERCENTAGE,
+      discountValue: 25,
+    });
+    const result = calculateSpecialOfferDiscount(offer, 4000, 2);
+    expect(result).toMatchObject({
+      sourceType: "SPECIAL_OFFER",
+      discountType: "PERCENTAGE",
+      amountDiscounted: 2000,
+      originalPrice: 8000,
+      finalPrice: 6000,
+    });
+  });
+
+  test("BUNDLE uses pre-calculated savings", () => {
+    const offer = baseSpecialOffer({
+      id: "so-2",
+      title: "Bundle Deal",
+      offerType: SpecialOfferType.BUNDLE,
+      bundleSavings: 1000,
+    });
+    const result = calculateSpecialOfferDiscount(offer, 5000, 1);
+    expect(result.discountType).toBe("FIXED_AMOUNT");
+    expect(result.amountDiscounted).toBe(1000);
+  });
+
+  test("REFERRAL uses buyer discount", () => {
+    const offer = baseSpecialOffer({
+      id: "so-3",
+      title: "Referral",
+      offerType: SpecialOfferType.REFERRAL,
+      referralDiscountForBuyer: 500,
+      requiresAttribution: true,
+      commissionRate: 10,
+    });
+    const result = calculateSpecialOfferDiscount(offer, 5000, 1, "referrer-user");
+    expect(result.amountDiscounted).toBe(500);
+    expect(result.attribution).toEqual({
+      userId: "referrer-user",
+      commissionRate: 10,
+      commissionAmount: 50,
+    });
+  });
+
+  test("BOGO sets FREE_ITEMS discount type", () => {
+    const offer = baseSpecialOffer({
+      id: "so-4",
+      title: "BOGO",
+      offerType: SpecialOfferType.BOGO,
+      buyQuantity: 1,
+      getQuantity: 1,
+      getDiscountPercent: 100,
+    });
+    const result = calculateSpecialOfferDiscount(offer, 5000, 2);
+    expect(result.discountType).toBe("FREE_ITEMS");
+    expect(result.amountDiscounted).toBe(5000);
+  });
+});
+
+describe("formatDiscountDescription", () => {
+  test("formats percentage discount", () => {
+    const text = formatDiscountDescription({
+      sourceType: "PROMO_CODE",
+      sourceId: "1",
+      sourceName: "SAVE20",
+      discountType: "PERCENTAGE",
+      discountValue: 20,
+      amountDiscounted: 2000,
+      originalPrice: 10000,
+      finalPrice: 8000,
+    });
+    expect(text).toBe("SAVE20: -20% ($20.00)");
+  });
+
+  test("formats fixed amount discount", () => {
+    const text = formatDiscountDescription({
+      sourceType: "SPECIAL_OFFER",
+      sourceId: "2",
+      sourceName: "Flat Off",
+      discountType: "FIXED_AMOUNT",
+      discountValue: 500,
+      amountDiscounted: 500,
+      originalPrice: 5000,
+      finalPrice: 4500,
+    });
+    expect(text).toBe("Flat Off: -$5.00");
+  });
+});

package/src/utils/__tests__/generalDateTimeUtils.test.ts

@@ -0,0 +1,34 @@
+import { DayOfWeek } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import {
+  dayOfWeekIdxToDay,
+  dayOfWeekIdxToDayOfWeek,
+  dayOfWeekToIdx,
+  dayOfWeekToString,
+} from "../generalDateTimeUtils.js";
+
+describe("generalDateTimeUtils", () => {
+  test("dayOfWeekToString maps each weekday to a short label", () => {
+    expect(dayOfWeekToString[DayOfWeek.Monday]).toBe("M");
+    expect(dayOfWeekToString[DayOfWeek.Thursday]).toBe("TR");
+    expect(dayOfWeekToString[DayOfWeek.Saturday]).toBe("S");
+  });
+
+  test("dayOfWeekToIdx assigns Monday=1 through Sunday=7", () => {
+    expect(dayOfWeekToIdx[DayOfWeek.Monday]).toBe(1);
+    expect(dayOfWeekToIdx[DayOfWeek.Sunday]).toBe(7);
+  });
+
+  test("dayOfWeekIdxToDayOfWeek round-trips with dayOfWeekToIdx", () => {
+    for (const day of Object.values(DayOfWeek)) {
+      const idx = dayOfWeekToIdx[day];
+      expect(dayOfWeekIdxToDayOfWeek[idx]).toBe(day);
+    }
+  });
+
+  test("dayOfWeekIdxToDay rotates Sunday to index 1", () => {
+    expect(dayOfWeekIdxToDay[7]).toBe(1);
+    expect(dayOfWeekIdxToDay[1]).toBe(2);
+    expect(dayOfWeekIdxToDay[6]).toBe(7);
+  });
+});