moneyutils-in 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# moneyutils-in
+
+A lightweight, TypeScript-first utility library for handling INR formatting, GST, discounts, commissions, fees, and common money calculations for Indian e-commerce, booking, and payment applications.
+
+## Installation
+
+```bash
+npm install moneyutils-in
+```
+
+## Quick Start
+
+```ts
+import {
+  formatINR,
+  addGST,
+  calculatePercentageDiscount,
+  calculateCommission,
+} from "moneyutils-in";
+
+formatINR(125000);
+// ₹1,25,000.00
+
+addGST(1000, 18);
+// Total: ₹1,180
+
+calculatePercentageDiscount(2000, 15);
+// Final amount: ₹1,700
+
+calculateCommission(5000, 12);
+// Commission: ₹600
+// Net amount: ₹4,400
+```
+
+## Features
+
+- INR formatting with number grouping
+- Rupee ↔ paise conversion
+- GST calculations
+- CGST, SGST and IGST splitting
+- GST-inclusive price extraction
+- Percentage and fixed discounts
+- Percentage calculations
+- Platform and convenience fees
+- Marketplace commissions
+- Cart/order total calculations
+- TypeScript support
+- ESM and CommonJS support
+- Zero runtime dependencies
+
+## Example: Order Calculation
+
+```ts
+import { calculateOrderTotal } from "moneyutils-in";
+
+const total = calculateOrderTotal({
+  items: [
+    { price: 999, quantity: 2 },
+    { price: 2499, quantity: 1 },
+  ],
+  discount: {
+    type: "percentage",
+    value: 10,
+  },
+  fees: [{ name: "Delivery", amount: 50 }],
+  tax: {
+    rate: 18,
+  },
+});
+
+console.log(total.grandTotal);
+```
+
+## Disclaimer
+
+GST and tax utilities perform calculations based on the values provided by the developer. They do not determine the legally applicable tax rate or tax treatment for a transaction.
+
+## License
+
+MIT

package/dist/commerce/commission.d.ts

@@ -0,0 +1,7 @@
+export interface CommissionResult {
+    amount: number;
+    commissionRate: number;
+    commissionAmount: number;
+    netAmount: number;
+}
+export declare function calculateCommission(amount: number, commissionRate: number): CommissionResult;

package/dist/commerce/fee.d.ts

@@ -0,0 +1,7 @@
+export interface PercentageFeeResult {
+    baseAmount: number;
+    feeRate: number;
+    feeAmount: number;
+    totalAmount: number;
+}
+export declare function calculatePercentageFee(amount: number, feeRate: number): PercentageFeeResult;

package/dist/commerce/order-total.d.ts

@@ -0,0 +1,34 @@
+export interface OrderItem {
+    price: number;
+    quantity: number;
+}
+export interface OrderFee {
+    name: string;
+    amount: number;
+}
+export type OrderDiscount = {
+    type: "percentage";
+    value: number;
+} | {
+    type: "fixed";
+    value: number;
+};
+export interface OrderTax {
+    rate: number;
+}
+export interface CalculateOrderTotalInput {
+    items: OrderItem[];
+    discount?: OrderDiscount;
+    fees?: OrderFee[];
+    tax?: OrderTax;
+}
+export interface OrderTotalResult {
+    subtotal: number;
+    discountAmount: number;
+    subtotalAfterDiscount: number;
+    feeTotal: number;
+    taxableAmount: number;
+    taxAmount: number;
+    grandTotal: number;
+}
+export declare function calculateOrderTotal(input: CalculateOrderTotalInput): OrderTotalResult;

package/dist/currency/conversion.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts rupees to paise.
+ *
+ * @example
+ * rupeesToPaise(499.99) // 49999
+ */
+export declare function rupeesToPaise(rupees: number): number;
+/**
+ * Converts paise to rupees.
+ *
+ * @example
+ * paiseToRupees(49999) // 499.99
+ */
+export declare function paiseToRupees(paise: number): number;

