@jjlmoya/utils-finance 1.46.0 → 1.47.0

package/src/tool/loanAprScenarioCalculator/logic.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import {
+  calculateScenario,
+  compareScenarios,
+  monthlyPaymentFromRate,
+} from "./logic";
+
+const baseScenario = {
+  name: "Offer A",
+  principal: 10000,
+  termMonths: 36,
+  mode: "rate" as const,
+  annualRate: 6,
+  monthlyPayment: 0,
+  upfrontFees: 0,
+  monthlyFees: 0,
+  finalFees: 0,
+};
+
+describe("loan APR scenario logic", () => {
+  it("calculates an amortising payment from a nominal annual rate", () => {
+    expect(monthlyPaymentFromRate(10000, 0, 10)).toBe(1000);
+    expect(monthlyPaymentFromRate(10000, 6, 36)).toBeCloseTo(304.22, 1);
+  });
+
+  it("returns the nominal rate as the effective APR when no fees are present", () => {
+    const result = calculateScenario(baseScenario);
+    expect(result.valid).toBe(true);
+    expect(result.effectiveApr).toBeCloseTo(6.168, 3);
+    expect(result.totalFees).toBe(0);
+  });
+
+  it("raises effective APR when an upfront fee reduces the cash received", () => {
+    const result = calculateScenario({ ...baseScenario, upfrontFees: 450 });
+    expect(result.valid).toBe(true);
+    expect(result.effectiveApr).toBeGreaterThan(6);
+    expect(result.netCashReceived).toBe(9550);
+  });
+
+  it("can infer an effective APR from a known monthly payment", () => {
+    const result = calculateScenario({
+      ...baseScenario,
+      mode: "payment",
+      annualRate: 0,
+      monthlyPayment: 304.22,
+    });
+    expect(result.valid).toBe(true);
+    expect(result.effectiveApr).toBeCloseTo(6.168, 2);
+  });
+
+  it("rejects non-positive cash received and malformed terms", () => {
+    expect(
+      calculateScenario({ ...baseScenario, upfrontFees: 10000 }).valid,
+    ).toBe(false);
+    expect(calculateScenario({ ...baseScenario, termMonths: 0 }).valid).toBe(
+      false,
+    );
+  });
+
+  it("identifies the lower effective cost", () => {
+    const first = calculateScenario(baseScenario);
+    const second = calculateScenario({ ...baseScenario, upfrontFees: 450 });
+    expect(compareScenarios(first, second).winner).toBe("a");
+  });
+});

package/src/tool/loanAprScenarioCalculator/logic.ts

