calcufly-finance 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 CalcuFly (https://calcufly.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# calcufly-finance
+
+Professional finance calculator functions for Node.js. Mortgage, loan, investment, retirement, tax, ROI and more.
+
+Part of the [CalcuFly](https://calcufly.com) calculator suite — 600+ free online calculators.
+
+## Installation
+
+```bash
+npm install calcufly-finance
+```
+
+## Quick Start
+
+```javascript
+const finance = require('calcufly-finance');
+
+// Mortgage calculation
+const mortgage = finance.mortgage(300000, 6.5, 30);
+console.log(mortgage.monthlyPayment); // 1896.20
+
+// Compound interest
+const growth = finance.compoundInterest(10000, 7, 10);
+console.log(growth.futureValue); // 20096.61
+
+// ROI
+const roi = finance.roi(5000, 7500);
+console.log(roi.roiPercent); // 50%
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `mortgage(principal, rate, years)` | Monthly mortgage payment |
+| `compoundInterest(principal, rate, years, n)` | Compound interest growth |
+| `simpleInterest(principal, rate, years)` | Simple interest |
+| `loanPayment(principal, rate, years)` | Loan monthly payment |
+| `amortizationSchedule(principal, rate, years)` | Full amortization table |
+| `roi(initial, final)` | Return on investment |
+| `profitMargin(revenue, cost)` | Gross profit margin |
+| `breakEven(fixed, price, cost)` | Break-even analysis |
+| `futureValue(pv, rate, years)` | Future value of money |
+| `presentValue(fv, rate, years)` | Present value of money |
+| `ruleOf72(rate)` | Years to double investment |
+| `retirementSavings(...)` | Retirement planning |
+| `fireNumber(expenses, rate)` | FIRE movement target |
+| `tipCalculator(bill, tipPct, people)` | Tip splitting |
+| `discountPrice(price, pct)` | Discount calculation |
+| `inflationAdjust(amount, rate, years)` | Inflation adjustment |
+| `depreciationStraightLine(cost, salvage, life)` | Depreciation schedule |
+
+Try these calculations online at **[CalcuFly.com](https://calcufly.com)** — free, no signup required.
+
+## License
+
+MIT — [CalcuFly](https://calcufly.com)

package/index.js

@@ -0,0 +1,528 @@
+/**
+ * calcufly-finance
+ * Professional finance calculator functions
+ * https://calcufly.com
+ *
+ * Try these calculations online at https://calcufly.com
+ */
+
+'use strict';
+
+/**
+ * Calculate monthly mortgage payment and totals.
+ * @param {number} principal - Loan amount
+ * @param {number} annualRate - Annual interest rate (e.g. 6.5 for 6.5%)
+ * @param {number} years - Loan term in years
+ * @returns {{ monthlyPayment: number, totalPayment: number, totalInterest: number }}
+ */
+function mortgage(principal, annualRate, years) {
+  const r = annualRate / 100 / 12;
+  const n = years * 12;
+  if (r === 0) {
+    const monthlyPayment = principal / n;
+    return { monthlyPayment, totalPayment: principal, totalInterest: 0 };
+  }
+  const monthlyPayment = principal * (r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1);
+  const totalPayment = monthlyPayment * n;
+  const totalInterest = totalPayment - principal;
+  return {
+    monthlyPayment: parseFloat(monthlyPayment.toFixed(2)),
+    totalPayment: parseFloat(totalPayment.toFixed(2)),
+    totalInterest: parseFloat(totalInterest.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate compound interest.
+ * @param {number} principal - Initial amount
+ * @param {number} rate - Annual interest rate (e.g. 5 for 5%)
+ * @param {number} years - Time in years
+ * @param {number} [n=12] - Compounding periods per year
+ * @returns {{ futureValue: number, totalInterest: number }}
+ */
+function compoundInterest(principal, rate, years, n = 12) {
+  const r = rate / 100;
+  const futureValue = principal * Math.pow(1 + r / n, n * years);
+  const totalInterest = futureValue - principal;
+  return {
+    futureValue: parseFloat(futureValue.toFixed(2)),
+    totalInterest: parseFloat(totalInterest.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate simple interest.
+ * @param {number} principal - Initial amount
+ * @param {number} rate - Annual interest rate (e.g. 5 for 5%)
+ * @param {number} years - Time in years
+ * @returns {{ interest: number, total: number }}
+ */
+function simpleInterest(principal, rate, years) {
+  const interest = principal * (rate / 100) * years;
+  const total = principal + interest;
+  return {
+    interest: parseFloat(interest.toFixed(2)),
+    total: parseFloat(total.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate loan payment (same formula as mortgage but named generically).
+ * @param {number} principal - Loan amount
+ * @param {number} annualRate - Annual interest rate (e.g. 6 for 6%)
+ * @param {number} years - Loan term in years
+ * @returns {{ monthlyPayment: number, totalPayment: number, totalInterest: number }}
+ */
+function loanPayment(principal, annualRate, years) {
+  return mortgage(principal, annualRate, years);
+}
+
+/**
+ * Generate a full amortization schedule.
+ * @param {number} principal - Loan amount
+ * @param {number} annualRate - Annual interest rate (e.g. 6 for 6%)
+ * @param {number} years - Loan term in years
+ * @returns {Array<{ month: number, payment: number, principal: number, interest: number, balance: number }>}
+ */
+function amortizationSchedule(principal, annualRate, years) {
+  const r = annualRate / 100 / 12;
+  const n = years * 12;
+  const schedule = [];
+  let balance = principal;
+
+  const monthlyPayment = r === 0
+    ? principal / n
+    : principal * (r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1);
+
+  for (let month = 1; month <= n; month++) {
+    const interestPayment = balance * r;
+    const principalPayment = monthlyPayment - interestPayment;
+    balance -= principalPayment;
+    schedule.push({
+      month,
+      payment: parseFloat(monthlyPayment.toFixed(2)),
+      principal: parseFloat(principalPayment.toFixed(2)),
+      interest: parseFloat(interestPayment.toFixed(2)),
+      balance: parseFloat(Math.max(0, balance).toFixed(2)),
+    });
+  }
+  return schedule;
+}
+
+/**
+ * Calculate the effective APR including fees.
+ * @param {number} principal - Loan amount
+ * @param {number} totalFees - Total fees/closing costs
+ * @param {number} rate - Nominal annual rate (e.g. 6 for 6%)
+ * @param {number} years - Loan term in years
+ * @returns {number} effectiveAPR as a percentage
+ */
+function apr(principal, totalFees, rate, years) {
+  const adjustedPrincipal = principal - totalFees;
+  const r = rate / 100 / 12;
+  const n = years * 12;
+  const monthlyPayment = principal * (r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1);
+
+  // Newton-Raphson to find APR
+  let guess = rate / 100 / 12;
+  for (let i = 0; i < 1000; i++) {
+    const f = monthlyPayment * (1 - Math.pow(1 + guess, -n)) / guess - adjustedPrincipal;
+    const fPrime = monthlyPayment * (
+      (Math.pow(1 + guess, -n) - 1) / (guess * guess) +
+      n * Math.pow(1 + guess, -n - 1) / guess
+    );
+    const next = guess - f / fPrime;
+    if (Math.abs(next - guess) < 1e-10) break;
+    guess = next;
+  }
+  return parseFloat((guess * 12 * 100).toFixed(4));
+}
+
+/**
+ * Calculate effective Annual Percentage Yield.
+ * @param {number} nominalRate - Nominal annual rate (e.g. 5 for 5%)
+ * @param {number} compoundingPeriods - Number of compounding periods per year
+ * @returns {number} effectiveAPY as a percentage
+ */
+function apy(nominalRate, compoundingPeriods) {
+  const r = nominalRate / 100;
+  const effectiveAPY = (Math.pow(1 + r / compoundingPeriods, compoundingPeriods) - 1) * 100;
+  return parseFloat(effectiveAPY.toFixed(4));
+}
+
+/**
+ * Calculate Return on Investment.
+ * @param {number} initialInvestment - Amount invested
+ * @param {number} finalValue - Final value of investment
+ * @returns {{ roi: number, roiPercent: number }}
+ */
+function roi(initialInvestment, finalValue) {
+  const roiValue = finalValue - initialInvestment;
+  const roiPercent = (roiValue / initialInvestment) * 100;
+  return {
+    roi: parseFloat(roiValue.toFixed(2)),
+    roiPercent: parseFloat(roiPercent.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate gross profit margin.
+ * @param {number} revenue - Total revenue
+ * @param {number} cost - Cost of goods sold
+ * @returns {{ grossMargin: number, grossMarginPercent: number }}
+ */
+function profitMargin(revenue, cost) {
+  const grossMargin = revenue - cost;
+  const grossMarginPercent = (grossMargin / revenue) * 100;
+  return {
+    grossMargin: parseFloat(grossMargin.toFixed(2)),
+    grossMarginPercent: parseFloat(grossMarginPercent.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate markup percentage.
+ * @param {number} cost - Cost of item
+ * @param {number} sellingPrice - Selling price
+ * @returns {{ markup: number, markupPercent: number }}
+ */
+function markup(cost, sellingPrice) {
+  const markupValue = sellingPrice - cost;
+  const markupPercent = (markupValue / cost) * 100;
+  return {
+    markup: parseFloat(markupValue.toFixed(2)),
+    markupPercent: parseFloat(markupPercent.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate break-even point.
+ * @param {number} fixedCosts - Total fixed costs
+ * @param {number} pricePerUnit - Selling price per unit
+ * @param {number} costPerUnit - Variable cost per unit
+ * @returns {{ breakEvenUnits: number, breakEvenRevenue: number }}
+ */
+function breakEven(fixedCosts, pricePerUnit, costPerUnit) {
+  const contributionMargin = pricePerUnit - costPerUnit;
+  const breakEvenUnits = fixedCosts / contributionMargin;
+  const breakEvenRevenue = breakEvenUnits * pricePerUnit;
+  return {
+    breakEvenUnits: parseFloat(breakEvenUnits.toFixed(2)),
+    breakEvenRevenue: parseFloat(breakEvenRevenue.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate future value of a present sum.
+ * @param {number} presentValue - Current amount
+ * @param {number} rate - Annual interest rate (e.g. 5 for 5%)
+ * @param {number} years - Time in years
+ * @returns {number} futureValue
+ */
+function futureValue(presentValue, rate, years) {
+  const fv = presentValue * Math.pow(1 + rate / 100, years);
+  return parseFloat(fv.toFixed(2));
+}
+
+/**
+ * Calculate present value of a future sum.
+ * @param {number} fv - Future value
+ * @param {number} rate - Annual discount rate (e.g. 5 for 5%)
+ * @param {number} years - Time in years
+ * @returns {number} presentValue
+ */
+function presentValue(fv, rate, years) {
+  const pv = fv / Math.pow(1 + rate / 100, years);
+  return parseFloat(pv.toFixed(2));
+}
+
+/**
+ * Estimate years to double an investment using the Rule of 72.
+ * @param {number} rate - Annual interest rate (e.g. 6 for 6%)
+ * @returns {number} yearsToDouble
+ */
+function ruleOf72(rate) {
+  return parseFloat((72 / rate).toFixed(2));
+}
+
+/**
+ * Sort debts using the Debt Snowball method (lowest balance first).
+ * @param {Array<{ name: string, balance: number, minPayment: number }>} debts
+ * @returns {Array} Sorted payoff order with debt info
+ */
+function debtSnowball(debts) {
+  return [...debts]
+    .sort((a, b) => a.balance - b.balance)
+    .map((d, i) => ({ ...d, payoffOrder: i + 1 }));
+}
+
+/**
+ * Sort debts using the Debt Avalanche method (highest interest rate first).
+ * @param {Array<{ name: string, balance: number, minPayment: number, rate: number }>} debts
+ * @returns {Array} Sorted payoff order with debt info
+ */
+function debtAvalanche(debts) {
+  return [...debts]
+    .sort((a, b) => b.rate - a.rate)
+    .map((d, i) => ({ ...d, payoffOrder: i + 1 }));
+}
+
+/**
+ * Estimate retirement savings at retirement age.
+ * @param {number} currentAge - Current age
+ * @param {number} retirementAge - Target retirement age
+ * @param {number} currentSavings - Current savings balance
+ * @param {number} monthlyContribution - Monthly contribution amount
+ * @param {number} annualReturn - Expected annual return rate (e.g. 7 for 7%)
+ * @returns {{ totalAtRetirement: number }}
+ */
+function retirementSavings(currentAge, retirementAge, currentSavings, monthlyContribution, annualReturn) {
+  const years = retirementAge - currentAge;
+  const months = years * 12;
+  const r = annualReturn / 100 / 12;
+
+  const futureCurrentSavings = currentSavings * Math.pow(1 + r, months);
+  const futureContributions = r === 0
+    ? monthlyContribution * months
+    : monthlyContribution * (Math.pow(1 + r, months) - 1) / r;
+
+  const totalAtRetirement = futureCurrentSavings + futureContributions;
+  return { totalAtRetirement: parseFloat(totalAtRetirement.toFixed(2)) };
+}
+
+/**
+ * Calculate FIRE (Financial Independence, Retire Early) number.
+ * @param {number} annualExpenses - Annual living expenses
+ * @param {number} [withdrawalRate=0.04] - Safe withdrawal rate (e.g. 0.04 for 4%)
+ * @returns {number} requiredSavings
+ */
+function fireNumber(annualExpenses, withdrawalRate = 0.04) {
+  const required = annualExpenses / withdrawalRate;
+  return parseFloat(required.toFixed(2));
+}
+
+/**
+ * Convert annual salary to hourly rate.
+ * @param {number} annualSalary - Annual salary amount
+ * @param {number} [hoursPerWeek=40] - Hours worked per week
+ * @param {number} [weeksPerYear=52] - Weeks worked per year
+ * @returns {number} hourlyRate
+ */
+function salaryToHourly(annualSalary, hoursPerWeek = 40, weeksPerYear = 52) {
+  const hourlyRate = annualSalary / (hoursPerWeek * weeksPerYear);
+  return parseFloat(hourlyRate.toFixed(2));
+}
+
+/**
+ * Convert hourly rate to annual salary.
+ * @param {number} hourlyRate - Hourly pay rate
+ * @param {number} [hoursPerWeek=40] - Hours worked per week
+ * @param {number} [weeksPerYear=52] - Weeks worked per year
+ * @returns {number} annualSalary
+ */
+function hourlyToSalary(hourlyRate, hoursPerWeek = 40, weeksPerYear = 52) {
+  const annualSalary = hourlyRate * hoursPerWeek * weeksPerYear;
+  return parseFloat(annualSalary.toFixed(2));
+}
+
+/**
+ * Calculate tip and split a restaurant bill.
+ * @param {number} billAmount - Total bill amount
+ * @param {number} tipPercent - Tip percentage (e.g. 18 for 18%)
+ * @param {number} [numPeople=1] - Number of people splitting the bill
+ * @returns {{ tipAmount: number, totalAmount: number, perPerson: number }}
+ */
+function tipCalculator(billAmount, tipPercent, numPeople = 1) {
+  const tipAmount = billAmount * (tipPercent / 100);
+  const totalAmount = billAmount + tipAmount;
+  const perPerson = totalAmount / numPeople;
+  return {
+    tipAmount: parseFloat(tipAmount.toFixed(2)),
+    totalAmount: parseFloat(totalAmount.toFixed(2)),
+    perPerson: parseFloat(perPerson.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate discounted price.
+ * @param {number} originalPrice - Original price
+ * @param {number} discountPercent - Discount percentage (e.g. 20 for 20%)
+ * @returns {{ discount: number, finalPrice: number }}
+ */
+function discountPrice(originalPrice, discountPercent) {
+  const discount = originalPrice * (discountPercent / 100);
+  const finalPrice = originalPrice - discount;
+  return {
+    discount: parseFloat(discount.toFixed(2)),
+    finalPrice: parseFloat(finalPrice.toFixed(2)),
+  };
+}
+
+/**
+ * Adjust an amount for inflation over time.
+ * @param {number} amount - Original amount
+ * @param {number} inflationRate - Annual inflation rate (e.g. 3 for 3%)
+ * @param {number} years - Number of years
+ * @returns {number} adjustedAmount (future purchasing cost equivalent)
+ */
+function inflationAdjust(amount, inflationRate, years) {
+  const adjusted = amount * Math.pow(1 + inflationRate / 100, years);
+  return parseFloat(adjusted.toFixed(2));
+}
+
+/**
+ * Calculate net cash flow from inflows and outflows.
+ * @param {number[]} inflows - Array of inflow amounts
+ * @param {number[]} outflows - Array of outflow amounts
+ * @returns {{ netCashFlow: number, totalInflows: number, totalOutflows: number }}
+ */
+function cashFlow(inflows, outflows) {
+  const totalInflows = inflows.reduce((sum, v) => sum + v, 0);
+  const totalOutflows = outflows.reduce((sum, v) => sum + v, 0);
+  const netCashFlow = totalInflows - totalOutflows;
+  return {
+    netCashFlow: parseFloat(netCashFlow.toFixed(2)),
+    totalInflows: parseFloat(totalInflows.toFixed(2)),
+    totalOutflows: parseFloat(totalOutflows.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate straight-line depreciation schedule.
+ * @param {number} cost - Original asset cost
+ * @param {number} salvageValue - Estimated salvage/residual value
+ * @param {number} usefulLife - Useful life in years
+ * @returns {{ annualDepreciation: number, schedule: Array<{ year: number, depreciation: number, bookValue: number }> }}
+ */
+function depreciationStraightLine(cost, salvageValue, usefulLife) {
+  const annualDepreciation = (cost - salvageValue) / usefulLife;
+  const schedule = [];
+  let bookValue = cost;
+  for (let year = 1; year <= usefulLife; year++) {
+    bookValue -= annualDepreciation;
+    schedule.push({
+      year,
+      depreciation: parseFloat(annualDepreciation.toFixed(2)),
+      bookValue: parseFloat(Math.max(salvageValue, bookValue).toFixed(2)),
+    });
+  }
+  return {
+    annualDepreciation: parseFloat(annualDepreciation.toFixed(2)),
+    schedule,
+  };
+}
+
+/**
+ * Calculate net present value of a series of cash flows.
+ * @param {number} discountRate - Annual discount rate (e.g. 10 for 10%)
+ * @param {number[]} cashFlows - Array of cash flows (index 0 = year 0, typically negative)
+ * @returns {number} npv
+ */
+function npv(discountRate, cashFlows) {
+  const r = discountRate / 100;
+  const result = cashFlows.reduce((acc, cf, t) => acc + cf / Math.pow(1 + r, t), 0);
+  return parseFloat(result.toFixed(2));
+}
+
+/**
+ * Calculate Internal Rate of Return using Newton-Raphson.
+ * @param {number[]} cashFlows - Array of cash flows (index 0 is typically negative initial investment)
+ * @returns {number} irr as a percentage
+ */
+function irr(cashFlows) {
+  let rate = 0.1;
+  for (let i = 0; i < 1000; i++) {
+    let npvVal = 0;
+    let npvDerivative = 0;
+    for (let t = 0; t < cashFlows.length; t++) {
+      npvVal += cashFlows[t] / Math.pow(1 + rate, t);
+      npvDerivative -= t * cashFlows[t] / Math.pow(1 + rate, t + 1);
+    }
+    const next = rate - npvVal / npvDerivative;
+    if (Math.abs(next - rate) < 1e-10) break;
+    rate = next;
+  }
+  return parseFloat((rate * 100).toFixed(4));
+}
+
+/**
+ * Calculate debt-to-income ratio.
+ * @param {number} monthlyDebtPayments - Total monthly debt payments
+ * @param {number} grossMonthlyIncome - Gross monthly income
+ * @returns {{ dtiRatio: number, dtiPercent: number }}
+ */
+function debtToIncome(monthlyDebtPayments, grossMonthlyIncome) {
+  const dtiRatio = monthlyDebtPayments / grossMonthlyIncome;
+  const dtiPercent = dtiRatio * 100;
+  return {
+    dtiRatio: parseFloat(dtiRatio.toFixed(4)),
+    dtiPercent: parseFloat(dtiPercent.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate savings goal progress and time to reach goal.
+ * @param {number} goalAmount - Target savings amount
+ * @param {number} currentSavings - Current savings balance
+ * @param {number} monthlyContribution - Monthly savings contribution
+ * @param {number} annualReturn - Expected annual return rate (e.g. 5 for 5%)
+ * @returns {{ monthsToGoal: number, progressPercent: number }}
+ */
+function savingsGoal(goalAmount, currentSavings, monthlyContribution, annualReturn) {
+  const r = annualReturn / 100 / 12;
+  const progressPercent = (currentSavings / goalAmount) * 100;
+  let balance = currentSavings;
+  let months = 0;
+  const maxMonths = 600;
+  while (balance < goalAmount && months < maxMonths) {
+    balance = balance * (1 + r) + monthlyContribution;
+    months++;
+  }
+  return {
+    monthsToGoal: months >= maxMonths ? null : months,
+    progressPercent: parseFloat(progressPercent.toFixed(2)),
+  };
+}
+
+/**
+ * Calculate currency exchange.
+ * @param {number} amount - Amount to convert
+ * @param {number} exchangeRate - Exchange rate (units of target currency per 1 unit of source)
+ * @returns {number} convertedAmount
+ */
+function currencyConvert(amount, exchangeRate) {
+  return parseFloat((amount * exchangeRate).toFixed(2));
+}
+
+module.exports = {
+  mortgage,
+  compoundInterest,
+  simpleInterest,
+  loanPayment,
+  amortizationSchedule,
+  apr,
+  apy,
+  roi,
+  profitMargin,
+  markup,
+  breakEven,
+  futureValue,
+  presentValue,
+  ruleOf72,
+  debtSnowball,
+  debtAvalanche,
+  retirementSavings,
+  fireNumber,
+  salaryToHourly,
+  hourlyToSalary,
+  tipCalculator,
+  discountPrice,
+  inflationAdjust,
+  cashFlow,
+  depreciationStraightLine,
+  npv,
+  irr,
+  debtToIncome,
+  savingsGoal,
+  currencyConvert,
+};

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "calcufly-finance",
+  "version": "1.0.0",
+  "description": "Professional finance calculator functions - mortgage, loan, investment, retirement, tax calculations. By CalcuFly.com",
+  "main": "index.js",
+  "keywords": ["finance", "calculator", "mortgage", "loan", "investment", "compound-interest", "amortization", "retirement", "tax", "roi", "apr", "apy", "debt", "savings", "budget"],
+  "author": "CalcuFly <contact@calcufly.com>",
+  "license": "MIT",
+  "homepage": "https://calcufly.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mansouewalks-bit2/calcufly-finance"
+  },
+  "bugs": {
+    "url": "https://github.com/mansouewalks-bit2/calcufly-finance/issues"
+  }
+}