package/dist/currency/format-rupee.d.ts

@@ -0,0 +1,5 @@
+export interface FormatINROptions {
+    decimals?: number;
+    symbol?: boolean;
+}
+export declare function formatINR(amount: number, options?: FormatINROptions): string;

package/dist/discount/discount.d.ts

@@ -0,0 +1,13 @@
+export interface DiscountResult {
+    originalAmount: number;
+    discountAmount: number;
+    finalAmount: number;
+    percentage: number;
+}
+export interface FixedDiscountResult {
+    originalAmount: number;
+    discountAmount: number;
+    finalAmount: number;
+}
+export declare function calculatePercentageDiscount(amount: number, percentage: number): DiscountResult;
+export declare function calculateFixedDiscount(amount: number, discount: number): FixedDiscountResult;

package/dist/gst/gst.d.ts

@@ -0,0 +1,12 @@
+export type GSTTransactionType = "INTRA_STATE" | "INTER_STATE";
+export interface GSTResult {
+    taxableAmount: number;
+    gstRate: number;
+    cgst: number;
+    sgst: number;
+    igst: number;
+    totalTax: number;
+    totalAmount: number;
+}
+export declare function addGST(amount: number, gstRate: number, transactionType?: GSTTransactionType): GSTResult;
+export declare function removeGST(inclusiveAmount: number, gstRate: number, transactionType?: GSTTransactionType): GSTResult;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { formatINR, type FormatINROptions } from "./currency/format-rupee.js";
+export { rupeesToPaise, paiseToRupees } from "./currency/conversion.js";
+export { calculatePercentageDiscount, calculateFixedDiscount, type DiscountResult, type FixedDiscountResult } from "./discount/discount.js";
+export { addGST, removeGST, type GSTResult, type GSTTransactionType } from "./gst/gst.js";
+export { calculateOrderTotal, type OrderItem, type OrderFee, type OrderDiscount, type OrderTax, type CalculateOrderTotalInput, type OrderTotalResult } from "./commerce/order-total.js";
+export { calculatePercentage } from "./percentage/percentage.js";
+export { calculateCommission, type CommissionResult } from "./commerce/commission.js";
+export { calculatePercentageFee, type PercentageFeeResult } from "./commerce/fee.js";

package/dist/index.js