@@ -0,0 +1,259 @@
+export type LoanMode = "rate" | "payment";
+
+export interface LoanScenarioInput {
+  name: string;
+  principal: number;
+  termMonths: number;
+  mode: LoanMode;
+  annualRate: number;
+  monthlyPayment: number;
+  upfrontFees: number;
+  monthlyFees: number;
+  finalFees: number;
+}
+
+export interface LoanScenarioResult {
+  valid: boolean;
+  name: string;
+  principal: number;
+  termMonths: number;
+  annualRate: number;
+  monthlyPayment: number;
+  upfrontFees: number;
+  monthlyFees: number;
+  finalFees: number;
+  totalPaid: number;
+  totalFees: number;
+  financeCost: number;
+  netCashReceived: number;
+  effectiveApr: number;
+  monthlyEffectiveRate: number;
+  error?: string;
+}
+
+export interface ComparisonResult {
+  winner: "a" | "b" | "tie" | "none";
+  difference: number;
+  message: "lower" | "tie" | "invalid";
+}
+
+function isFiniteNonNegative(value: number): boolean {
+  return Number.isFinite(value) && value >= 0;
+}
+
+function invalidResult(
+  input: LoanScenarioInput,
+  error: string,
+): LoanScenarioResult {
+  return {
+    valid: false,
+    name: input.name,
+    principal: input.principal,
+    termMonths: input.termMonths,
+    annualRate: input.annualRate,
+    monthlyPayment: input.monthlyPayment,
+    upfrontFees: input.upfrontFees,
+    monthlyFees: input.monthlyFees,
+    finalFees: input.finalFees,
+    totalPaid: 0,
+    totalFees: 0,
+    financeCost: 0,
+    netCashReceived: 0,
+    effectiveApr: 0,
+    monthlyEffectiveRate: 0,
+    error,
+  };
+}
+
+export function monthlyPaymentFromRate(
+  principal: number,
+  annualRate: number,
+  termMonths: number,
+): number {
+  const monthlyRate = annualRate / 100 / 12;
+  if (monthlyRate === 0) return principal / termMonths;
+  const growth = (1 + monthlyRate) ** termMonths;
+  return (principal * (monthlyRate * growth)) / (growth - 1);
+}
+
+function presentValue(
+  monthlyOutflow: number,
+  finalFee: number,
+  termMonths: number,
+  monthlyRate: number,
+): number {
+  let value = 0;
+  for (let month = 1; month <= termMonths; month += 1) {
+    value += monthlyOutflow / (1 + monthlyRate) ** month;
+  }
+  return value + finalFee / (1 + monthlyRate) ** termMonths;
+}
+
+function findRateUpperBound(input: {
+  netCashReceived: number;
+  monthlyOutflow: number;
+  finalFee: number;
+  termMonths: number;
+}): number | null {
+  let high = 1;
+  while (
+    presentValue(input.monthlyOutflow, input.finalFee, input.termMonths, high) >
+      input.netCashReceived &&
+    high < 128
+  )
+    high *= 2;
+  return high >= 128 &&
+    presentValue(input.monthlyOutflow, input.finalFee, input.termMonths, high) >
+      input.netCashReceived
+    ? null
+    : high;
+}
+
+function refineMonthlyRate(input: {
+  netCashReceived: number;
+  monthlyOutflow: number;
+  finalFee: number;
+  termMonths: number;
+  high: number;
+}): number {
+  let low = -0.99;
+  let high = input.high;
+  for (let iteration = 0; iteration < 80; iteration += 1) {
+    const middle = (low + high) / 2;
+    if (
+      presentValue(
+        input.monthlyOutflow,
+        input.finalFee,
+        input.termMonths,
+        middle,
+      ) > input.netCashReceived
+    )
+      low = middle;
+    else high = middle;
+  }
+  return (low + high) / 2;
+}
+
+function solveMonthlyRate(
+  netCashReceived: number,
+  monthlyOutflow: number,
+  finalFee: number,
+  termMonths: number,
+): number | null {
+  const input = { netCashReceived, monthlyOutflow, finalFee, termMonths };
+  if (
+    presentValue(monthlyOutflow, finalFee, termMonths, -0.99) < netCashReceived
+  )
+    return null;
+  const high = findRateUpperBound(input);
+  return high === null ? null : refineMonthlyRate({ ...input, high });
+}
+
+function validateBasics(input: LoanScenarioInput): string | undefined {
+  if (!Number.isFinite(input.principal) || input.principal <= 0)
+    return "principal";
+  if (
+    !Number.isInteger(input.termMonths) ||
+    input.termMonths <= 0 ||
+    input.termMonths > 600
+  )
+    return "term";
+  return undefined;
+}
+
+function validateFees(input: LoanScenarioInput): string | undefined {
+  if (
+    !isFiniteNonNegative(input.upfrontFees) ||
+    !isFiniteNonNegative(input.monthlyFees) ||
+    !isFiniteNonNegative(input.finalFees)
+  )
+    return "fees";
+  return undefined;
+}
+
+function validateMode(input: LoanScenarioInput): string | undefined {
+  if (
+    input.mode === "rate" &&
+    (!isFiniteNonNegative(input.annualRate) || input.annualRate > 100)
+  )
+    return "rate";
+  if (
+    input.mode === "payment" &&
+    (!isFiniteNonNegative(input.monthlyPayment) || input.monthlyPayment === 0)
+  )
+    return "payment";
+  return undefined;
+}
+
+function validateScenario(input: LoanScenarioInput): string | undefined {
+  return validateBasics(input) ?? validateFees(input) ?? validateMode(input);
+}
+
+function buildResult(
+  input: LoanScenarioInput,
+  payment: number,
+  netCashReceived: number,
+  monthlyEffectiveRate: number,
+): LoanScenarioResult {
+  const totalFees =
+    input.upfrontFees + input.monthlyFees * input.termMonths + input.finalFees;
+  const totalPaid =
+    payment * input.termMonths +
+    input.monthlyFees * input.termMonths +
+    input.finalFees;
+  return {
+    valid: true,
+    name: input.name,
+    principal: input.principal,
+    termMonths: input.termMonths,
+    annualRate: input.mode === "rate" ? input.annualRate : 0,
+    monthlyPayment: payment,
+    upfrontFees: input.upfrontFees,
+    monthlyFees: input.monthlyFees,
+    finalFees: input.finalFees,
+    totalPaid,
+    totalFees,
+    financeCost: totalPaid - input.principal,
+    netCashReceived,
+    effectiveApr: ((1 + monthlyEffectiveRate) ** 12 - 1) * 100,
+    monthlyEffectiveRate,
+  };
+}
+
+export function calculateScenario(
+  input: LoanScenarioInput,
+): LoanScenarioResult {
+  const validationError = validateScenario(input);
+  if (validationError) return invalidResult(input, validationError);
+  const payment =
+    input.mode === "rate"
+      ? monthlyPaymentFromRate(
+          input.principal,
+          input.annualRate,
+          input.termMonths,
+        )
+      : input.monthlyPayment;
+  const netCashReceived = input.principal - input.upfrontFees;
+  if (netCashReceived <= 0) return invalidResult(input, "principal");
+  const monthlyEffectiveRate = solveMonthlyRate(
+    netCashReceived,
+    payment + input.monthlyFees,
+    input.finalFees,
+    input.termMonths,
+  );
+  if (monthlyEffectiveRate === null) return invalidResult(input, "payment");
+  return buildResult(input, payment, netCashReceived, monthlyEffectiveRate);
+}
+
+export function compareScenarios(
+  first: LoanScenarioResult,
+  second: LoanScenarioResult,
+): ComparisonResult {
+  if (!first.valid || !second.valid)
+    return { winner: "none", difference: 0, message: "invalid" };
+  const difference = Math.abs(first.effectiveApr - second.effectiveApr);
+  if (difference < 0.005) return { winner: "tie", difference, message: "tie" };
+  return first.effectiveApr < second.effectiveApr
+    ? { winner: "a", difference, message: "lower" }
+    : { winner: "b", difference, message: "lower" };
+}