@@ -0,0 +1,308 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  addGST: () => addGST,
+  calculateCommission: () => calculateCommission,
+  calculateFixedDiscount: () => calculateFixedDiscount,
+  calculateOrderTotal: () => calculateOrderTotal,
+  calculatePercentage: () => calculatePercentage,
+  calculatePercentageDiscount: () => calculatePercentageDiscount,
+  calculatePercentageFee: () => calculatePercentageFee,
+  formatINR: () => formatINR,
+  paiseToRupees: () => paiseToRupees,
+  removeGST: () => removeGST,
+  rupeesToPaise: () => rupeesToPaise
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/currency/format-rupee.ts
+function formatINR(amount, options = {}) {
+  const {
+    decimals = 2,
+    symbol = true
+  } = options;
+  if (!Number.isFinite(amount)) {
+    throw new TypeError("Amount must be a finite number");
+  }
+  const formatted = new Intl.NumberFormat("en-IN", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(amount);
+  return symbol ? `\u20B9${formatted}` : formatted;
+}
+
+// src/currency/conversion.ts
+function rupeesToPaise(rupees) {
+  if (!Number.isFinite(rupees)) {
+    throw new TypeError("Amount must be a finite number");
+  }
+  return Math.round(rupees * 100);
+}
+function paiseToRupees(paise) {
+  if (!Number.isFinite(paise)) {
+    throw new TypeError("Amount must be a finite number");
+  }
+  if (!Number.isInteger(paise)) {
+    throw new TypeError("Paise must be an integer");
+  }
+  return paise / 100;
+}
+
+// src/internal/round-money.ts
+function roundMoney(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+
+// src/internal/validate-amount.ts
+function validateAmount(amount, name = "Amount") {
+  if (!Number.isFinite(amount) || amount < 0) {
+    throw new TypeError(
+      `${name} must be a non-negative finite number`
+    );
+  }
+}
+
+// src/discount/discount.ts
+function calculatePercentageDiscount(amount, percentage) {
+  validateAmount(amount);
+  if (!Number.isFinite(percentage) || percentage < 0 || percentage > 100) {
+    throw new RangeError(
+      "Percentage must be between 0 and 100"
+    );
+  }
+  const discountAmount = roundMoney(
+    amount * percentage / 100
+  );
+  const finalAmount = roundMoney(
+    amount - discountAmount
+  );
+  return {
+    originalAmount: amount,
+    discountAmount,
+    finalAmount,
+    percentage
+  };
+}
+function calculateFixedDiscount(amount, discount) {
+  validateAmount(amount);
+  validateAmount(discount, "Discount");
+  const discountAmount = Math.min(
+    discount,
+    amount
+  );
+  return {
+    originalAmount: amount,
+    discountAmount,
+    finalAmount: roundMoney(
+      amount - discountAmount
+    )
+  };
+}
+
+// src/gst/gst.ts
+function validateGST(amount, gstRate) {
+  validateAmount(amount);
+  if (!Number.isFinite(gstRate) || gstRate < 0 || gstRate > 100) {
+    throw new RangeError(
+      "GST rate must be between 0 and 100"
+    );
+  }
+}
+function addGST(amount, gstRate, transactionType = "INTRA_STATE") {
+  validateGST(amount, gstRate);
+  const totalTax = roundMoney(amount * gstRate / 100);
+  const cgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax / 2) : 0;
+  const sgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax - cgst) : 0;
+  const igst = transactionType === "INTER_STATE" ? totalTax : 0;
+  return {
+    taxableAmount: amount,
+    gstRate,
+    cgst,
+    sgst,
+    igst,
+    totalTax,
+    totalAmount: roundMoney(amount + totalTax)
+  };
+}
+function removeGST(inclusiveAmount, gstRate, transactionType = "INTRA_STATE") {
+  validateGST(inclusiveAmount, gstRate);
+  const taxableAmount = roundMoney(inclusiveAmount / (1 + gstRate / 100));
+  const totalTax = roundMoney(inclusiveAmount - taxableAmount);
+  const cgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax / 2) : 0;
+  const sgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax - cgst) : 0;
+  const igst = transactionType === "INTER_STATE" ? totalTax : 0;
+  return {
+    taxableAmount,
+    gstRate,
+    cgst,
+    sgst,
+    igst,
+    totalTax,
+    totalAmount: inclusiveAmount
+  };
+}
+
+// src/commerce/order-total.ts
+function calculateOrderTotal(input) {
+  const {
+    items,
+    discount,
+    fees = [],
+    tax
+  } = input;
+  if (!Array.isArray(items) || items.length === 0) {
+    throw new TypeError("Items must contain at least one item");
+  }
+  let subtotal = 0;
+  for (const item of items) {
+    validateAmount(item.price, "Item price");
+    if (!Number.isInteger(item.quantity) || item.quantity <= 0) {
+      throw new TypeError(
+        "Item quantity must be a positive integer"
+      );
+    }
+    subtotal += item.price * item.quantity;
+  }
+  subtotal = roundMoney(subtotal);
+  let discountAmount = 0;
+  if (discount) {
+    validateAmount(discount.value, "Discount");
+    if (discount.type === "percentage") {
+      if (discount.value > 100) {
+        throw new RangeError(
+          "Percentage discount cannot exceed 100"
+        );
+      }
+      discountAmount = roundMoney(
+        subtotal * discount.value / 100
+      );
+    } else {
+      discountAmount = Math.min(
+        discount.value,
+        subtotal
+      );
+    }
+  }
+  const subtotalAfterDiscount = roundMoney(
+    subtotal - discountAmount
+  );
+  let feeTotal = 0;
+  for (const fee of fees) {
+    validateAmount(fee.amount, `Fee "${fee.name}"`);
+    feeTotal += fee.amount;
+  }
+  feeTotal = roundMoney(feeTotal);
+  const taxableAmount = roundMoney(
+    subtotalAfterDiscount + feeTotal
+  );
+  let taxAmount = 0;
+  if (tax) {
+    validateAmount(tax.rate, "Tax rate");
+    if (tax.rate > 100) {
+      throw new RangeError(
+        "Tax rate cannot exceed 100"
+      );
+    }
+    taxAmount = roundMoney(
+      taxableAmount * tax.rate / 100
+    );
+  }
+  const grandTotal = roundMoney(
+    taxableAmount + taxAmount
+  );
+  return {
+    subtotal,
+    discountAmount,
+    subtotalAfterDiscount,
+    feeTotal,
+    taxableAmount,
+    taxAmount,
+    grandTotal
+  };
+}
+
+// src/percentage/percentage.ts
+function calculatePercentage(amount, percentage) {
+  validateAmount(amount);
+  validateAmount(percentage, "Percentage");
+  return roundMoney(amount * percentage / 100);
+}
+
+// src/commerce/commission.ts
+function calculateCommission(amount, commissionRate) {
+  validateAmount(amount);
+  validateAmount(commissionRate, "Commission rate");
+  if (commissionRate > 100) {
+    throw new RangeError(
+      "Commission rate cannot exceed 100"
+    );
+  }
+  const commissionAmount = calculatePercentage(
+    amount,
+    commissionRate
+  );
+  return {
+    amount,
+    commissionRate,
+    commissionAmount,
+    netAmount: roundMoney(
+      amount - commissionAmount
+    )
+  };
+}
+
+// src/commerce/fee.ts
+function calculatePercentageFee(amount, feeRate) {
+  validateAmount(amount);
+  validateAmount(feeRate, "Fee rate");
+  if (feeRate > 100) {
+    throw new RangeError(
+      "Fee rate cannot exceed 100"
+    );
+  }
+  const feeAmount = calculatePercentage(
+    amount,
+    feeRate
+  );
+  return {
+    baseAmount: amount,
+    feeRate,
+    feeAmount,
+    totalAmount: roundMoney(
+      amount + feeAmount
+    )
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addGST,
+  calculateCommission,
+  calculateFixedDiscount,
+  calculateOrderTotal,
+  calculatePercentage,
+  calculatePercentageDiscount,
+  calculatePercentageFee,
+  formatINR,
+  paiseToRupees,
+  removeGST,
+  rupeesToPaise
+});