package/src/tool/loanAprScenarioCalculator/presets.ts

@@ -0,0 +1,51 @@
+import { defaultState } from "./storage";
+import { writeScenario } from "./scenario-dom";
+
+function lowFeeState() {
+  const state = defaultState();
+  return {
+    ...state,
+    scenarioA: {
+      ...state.scenarioA,
+      annualRate: 6.8,
+      monthlyPayment: 307.72,
+      upfrontFees: 0,
+      monthlyFees: 0,
+    },
+    scenarioB: {
+      ...state.scenarioB,
+      annualRate: 6.4,
+      monthlyPayment: 305.95,
+      upfrontFees: 500,
+      monthlyFees: 4,
+    },
+  };
+}
+
+function longTermState() {
+  const state = defaultState();
+  return {
+    ...state,
+    scenarioA: {
+      ...state.scenarioA,
+      termMonths: 60,
+      annualRate: 5.8,
+      monthlyPayment: 192.26,
+    },
+    scenarioB: {
+      ...state.scenarioB,
+      termMonths: 60,
+      annualRate: 5.1,
+      monthlyPayment: 189.11,
+      upfrontFees: 350,
+    },
+  };
+}
+
+export function applyPreset(root: HTMLElement, preset: string): void {
+  let state = defaultState();
+  if (preset === "low-fee") state = lowFeeState();
+  if (preset === "long-term") state = longTermState();
+  writeScenario(root, "a", state.scenarioA);
+  writeScenario(root, "b", state.scenarioB);
+}

package/src/tool/loanAprScenarioCalculator/scenario-dom.ts

@@ -0,0 +1,101 @@
+import type { LoanMode, LoanScenarioInput } from "./logic";
+
+export type ScenarioSide = "a" | "b";
+
+function numberValue(root: HTMLElement, selector: string): number {
+  return Number(root.querySelector<HTMLInputElement>(selector)?.value ?? 0);
+}
+
+function textValue(
+  root: HTMLElement,
+  selector: string,
+  fallback: string,
+): string {
+  return (
+    root.querySelector<HTMLInputElement>(selector)?.value.trim() || fallback
+  );
+}
+
+function modeValue(root: HTMLElement, side: ScenarioSide): LoanMode {
+  return (
+    (root.querySelector<HTMLButtonElement>(
+      `[data-mode-side="${side}"][aria-pressed="true"]`,
+    )?.dataset.mode as LoanMode) ?? "rate"
+  );
+}
+
+export function readScenario(
+  root: HTMLElement,
+  side: ScenarioSide,
+): LoanScenarioInput {
+  const selector = `[data-scenario="${side}"]`;
+  return {
+    name: textValue(
+      root,
+      `${selector} [data-field="name"]`,
+      side === "a" ? "Offer A" : "Offer B",
+    ),
+    principal: numberValue(root, `${selector} [data-field="principal"]`),
+    termMonths: numberValue(root, `${selector} [data-field="term"]`),
+    mode: modeValue(root, side),
+    annualRate: numberValue(root, `${selector} [data-field="rate"]`),
+    monthlyPayment: numberValue(root, `${selector} [data-field="payment"]`),
+    upfrontFees: numberValue(root, `${selector} [data-field="upfrontFees"]`),
+    monthlyFees: numberValue(root, `${selector} [data-field="monthlyFees"]`),
+    finalFees: numberValue(root, `${selector} [data-field="finalFees"]`),
+  };
+}
+
+function setInput(
+  root: HTMLElement,
+  selector: string,
+  value: string | number,
+): void {
+  const input = root.querySelector<HTMLInputElement>(selector);
+  if (input) input.value = String(value);
+}
+
+export function setMode(
+  root: HTMLElement,
+  side: ScenarioSide,
+  mode: LoanMode,
+): void {
+  root
+    .querySelectorAll<HTMLButtonElement>(`[data-mode-side="${side}"]`)
+    .forEach((button) =>
+      button.setAttribute("aria-pressed", String(button.dataset.mode === mode)),
+    );
+  const rateField = root.querySelector<HTMLElement>(
+    `[data-scenario="${side}"] [data-mode-field="rate"]`,
+  );
+  const paymentField = root.querySelector<HTMLElement>(
+    `[data-scenario="${side}"] [data-mode-field="payment"]`,
+  );
+  if (rateField) rateField.hidden = mode !== "rate";
+  if (paymentField) paymentField.hidden = mode !== "payment";
+}
+
+export function writeScenario(
+  root: HTMLElement,
+  side: ScenarioSide,
+  scenario: LoanScenarioInput,
+): void {
+  const selector = `[data-scenario="${side}"]`;
+  setInput(root, `${selector} [data-field="name"]`, scenario.name);
+  setInput(root, `${selector} [data-field="principal"]`, scenario.principal);
+  setInput(root, `${selector} [data-field="term"]`, scenario.termMonths);
+  setInput(root, `${selector} [data-field="rate"]`, scenario.annualRate);
+  setInput(root, `${selector} [data-field="payment"]`, scenario.monthlyPayment);
+  setInput(
+    root,
+    `${selector} [data-field="upfrontFees"]`,
+    scenario.upfrontFees,
+  );
+  setInput(
+    root,
+    `${selector} [data-field="monthlyFees"]`,
+    scenario.monthlyFees,
+  );
+  setInput(root, `${selector} [data-field="finalFees"]`, scenario.finalFees);
+  setMode(root, side, scenario.mode);
+}

package/src/tool/loanAprScenarioCalculator/seo.astro