package/dist/index.mjs

@@ -0,0 +1,271 @@
+// src/currency/format-rupee.ts
+function formatINR(amount, options = {}) {
+  const {
+    decimals = 2,
+    symbol = true
+  } = options;
+  if (!Number.isFinite(amount)) {
+    throw new TypeError("Amount must be a finite number");
+  }
+  const formatted = new Intl.NumberFormat("en-IN", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(amount);
+  return symbol ? `\u20B9${formatted}` : formatted;
+}
+
+// src/currency/conversion.ts
+function rupeesToPaise(rupees) {
+  if (!Number.isFinite(rupees)) {
+    throw new TypeError("Amount must be a finite number");
+  }
+  return Math.round(rupees * 100);
+}
+function paiseToRupees(paise) {
+  if (!Number.isFinite(paise)) {
+    throw new TypeError("Amount must be a finite number");
+  }
+  if (!Number.isInteger(paise)) {
+    throw new TypeError("Paise must be an integer");
+  }
+  return paise / 100;
+}
+
+// src/internal/round-money.ts
+function roundMoney(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+
+// src/internal/validate-amount.ts
+function validateAmount(amount, name = "Amount") {
+  if (!Number.isFinite(amount) || amount < 0) {
+    throw new TypeError(
+      `${name} must be a non-negative finite number`
+    );
+  }
+}
+
+// src/discount/discount.ts
+function calculatePercentageDiscount(amount, percentage) {
+  validateAmount(amount);
+  if (!Number.isFinite(percentage) || percentage < 0 || percentage > 100) {
+    throw new RangeError(
+      "Percentage must be between 0 and 100"
+    );
+  }
+  const discountAmount = roundMoney(
+    amount * percentage / 100
+  );
+  const finalAmount = roundMoney(
+    amount - discountAmount
+  );
+  return {
+    originalAmount: amount,
+    discountAmount,
+    finalAmount,
+    percentage
+  };
+}
+function calculateFixedDiscount(amount, discount) {
+  validateAmount(amount);
+  validateAmount(discount, "Discount");
+  const discountAmount = Math.min(
+    discount,
+    amount
+  );
+  return {
+    originalAmount: amount,
+    discountAmount,
+    finalAmount: roundMoney(
+      amount - discountAmount
+    )
+  };
+}
+
+// src/gst/gst.ts
+function validateGST(amount, gstRate) {
+  validateAmount(amount);
+  if (!Number.isFinite(gstRate) || gstRate < 0 || gstRate > 100) {
+    throw new RangeError(
+      "GST rate must be between 0 and 100"
+    );
+  }
+}
+function addGST(amount, gstRate, transactionType = "INTRA_STATE") {
+  validateGST(amount, gstRate);
+  const totalTax = roundMoney(amount * gstRate / 100);
+  const cgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax / 2) : 0;
+  const sgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax - cgst) : 0;
+  const igst = transactionType === "INTER_STATE" ? totalTax : 0;
+  return {
+    taxableAmount: amount,
+    gstRate,
+    cgst,
+    sgst,
+    igst,
+    totalTax,
+    totalAmount: roundMoney(amount + totalTax)
+  };
+}
+function removeGST(inclusiveAmount, gstRate, transactionType = "INTRA_STATE") {
+  validateGST(inclusiveAmount, gstRate);
+  const taxableAmount = roundMoney(inclusiveAmount / (1 + gstRate / 100));
+  const totalTax = roundMoney(inclusiveAmount - taxableAmount);
+  const cgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax / 2) : 0;
+  const sgst = transactionType === "INTRA_STATE" ? roundMoney(totalTax - cgst) : 0;
+  const igst = transactionType === "INTER_STATE" ? totalTax : 0;
+  return {
+    taxableAmount,
+    gstRate,
+    cgst,
+    sgst,
+    igst,
+    totalTax,
+    totalAmount: inclusiveAmount
+  };
+}
+
+// src/commerce/order-total.ts
+function calculateOrderTotal(input) {
+  const {
+    items,
+    discount,
+    fees = [],
+    tax
+  } = input;
+  if (!Array.isArray(items) || items.length === 0) {
+    throw new TypeError("Items must contain at least one item");
+  }
+  let subtotal = 0;
+  for (const item of items) {
+    validateAmount(item.price, "Item price");
+    if (!Number.isInteger(item.quantity) || item.quantity <= 0) {
+      throw new TypeError(
+        "Item quantity must be a positive integer"
+      );
+    }
+    subtotal += item.price * item.quantity;
+  }
+  subtotal = roundMoney(subtotal);
+  let discountAmount = 0;
+  if (discount) {
+    validateAmount(discount.value, "Discount");
+    if (discount.type === "percentage") {
+      if (discount.value > 100) {
+        throw new RangeError(
+          "Percentage discount cannot exceed 100"
+        );
+      }
+      discountAmount = roundMoney(
+        subtotal * discount.value / 100
+      );
+    } else {
+      discountAmount = Math.min(
+        discount.value,
+        subtotal
+      );
+    }
+  }
+  const subtotalAfterDiscount = roundMoney(
+    subtotal - discountAmount
+  );
+  let feeTotal = 0;
+  for (const fee of fees) {
+    validateAmount(fee.amount, `Fee "${fee.name}"`);
+    feeTotal += fee.amount;
+  }
+  feeTotal = roundMoney(feeTotal);
+  const taxableAmount = roundMoney(
+    subtotalAfterDiscount + feeTotal
+  );
+  let taxAmount = 0;
+  if (tax) {
+    validateAmount(tax.rate, "Tax rate");
+    if (tax.rate > 100) {
+      throw new RangeError(
+        "Tax rate cannot exceed 100"
+      );
+    }
+    taxAmount = roundMoney(
+      taxableAmount * tax.rate / 100
+    );
+  }
+  const grandTotal = roundMoney(
+    taxableAmount + taxAmount
+  );
+  return {
+    subtotal,
+    discountAmount,
+    subtotalAfterDiscount,
+    feeTotal,
+    taxableAmount,
+    taxAmount,
+    grandTotal
+  };
+}
+
+// src/percentage/percentage.ts
+function calculatePercentage(amount, percentage) {
+  validateAmount(amount);
+  validateAmount(percentage, "Percentage");
+  return roundMoney(amount * percentage / 100);
+}
+
+// src/commerce/commission.ts
+function calculateCommission(amount, commissionRate) {
+  validateAmount(amount);
+  validateAmount(commissionRate, "Commission rate");
+  if (commissionRate > 100) {
+    throw new RangeError(
+      "Commission rate cannot exceed 100"
+    );
+  }
+  const commissionAmount = calculatePercentage(
+    amount,
+    commissionRate
+  );
+  return {
+    amount,
+    commissionRate,
+    commissionAmount,
+    netAmount: roundMoney(
+      amount - commissionAmount
+    )
+  };
+}
+
+// src/commerce/fee.ts
+function calculatePercentageFee(amount, feeRate) {
+  validateAmount(amount);
+  validateAmount(feeRate, "Fee rate");
+  if (feeRate > 100) {
+    throw new RangeError(
+      "Fee rate cannot exceed 100"
+    );
+  }
+  const feeAmount = calculatePercentage(
+    amount,
+    feeRate
+  );
+  return {
+    baseAmount: amount,
+    feeRate,
+    feeAmount,
+    totalAmount: roundMoney(
+      amount + feeAmount
+    )
+  };
+}
+export {
+  addGST,
+  calculateCommission,
+  calculateFixedDiscount,
+  calculateOrderTotal,
+  calculatePercentage,
+  calculatePercentageDiscount,
+  calculatePercentageFee,
+  formatINR,
+  paiseToRupees,
+  removeGST,
+  rupeesToPaise
+};

package/dist/internal/round-money.d.ts

@@ -0,0 +1 @@
+export declare function roundMoney(value: number): number;

package/dist/internal/validate-amount.d.ts

@@ -0,0 +1 @@
+export declare function validateAmount(amount: number, name?: string): void;

package/dist/percentage/percentage.d.ts

@@ -0,0 +1 @@
+export declare function calculatePercentage(amount: number, percentage: number): number;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "moneyutils-in",
+  "version": "0.1.0",
+  "description": "TypeScript-first money utilities for INR formatting, GST, discounts, taxes, payments, and calculations for Indian e-commerce and booking applications.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --clean && tsc --emitDeclarationOnly",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test:run && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dheemanthshenoy/moneyutils-in.git"
+  },
+  "author": "Dheemanth Shenoy",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Dheemanthshenoy/moneyutils-in/issues"
+  },
+  "homepage": "https://github.com/Dheemanthshenoy/moneyutils-in#readme",
+  "keywords": [
+    "money",
+    "inr",
+    "india",
+    "currency",
+    "gst",
+    "discount",
+    "tax",
+    "ecommerce",
+    "booking",
+    "payments",
+    "typescript"
+  ],
+  "devDependencies": {
+    "@types/node": "^26.6.1",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
+  }
+}