@@ -0,0 +1,11 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { loanAprScenarioCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props { locale?: KnownLocale; }
+const { locale = 'en' } = Astro.props;
+const content = await loanAprScenarioCalculator.i18n[locale]?.() ?? await loanAprScenarioCalculator.i18n.en?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/loanAprScenarioCalculator/storage.ts

@@ -0,0 +1,60 @@
+import type { LoanMode, LoanScenarioInput } from "./logic";
+import { isLoanAprCurrencyCode, type LoanAprCurrencyCode } from "./currency";
+
+export interface LoanAprStoredState {
+  scenarioA: LoanScenarioInput;
+  scenarioB: LoanScenarioInput;
+  currency: LoanAprCurrencyCode;
+}
+
+const STORAGE_KEY = "loan-apr-scenario-calculator:v1";
+
+export function loadStoredState(): LoanAprStoredState | null {
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const value = JSON.parse(raw) as LoanAprStoredState;
+    if (!value || !value.scenarioA || !value.scenarioB) return null;
+    return {
+      ...value,
+      currency: isLoanAprCurrencyCode(value.currency) ? value.currency : "USD",
+    };
+  } catch {}
+  return null;
+}
+
+export function saveStoredState(state: LoanAprStoredState): void {
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {}
+}
+
+export function defaultScenario(
+  name: string,
+  mode: LoanMode = "rate",
+): LoanScenarioInput {
+  return {
+    name,
+    principal: 10000,
+    termMonths: 36,
+    mode,
+    annualRate: 6,
+    monthlyPayment: 304.22,
+    upfrontFees: 0,
+    monthlyFees: 0,
+    finalFees: 0,
+  };
+}
+
+export function defaultState(): LoanAprStoredState {
+  return {
+    scenarioA: defaultScenario("Offer A"),
+    scenarioB: {
+      ...defaultScenario("Offer B"),
+      annualRate: 7.25,
+      monthlyPayment: 309.88,
+      upfrontFees: 150,
+    },
+    currency: "USD",
+  };
+}

package/src/tool/loanAprScenarioCalculator/ui.ts

@@ -0,0 +1,55 @@
+export interface LoanAprScenarioCalculatorUI {
+  labelScenarioA: string;
+  labelScenarioB: string;
+  labelScenarioName: string;
+  labelCurrency: string;
+  labelApproximateRates: string;
+  labelPrincipal: string;
+  labelTerm: string;
+  labelMonths: string;
+  labelInputBasis: string;
+  labelAnnualRate: string;
+  labelMonthlyPayment: string;
+  labelUpfrontFees: string;
+  labelMonthlyFees: string;
+  labelFinalFees: string;
+  labelOfferNameA: string;
+  labelOfferNameB: string;
+  labelRateMode: string;
+  labelPaymentMode: string;
+  labelPreset: string;
+  labelPresetBalanced: string;
+  labelPresetLowFee: string;
+  labelPresetLongTerm: string;
+  labelReset: string;
+  labelCopy: string;
+  labelCopied: string;
+  labelEffectiveApr: string;
+  labelNominalRate: string;
+  labelMonthlyPaymentResult: string;
+  labelTotalPaid: string;
+  labelTotalFees: string;
+  labelFinanceCost: string;
+  labelNetCashReceived: string;
+  labelWinner: string;
+  labelLowerCost: string;
+  labelHigherCost: string;
+  labelTie: string;
+  labelNeedValidInputs: string;
+  labelInvalidPrincipal: string;
+  labelInvalidTerm: string;
+  labelInvalidFees: string;
+  labelInvalidPayment: string;
+  labelInvalidRate: string;
+  labelNoComparison: string;
+  labelTimeline: string;
+  labelStart: string;
+  labelMonthly: string;
+  labelEnd: string;
+  labelFormula: string;
+  labelFormulaText: string;
+  labelApproximation: string;
+  labelScenarioSummary: string;
+  currencyCode: string;
+  currencyLocale: string;
+}

package/src/tool/loanAprScenarioCalculator/validation.ts

@@ -0,0 +1,24 @@
+export const validation = {
+  reviewedAt: "2026-09-08",
+  methodology:
+    "The tool models equal monthly payments, upfront fees, recurring fees and an optional final fee. It solves the monthly rate that equates the net cash received with the discounted payment stream and compounds that rate for an annual effective result.",
+  sources: [
+    "https://clientebancario.bde.es/pcb/es/menu-horizontal/podemosayudarte/simuladores/calculo_tae_prestamo_personal.html",
+    "https://www.consumerfinance.gov/ask-cfpb/what-is-the-difference-between-a-loan-interest-rate-and-the-apr-en-733/",
+  ],
+  referenceCases: [
+    {
+      case: "No fees at 6% nominal annual rate",
+      expected: "Effective annual result is approximately 6%.",
+    },
+    {
+      case: "Positive upfront fee",
+      expected: "Effective annual result is higher than the nominal rate.",
+    },
+  ],
+  limitations: [
+    "This is a scenario estimate, not a lender disclosure or legal calculation.",
+    "It assumes equal monthly payments, no grace period and fees entered by the user.",
+    "It does not model variable rates, insurance exclusions, taxes, late charges or jurisdiction-specific APR rules.",
+  ],
+};

package/src/tools.ts

@@ -27,5 +27,6 @@ import { RENTAL_DEPOSIT_RETURN_TOOL } from './tool/rentalDepositReturn';
 import { CAPITAL_GAINS_TAX_SCENARIO_CALCULATOR_TOOL } from './tool/capitalGainsTaxScenarioCalculator';
 import { INSURANCE_DEDUCTIBLE_BREAK_EVEN_CALCULATOR_TOOL } from './tool/insuranceDeductibleBreakEvenCalculator';
 import { RENTER_INSURANCE_COVERAGE_GAP_CALCULATOR_TOOL } from './tool/renterInsuranceCoverageGapCalculator';
+import { LOAN_APR_SCENARIO_CALCULATOR_TOOL } from './tool/loanAprScenarioCalculator';
 
-export const ALL_TOOLS: ToolDefinition[] = [COMPOUND_INTEREST_TOOL, FINANCIAL_FREEDOM_TOOL, SAVINGS_RATE_TOOL, PROFITABILITY_TOOL, MORTGAGE_TOOL, INFLATION_TOOL, PERCENTAGE_CALCULATOR_TOOL, LATE_INTEREST_TOOL, IBAN_BIC_SWIFT_TOOL, RENT_INCREASE_TOOL, LOTTERY_OPTIMIZER_TOOL, COURT_FEE_CALCULATOR_TOOL, LEGAL_INTEREST_RATE_TOOL, FIRE_CALCULATOR_TOOL, DEBT_SNOWBALL_TOOL, REVOLVING_CARD_CALCULATOR_TOOL, PESETA_VALUE_TOOL, SALARY_EMPLOYER_COST_TOOL, DIVIDEND_YIELD_TOOL, MORTGAGE_EXTRA_PAYMENT_PLANNER_TOOL, INFLATION_PURCHASING_POWER_TOOL, SUBSCRIPTION_COST_ANNUALIZER_TOOL, LOAN_TO_INCOME_RATIO_TOOL, RENTAL_DEPOSIT_RETURN_TOOL, CAPITAL_GAINS_TAX_SCENARIO_CALCULATOR_TOOL, INSURANCE_DEDUCTIBLE_BREAK_EVEN_CALCULATOR_TOOL, RENTER_INSURANCE_COVERAGE_GAP_CALCULATOR_TOOL];
+export const ALL_TOOLS: ToolDefinition[] = [COMPOUND_INTEREST_TOOL, FINANCIAL_FREEDOM_TOOL, SAVINGS_RATE_TOOL, PROFITABILITY_TOOL, MORTGAGE_TOOL, INFLATION_TOOL, PERCENTAGE_CALCULATOR_TOOL, LATE_INTEREST_TOOL, IBAN_BIC_SWIFT_TOOL, RENT_INCREASE_TOOL, LOTTERY_OPTIMIZER_TOOL, COURT_FEE_CALCULATOR_TOOL, LEGAL_INTEREST_RATE_TOOL, FIRE_CALCULATOR_TOOL, DEBT_SNOWBALL_TOOL, REVOLVING_CARD_CALCULATOR_TOOL, PESETA_VALUE_TOOL, SALARY_EMPLOYER_COST_TOOL, DIVIDEND_YIELD_TOOL, MORTGAGE_EXTRA_PAYMENT_PLANNER_TOOL, INFLATION_PURCHASING_POWER_TOOL, SUBSCRIPTION_COST_ANNUALIZER_TOOL, LOAN_TO_INCOME_RATIO_TOOL, RENTAL_DEPOSIT_RETURN_TOOL, CAPITAL_GAINS_TAX_SCENARIO_CALCULATOR_TOOL, INSURANCE_DEDUCTIBLE_BREAK_EVEN_CALCULATOR_TOOL, RENTER_INSURANCE_COVERAGE_GAP_CALCULATOR_TOOL, LOAN_APR_SCENARIO_CALCULATOR_TOOL];