feat: almost done with release

app/Actions/OptionAction/CreateCurrency.php

 
 class CreateCurrency
 {
-    public function create(string $code, string $name, string $rate): Currency
+    public static function create(string $code, string $name, string $rate): Currency
     {
         $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
 
         $hasDefaultCurrency = $defaultCurrency !== null;
-        $currency_code = currency($code);
+        $currency = currency($code);
 
         return Currency::create([
             'name' => $name,
             'code' => $code,
             'rate' => $rate,
-            'precision' => $currency_code->getPrecision(),
-            'symbol' => $currency_code->getSymbol(),
-            'symbol_first' => $currency_code->isSymbolFirst(),
-            'decimal_mark' => $currency_code->getDecimalMark(),
-            'thousands_separator' => $currency_code->getThousandsSeparator(),
+            'precision' => $currency->getPrecision(),
+            'symbol' => $currency->getSymbol(),
+            'symbol_first' => $currency->isSymbolFirst(),
+            'decimal_mark' => $currency->getDecimalMark(),
+            'thousands_separator' => $currency->getThousandsSeparator(),
             'enabled' => ! $hasDefaultCurrency,
         ]);
     }

app/Casts/JournalEntryCast.php

+<?php
+
+namespace App\Casts;
+
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
+use Illuminate\Database\Eloquent\Model;
+use UnexpectedValueException;
+
+class JournalEntryCast implements CastsAttributes
+{
+    public function get(Model $model, string $key, mixed $value, array $attributes): string
+    {
+        $currency_code = CurrencyAccessor::getDefaultCurrency();
+
+        if ($value !== null) {
+            return CurrencyConverter::prepareForMutator($value, $currency_code);
+        }
+
+        return '';
+    }
+
+    /**
+     * @throws UnexpectedValueException
+     */
+    public function set(Model $model, string $key, mixed $value, array $attributes): int
+    {
+        $currency_code = CurrencyAccessor::getDefaultCurrency();
+
+        if (is_numeric($value)) {
+            $value = (string) $value;
+        } elseif (! is_string($value)) {
+            throw new UnexpectedValueException('Expected string or numeric value for money cast');
+        }
+
+        return CurrencyConverter::prepareForAccessor($value, $currency_code);
+    }
+}

app/Casts/MoneyCast.php

 {
     public function get(Model $model, string $key, mixed $value, array $attributes): string
     {
-        $currency_code = $model->getAttribute('currency_code') ?? CurrencyAccessor::getDefaultCurrency();
+        $currency_code = $attributes['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
 
         if ($value !== null) {
             return CurrencyConverter::prepareForMutator($value, $currency_code);
      */
     public function set(Model $model, string $key, mixed $value, array $attributes): int
     {
-        $currency_code = $model->getAttribute('currency_code') ?? CurrencyAccessor::getDefaultCurrency();
+        $currency_code = $attributes['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
 
         if (is_numeric($value)) {
             $value = (string) $value;

app/Casts/TransactionAmountCast.php

 
 namespace App\Casts;
 
+use App\Models\Banking\BankAccount;
 use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
     public function get(Model $model, string $key, mixed $value, array $attributes): string
     {
         // Attempt to retrieve the currency code from the related bankAccount->account model
-        $currency_code = $model->bankAccount?->account?->currency_code ?? CurrencyAccessor::getDefaultCurrency();
+        $currency_code = $this->getCurrencyCodeFromBankAccountId($attributes['bank_account_id'] ?? null);
 
         if ($value !== null) {
             return CurrencyConverter::prepareForMutator($value, $currency_code);
      */
     public function set(Model $model, string $key, mixed $value, array $attributes): int
     {
-        $currency_code = $model->bankAccount?->account?->currency_code ?? CurrencyAccessor::getDefaultCurrency();
+        $currency_code = $this->getCurrencyCodeFromBankAccountId($attributes['bank_account_id'] ?? null);
 
         if (is_numeric($value)) {
             $value = (string) $value;
 
         return CurrencyConverter::prepareForAccessor($value, $currency_code);
     }
+
+    /**
+     * Using this is necessary because the relationship is not always loaded into memory when the cast is called
+     * Instead of using: $model->bankAccount->account->currency_code directly, find the bank account and get the currency code
+     */
+    private function getCurrencyCodeFromBankAccountId(?int $bankAccountId): string
+    {
+        if ($bankAccountId === null) {
+            return CurrencyAccessor::getDefaultCurrency();
+        }
+
+        $bankAccount = BankAccount::find($bankAccountId);
+
+        return $bankAccount?->account?->currency_code ?? CurrencyAccessor::getDefaultCurrency();
+    }
 }

app/Collections/Accounting/JournalEntryCollection.php

+<?php
+
+namespace App\Collections\Accounting;
+
+use App\Models\Accounting\JournalEntry;
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use App\ValueObjects\Money;
+use Illuminate\Database\Eloquent\Collection;
+
+class JournalEntryCollection extends Collection
+{
+    public function sumDebits(): Money
+    {
+        $total = $this->reduce(static function ($carry, JournalEntry $item) {
+            if ($item->type->isDebit()) {
+                $amountAsInteger = CurrencyConverter::prepareForAccessor($item->amount, CurrencyAccessor::getDefaultCurrency());
+
+                return bcadd($carry, $amountAsInteger, 0);
+            }
+
+            return $carry;
+        }, 0);
+
+        return new Money($total, CurrencyAccessor::getDefaultCurrency());
+    }
+
+    public function sumCredits(): Money
+    {
+        $total = $this->reduce(static function ($carry, JournalEntry $item) {
+            if ($item->type->isCredit()) {
+                $amountAsInteger = CurrencyConverter::prepareForAccessor($item->amount, CurrencyAccessor::getDefaultCurrency());
+
+                return bcadd($carry, $amountAsInteger, 0);
+            }
+
+            return $carry;
+        }, 0);
+
+        return new Money($total, CurrencyAccessor::getDefaultCurrency());
+    }
+
+    public function areBalanced(): bool
+    {
+        return $this->sumDebits()->getAmount() === $this->sumCredits()->getAmount();
+    }
+}

app/Concerns/HasJournalEntryActions.php

 namespace App\Concerns;
 
 use App\Enums\Accounting\JournalEntryType;
+use App\Utilities\Currency\CurrencyAccessor;
 
 trait HasJournalEntryActions
 {
-    public string $debitAmount = '0.00';
+    public int $debitAmount = 0;
 
-    public string $creditAmount = '0.00';
+    public int $creditAmount = 0;
 
-    public function setDebitAmount(string $amount): void
+    private function formatMoney(int $amount): string
     {
-        $this->debitAmount = $amount;
+        return money($amount, CurrencyAccessor::getDefaultCurrency())->format();
     }
 
-    public function getDebitAmount(): string
+    /**
+     * Expects formatted simple amount: e.g. 1,000.00 or 1.000,00
+     *
+     * Sets debit amount in cents as integer: e.g. 100000
+     */
+    public function setDebitAmount(int $amount): void
     {
-        return $this->debitAmount;
+        $this->debitAmount = $amount;
     }
 
-    public function getFormattedDebitAmount(): string
+    /**
+     * Expects formatted simple amount: e.g. 1,000.00 or 1.000,00
+     *
+     * Sets credit amount in cents as integer: e.g. 100000
+     */
+    public function setCreditAmount(int $amount): void
     {
-        return money($this->getDebitAmount(), 'USD', true)->format();
+        $this->creditAmount = $amount;
     }
 
-    public function setCreditAmount(string $amount): void
+    /**
+     * Returns debit amount in cents as integer: e.g. 100000
+     */
+    public function getDebitAmount(): int
     {
-        $this->creditAmount = $amount;
+        return $this->debitAmount;
     }
 
-    public function getCreditAmount(): string
+    /**
+     * Returns credit amount in cents as integer: e.g. 100000
+     */
+    public function getCreditAmount(): int
     {
         return $this->creditAmount;
     }
 
+    /**
+     * Expects debit amount in cents as string integer: e.g. 100000
+     *
+     * Returns formatted amount: e.g. $1,000.00 or €1.000,00
+     */
+    public function getFormattedDebitAmount(): string
+    {
+        return $this->formatMoney($this->getDebitAmount());
+    }
+
+    /**
+     * Expects credit amount in cents as integer: e.g. 100000
+     *
+     * Returns formatted amount: e.g. $1,000.00 or €1.000,00
+     */
     public function getFormattedCreditAmount(): string
     {
-        return money($this->getCreditAmount(), 'USD', true)->format();
+        return $this->formatMoney($this->getCreditAmount());
     }
 
-    public function getBalanceDifference(): string
+    /**
+     * Returns balance difference in cents as integer: e.g. 100000
+     */
+    public function getBalanceDifference(): int
     {
-        return bcsub($this->getDebitAmount(), $this->getCreditAmount(), 2);
+        return $this->getDebitAmount() - $this->getCreditAmount();
     }
 
+    /**
+     * Returns formatted balance difference: e.g. $1,000.00 or €1.000,00
+     */
     public function getFormattedBalanceDifference(): string
     {
-        $difference = $this->getBalanceDifference();
-        $absoluteDifference = abs((float) $difference);
+        $absoluteDifference = abs($this->getBalanceDifference());
 
-        return money($absoluteDifference, 'USD', true)->format();
+        return $this->formatMoney($absoluteDifference);
     }
 
+    /**
+     * Returns boolean indicating whether the journal entry is balanced
+     * using the debit and credit integer amounts
+     */
     public function isJournalEntryBalanced(): bool
     {
-        return bccomp($this->getDebitAmount(), $this->getCreditAmount(), 2) === 0;
+        return $this->getDebitAmount() === $this->getCreditAmount();
     }
 
+    /**
+     * Resets debit and credit amounts to '0.00'
+     */
     public function resetJournalEntryAmounts(): void
     {
         $this->reset(['debitAmount', 'creditAmount']);
 
     public function adjustJournalEntryAmountsForTypeChange(JournalEntryType $newType, JournalEntryType $oldType, ?string $amount): void
     {
-        if ($newType !== $oldType) {
-            $normalizedAmount = $amount === null ? '0.00' : rtrim($amount, '.');
-            $normalizedAmount = $this->sanitizeAndFormatAmount($normalizedAmount);
-
-            if (bccomp($normalizedAmount, '0.00', 2) === 0) {
-                return;
-            }
-
-            if ($oldType->isDebit() && $newType->isCredit()) {
-                $this->setDebitAmount(bcsub($this->getDebitAmount(), $normalizedAmount, 2));
-                $this->setCreditAmount(bcadd($this->getCreditAmount(), $normalizedAmount, 2));
-            } elseif ($oldType->isCredit() && $newType->isDebit()) {
-                $this->setDebitAmount(bcadd($this->getDebitAmount(), $normalizedAmount, 2));
-                $this->setCreditAmount(bcsub($this->getCreditAmount(), $normalizedAmount, 2));
-            }
+        if ($newType === $oldType) {
+            return;
+        }
+
+        $amountComplete = $this->ensureCompleteDecimal($amount);
+        $normalizedAmount = $this->convertAmountToCents($amountComplete);
+
+        if ($normalizedAmount === 0) {
+            return;
+        }
+
+        if ($oldType->isDebit() && $newType->isCredit()) {
+            $this->debitAmount -= $normalizedAmount;
+            $this->creditAmount += $normalizedAmount;
+        } elseif ($oldType->isCredit() && $newType->isDebit()) {
+            $this->debitAmount += $normalizedAmount;
+            $this->creditAmount -= $normalizedAmount;
         }
     }
 
+    /**
+     * Expects the journal entry type,
+     * the new amount and the old amount as formatted simple amounts: e.g. 1,000.00 or 1.000,00
+     * It can expect the amounts as partial amounts: e.g. 1,000. or 1.000, (this needs to be handled by this method)
+     */
     public function updateJournalEntryAmount(JournalEntryType $journalEntryType, ?string $newAmount, ?string $oldAmount): void
     {
         if ($newAmount === $oldAmount) {
             return;
         }
 
-        $normalizedNewAmount = $newAmount === null ? '0.00' : rtrim($newAmount, '.');
-        $normalizedOldAmount = $oldAmount === null ? '0.00' : rtrim($oldAmount, '.');
+        $newAmountComplete = $this->ensureCompleteDecimal($newAmount);
+        $oldAmountComplete = $this->ensureCompleteDecimal($oldAmount);
 
-        $formattedNewAmount = $this->sanitizeAndFormatAmount($normalizedNewAmount);
-        $formattedOldAmount = $this->sanitizeAndFormatAmount($normalizedOldAmount);
+        $formattedNewAmount = $this->convertAmountToCents($newAmountComplete);
+        $formattedOldAmount = $this->convertAmountToCents($oldAmountComplete);
 
-        $difference = bcsub($formattedNewAmount, $formattedOldAmount, 2);
+        $difference = $formattedNewAmount - $formattedOldAmount;
 
         if ($journalEntryType->isDebit()) {
-            $this->setDebitAmount(bcadd($this->getDebitAmount(), $difference, 2));
+            $this->debitAmount += $difference;
         } else {
-            $this->setCreditAmount(bcadd($this->getCreditAmount(), $difference, 2));
+            $this->creditAmount += $difference;
         }
     }
 
-    protected function sanitizeAndFormatAmount(string $amount): string
+    private function ensureCompleteDecimal(?string $amount): string
+    {
+        if ($amount === null) {
+            return '0';
+        }
+
+        $currency = currency(CurrencyAccessor::getDefaultCurrency());
+        $decimal = $currency->getDecimalMark();
+
+        if (substr($amount, -1) === $decimal) {
+            return '0';
+        }
+
+        return $amount;
+    }
+
+    /**
+     * Expects formatted simple amount: e.g. 1,000.00 or 1.000,00
+     *
+     * Returns sanitized amount in cents as integer: e.g. 100000
+     */
+    protected function convertAmountToCents(string $amount): int
     {
-        return (string) money($amount, 'USD')->getAmount();
+        return money($amount, CurrencyAccessor::getDefaultCurrency(), true)->getAmount();
     }
 }

app/Contracts/AccountHandler.php

 use App\DTO\AccountBalanceReportDTO;
 use App\Enums\Accounting\AccountCategory;
 use App\Models\Accounting\Account;
-use App\ValueObjects\BalanceValue;
+use App\ValueObjects\Money;
 
 interface AccountHandler
 {
-    public function getDebitBalance(Account $account, string $startDate, string $endDate): BalanceValue;
+    public function getDebitBalance(Account $account, string $startDate, string $endDate): Money;
 
-    public function getCreditBalance(Account $account, string $startDate, string $endDate): BalanceValue;
+    public function getCreditBalance(Account $account, string $startDate, string $endDate): Money;
 
-    public function getNetMovement(Account $account, string $startDate, string $endDate): BalanceValue;
+    public function getNetMovement(Account $account, string $startDate, string $endDate): Money;
 
-    public function getStartingBalance(Account $account, string $startDate): ?BalanceValue;
+    public function getStartingBalance(Account $account, string $startDate): ?Money;
 
-    public function getEndingBalance(Account $account, string $startDate, string $endDate): ?BalanceValue;
+    public function getEndingBalance(Account $account, string $startDate, string $endDate): ?Money;
 
     public function calculateNetMovementByCategory(AccountCategory $category, int $debitBalance, int $creditBalance): int;
 
 
     public function buildAccountBalanceReport(string $startDate, string $endDate): AccountBalanceReportDTO;
 
-    public function getTotalBalanceForAllBankAccounts(string $startDate, string $endDate): BalanceValue;
+    public function getTotalBalanceForAllBankAccounts(string $startDate, string $endDate): Money;
 
     public function getAccountCategoryOrder(): array;
 

app/Enums/Banking/BankAccountType.php

 
 namespace App\Enums\Banking;
 
+use App\Enums\Concerns\ParsesEnum;
 use Filament\Support\Contracts\HasLabel;
 
 enum BankAccountType: string implements HasLabel
 {
+    use ParsesEnum;
+
     case Investment = 'investment';
     case Credit = 'credit';
     case Depository = 'depository';

app/Facades/Accounting.php

 use App\DTO\AccountBalanceReportDTO;
 use App\Enums\Accounting\AccountCategory;
 use App\Models\Accounting\Account;
-use App\ValueObjects\BalanceValue;
+use App\ValueObjects\Money;
 use Illuminate\Support\Facades\Facade;
 
 /**
- * @method static BalanceValue getDebitBalance(Account $account, string $startDate, string $endDate)
- * @method static BalanceValue getCreditBalance(Account $account, string $startDate, string $endDate)
- * @method static BalanceValue getNetMovement(Account $account, string $startDate, string $endDate)
- * @method static BalanceValue|null getStartingBalance(Account $account, string $startDate)
- * @method static BalanceValue|null getEndingBalance(Account $account, string $startDate, string $endDate)
+ * @method static Money getDebitBalance(Account $account, string $startDate, string $endDate)
+ * @method static Money getCreditBalance(Account $account, string $startDate, string $endDate)
+ * @method static Money getNetMovement(Account $account, string $startDate, string $endDate)
+ * @method static Money|null getStartingBalance(Account $account, string $startDate)
+ * @method static Money|null getEndingBalance(Account $account, string $startDate, string $endDate)
  * @method static int calculateNetMovementByCategory(AccountCategory $category, int $debitBalance, int $creditBalance)
  * @method static array getBalances(Account $account, string $startDate, string $endDate)
  * @method static AccountBalanceDTO formatBalances(array $balances)
  * @method static AccountBalanceReportDTO buildAccountBalanceReport(string $startDate, string $endDate)
- * @method static BalanceValue getTotalBalanceForAllBankAccounts(string $startDate, string $endDate)
+ * @method static Money getTotalBalanceForAllBankAccounts(string $startDate, string $endDate)
  * @method static array getAccountCategoryOrder()
  * @method static string getEarliestTransactionDate()
  *

app/Filament/Company/Clusters/Settings/Resources/CurrencyResource.php

 use App\Models\Setting\Currency as CurrencyModel;
 use App\Utilities\Currency\CurrencyAccessor;
 use Closure;
-use Filament\Facades\Filament;
 use Filament\Forms;
 use Filament\Forms\Form;
 use Filament\Resources\Resource;
         return translate($modelLabel);
     }
 
-    public static function getNavigationParentItem(): ?string
-    {
-        if (Filament::hasTopNavigation()) {
-            return translate('Finance');
-        }
-
-        return null;
-    }
-
     public static function form(Form $form): Form
     {
         return $form

app/Filament/Company/Pages/Accounting/Transactions.php

 use App\Enums\Accounting\AccountCategory;
 use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\TransactionType;
-use App\Enums\Setting\DateFormat;
 use App\Facades\Accounting;
 use App\Filament\Company\Pages\Service\ConnectedAccount;
-use App\Forms\Components\DateRangeSelect;
-use App\Forms\Components\JournalEntryRepeater;
+use App\Filament\Forms\Components\DateRangeSelect;
+use App\Filament\Forms\Components\JournalEntryRepeater;
 use App\Models\Accounting\Account;
 use App\Models\Accounting\Transaction;
 use App\Models\Banking\BankAccount;
 use App\Models\Company;
-use App\Models\Setting\Localization;
 use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Awcodes\TableRepeater\Header;
 use Filament\Support\Enums\IconPosition;
 use Filament\Support\Enums\IconSize;
 use Filament\Support\Enums\MaxWidth;
-use Filament\Support\RawJs;
 use Filament\Tables;
 use Filament\Tables\Concerns\InteractsWithTable;
 use Filament\Tables\Contracts\HasTable;
                     ->groupedIcon(null)
                     ->modalHeading('Journal Entry')
                     ->mutateFormDataUsing(static fn (array $data) => array_merge($data, ['type' => TransactionType::Journal]))
-                    ->afterFormFilled(fn () => $this->resetJournalEntryAmounts()),
+                    ->afterFormFilled(fn () => $this->resetJournalEntryAmounts())
+                    ->after(fn (Transaction $transaction) => $transaction->updateAmountIfBalanced()),
                 Actions\Action::make('connectBank')
                     ->label('Connect Your Bank')
                     ->url(ConnectedAccount::getUrl()),
             ->schema([
                 Forms\Components\DatePicker::make('posted_at')
                     ->label('Date')
-                    ->required()
-                    ->displayFormat('Y-m-d'),
+                    ->required(),
                 Forms\Components\TextInput::make('description')
                     ->label('Description'),
                 Forms\Components\Select::make('bank_account_id')
                 Tables\Columns\TextColumn::make('posted_at')
                     ->label('Date')
                     ->sortable()
-                    ->formatStateUsing(static function ($state) {
-                        $dateFormat = Localization::firstOrFail()->date_format->value ?? DateFormat::DEFAULT;
-
-                        return Carbon::parse($state)->translatedFormat($dateFormat);
-                    }),
+                    ->localizeDate(),
                 Tables\Columns\TextColumn::make('description')
                     ->limit(30)
                     ->label('Description'),
                     ->label('Account'),
                 Tables\Columns\TextColumn::make('account.name')
                     ->label('Category')
-                    ->state(static fn (Transaction $record) => $record->account->name ?? 'Journal Entry'),
+                    ->state(static fn (Transaction $transaction) => $transaction->account->name ?? 'Journal Entry'),
                 Tables\Columns\TextColumn::make('amount')
                     ->label('Amount')
-                    ->weight(static fn (Transaction $record) => $record->reviewed ? null : FontWeight::SemiBold)
+                    ->weight(static fn (Transaction $transaction) => $transaction->reviewed ? null : FontWeight::SemiBold)
                     ->color(
-                        static fn (Transaction $record) => match ($record->type) {
+                        static fn (Transaction $transaction) => match ($transaction->type) {
                             TransactionType::Deposit => Color::rgb('rgb(' . Color::Green[700] . ')'),
                             TransactionType::Journal => 'primary',
                             default => null,
                         }
                     )
-                    ->currency(static fn (Transaction $record) => $record->bankAccount->account->currency_code ?? 'USD', true)
-                    ->state(fn (Transaction $record) => $record->type->isJournal() ? $record->journalEntries->first()->amount : $record->amount),
+                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(), true),
             ])
-            ->recordClasses(static fn (Transaction $record) => $record->reviewed ? 'bg-primary-300/10' : null)
+            ->recordClasses(static fn (Transaction $transaction) => $transaction->reviewed ? 'bg-primary-300/10' : null)
             ->defaultSort('posted_at', 'desc')
             ->filters([
                 Tables\Filters\Filter::make('filters')
                 Tables\Actions\Action::make('markAsReviewed')
                     ->label('Mark as Reviewed')
                     ->view('filament.company.components.tables.actions.mark-as-reviewed')
-                    ->icon(static fn (Transaction $record) => $record->reviewed ? 'heroicon-s-check-circle' : 'heroicon-o-check-circle')
-                    ->color(static fn (Transaction $record, Tables\Actions\Action $action) => match (static::determineTransactionState($record, $action)) {
+                    ->icon(static fn (Transaction $transaction) => $transaction->reviewed ? 'heroicon-s-check-circle' : 'heroicon-o-check-circle')
+                    ->color(static fn (Transaction $transaction, Tables\Actions\Action $action) => match (static::determineTransactionState($transaction, $action)) {
                         'reviewed' => 'primary',
                         'unreviewed' => Color::rgb('rgb(' . Color::Gray[600] . ')'),
                         'uncategorized' => 'gray',
                     })
-                    ->tooltip(static fn (Transaction $record, Tables\Actions\Action $action) => match (static::determineTransactionState($record, $action)) {
+                    ->tooltip(static fn (Transaction $transaction, Tables\Actions\Action $action) => match (static::determineTransactionState($transaction, $action)) {
                         'reviewed' => 'Reviewed',
                         'unreviewed' => 'Mark as Reviewed',
                         'uncategorized' => 'Categorize first to mark as reviewed',
                     })
-                    ->disabled(fn (Transaction $record): bool => $record->isUncategorized())
-                    ->action(fn (Transaction $record) => $record->update(['reviewed' => ! $record->reviewed])),
+                    ->disabled(fn (Transaction $transaction): bool => $transaction->isUncategorized())
+                    ->action(fn (Transaction $transaction) => $transaction->update(['reviewed' => ! $transaction->reviewed])),
                 Tables\Actions\ActionGroup::make([
                     Tables\Actions\EditAction::make('updateTransaction')
                         ->label('Edit Transaction')
                         ->modalHeading('Edit Transaction')
                         ->modalWidth(MaxWidth::ThreeExtraLarge)
                         ->form(fn (Form $form) => $this->transactionForm($form))
-                        ->hidden(static fn (Transaction $record) => $record->type->isJournal()),
+                        ->hidden(static fn (Transaction $transaction) => $transaction->type->isJournal()),
                     Tables\Actions\EditAction::make('updateJournalTransaction')
                         ->label('Edit Journal Transaction')
                         ->modalHeading('Journal Entry')
                         ->modalWidth(MaxWidth::Screen)
                         ->form(fn (Form $form) => $this->journalTransactionForm($form))
-                        ->afterFormFilled(function (Transaction $record) {
-                            $debitAmounts = $record->journalEntries->where('type', JournalEntryType::Debit)->sum('amount');
-                            $creditAmounts = $record->journalEntries->where('type', JournalEntryType::Credit)->sum('amount');
+                        ->afterFormFilled(function (Transaction $transaction) {
+                            $debitAmounts = $transaction->journalEntries->sumDebits()->getAmount();
+                            $creditAmounts = $transaction->journalEntries->sumCredits()->getAmount();
 
                             $this->setDebitAmount($debitAmounts);
                             $this->setCreditAmount($creditAmounts);
                         })
-                        ->visible(static fn (Transaction $record) => $record->type->isJournal()),
+                        ->modalSubmitAction(fn (Actions\StaticAction $action) => $action->disabled(! $this->isJournalEntryBalanced()))
+                        ->after(fn (Transaction $transaction) => $transaction->updateAmountIfBalanced())
+                        ->visible(static fn (Transaction $transaction) => $transaction->type->isJournal()),
                     Tables\Actions\DeleteAction::make(),
                     Tables\Actions\ReplicateAction::make()
                         ->excludeAttributes(['created_by', 'updated_by', 'created_at', 'updated_at'])
                         ->modal(false)
-                        ->beforeReplicaSaved(static function (Transaction $replica) {
-                            $replica->description = '(Copy of) ' . $replica->description;
+                        ->beforeReplicaSaved(static function (Transaction $transaction) {
+                            $transaction->description = '(Copy of) ' . $transaction->description;
                         }),
                 ])
                     ->dropdownPlacement('bottom-start')
             ->schema($this->getJournalEntriesTableRepeaterSchema())
             ->streamlined()
             ->deletable(fn (JournalEntryRepeater $repeater) => $repeater->getItemsCount() > 2)
+            ->deleteAction(function (Forms\Components\Actions\Action $action) {
+                return $action
+                    ->action(function (array $arguments, JournalEntryRepeater $component): void {
+                        $items = $component->getState();
+
+                        $amount = $items[$arguments['item']]['amount'];
+                        $type = $items[$arguments['item']]['type'];
+
+                        $this->updateJournalEntryAmount(JournalEntryType::parse($type), '0.00', $amount);
+
+                        unset($items[$arguments['item']]);
+
+                        $component->state($items);
+
+                        $component->callAfterStateUpdated();
+                    });
+            })
             ->minItems(2)
             ->defaultItems(2)
             ->addable(false)
             TextInput::make('amount')
                 ->label('Amount')
                 ->live()
-                ->mask(RawJs::make('$money($input)'))
+                ->mask(moneyMask(CurrencyAccessor::getDefaultCurrency()))
                 ->afterStateUpdated(function (Get $get, Set $set, ?string $state, ?string $old) {
                     $this->updateJournalEntryAmount(JournalEntryType::parse($get('type')), $state, $old);
                 })
         }
     }
 
-    protected static function determineTransactionState(Transaction $record, Tables\Actions\Action $action): string
+    protected static function determineTransactionState(Transaction $transaction, Tables\Actions\Action $action): string
     {
-        if ($record->reviewed) {
+        if ($transaction->reviewed) {
             return 'reviewed';
         }
 
-        if ($record->reviewed === false && $action->isEnabled()) {
+        if ($transaction->reviewed === false && $action->isEnabled()) {
             return 'unreviewed';
         }
 
 
     protected function getBalanceForAllAccounts(): string
     {
-        return Accounting::getTotalBalanceForAllBankAccounts($this->fiscalYearStartDate, $this->fiscalYearEndDate)->formatted();
+        return Accounting::getTotalBalanceForAllBankAccounts($this->fiscalYearStartDate, $this->fiscalYearEndDate)->format();
     }
 }

app/Filament/Company/Pages/Reports/AccountBalances.php

 namespace App\Filament\Company\Pages\Reports;
 
 use App\DTO\AccountBalanceReportDTO;
-use App\Forms\Components\DateRangeSelect;
+use App\Filament\Forms\Components\DateRangeSelect;
 use App\Models\Company;
 use App\Services\AccountBalancesExportService;
 use App\Services\AccountService;

app/Filament/Company/Resources/Banking/AccountResource.php

 
 namespace App\Filament\Company\Resources\Banking;
 
-use App\Actions\OptionAction\CreateCurrency;
 use App\Enums\Accounting\AccountCategory;
 use App\Enums\Banking\BankAccountType;
-use App\Facades\Forex;
 use App\Filament\Company\Resources\Banking\AccountResource\Pages;
+use App\Filament\Forms\Components\CreateCurrencySelect;
 use App\Models\Accounting\AccountSubtype;
 use App\Models\Banking\BankAccount;
-use App\Utilities\Currency\CurrencyAccessor;
-use BackedEnum;
 use Filament\Forms;
 use Filament\Forms\Form;
 use Filament\Resources\Resource;
 use Filament\Tables\Table;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Auth;
-use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\Rules\Unique;
 use Wallo\FilamentSelectify\Components\ToggleButton;
 
                             ->columnSpan(1)
                             ->default(BankAccountType::DEFAULT)
                             ->live()
-                            ->afterStateUpdated(static function (Forms\Set $set, $state, ?BankAccount $record, string $operation) {
+                            ->afterStateUpdated(static function (Forms\Set $set, $state, ?BankAccount $bankAccount, string $operation) {
                                 if ($operation === 'create') {
                                     $set('account.subtype_id', null);
-                                } elseif ($operation === 'edit' && $record !== null) {
-                                    if ($state !== $record->type->value) {
+                                } elseif ($operation === 'edit' && $bankAccount !== null) {
+                                    if ($state !== $bankAccount->type->value) {
                                         $set('account.subtype_id', null);
                                     } else {
-                                        $set('account.subtype_id', $record->account->subtype_id);
+                                        $set('account.subtype_id', $bankAccount->account->subtype_id);
                                     }
                                 }
                             })
                             ->relationship('account')
                             ->schema([
                                 Forms\Components\Select::make('subtype_id')
-                                    ->options(static function (Forms\Get $get) {
-                                        $typeValue = $get('data.type', true); // Bug: $get('type') returns string on edit, but returns Enum type on create
-                                        $typeString = $typeValue instanceof BackedEnum ? $typeValue->value : $typeValue;
-
-                                        return static::groupSubtypesBySubtypeType($typeString);
-                                    })
+                                    ->options(static fn (Forms\Get $get) => static::groupSubtypesBySubtypeType(BankAccountType::parse($get('data.type', true))))
                                     ->localizeLabel()
                                     ->searchable()
                                     ->live()
                             ]),
                         Forms\Components\Group::make()
                             ->relationship('account')
-                            ->columns(2)
+                            ->columns()
                             ->columnSpanFull()
                             ->schema([
                                 Forms\Components\TextInput::make('name')
                                     ->maxLength(100)
                                     ->localizeLabel()
                                     ->required(),
-                                Forms\Components\Select::make('currency_code')
-                                    ->localizeLabel('Currency')
-                                    ->relationship('currency', 'name')
-                                    ->default(CurrencyAccessor::getDefaultCurrency())
-                                    ->preload()
-                                    ->searchable()
-                                    ->live()
-                                    ->required()
-                                    ->createOptionForm([
-                                        Forms\Components\Select::make('code')
-                                            ->localizeLabel()
-                                            ->searchable()
-                                            ->options(CurrencyAccessor::getAvailableCurrencies())
-                                            ->live()
-                                            ->afterStateUpdated(static function (callable $set, $state) {
-                                                if ($state === null) {
-                                                    return;
-                                                }
-
-                                                $currency_code = currency($state);
-                                                $defaultCurrencyCode = currency()->getCurrency();
-                                                $forexEnabled = Forex::isEnabled();
-                                                $exchangeRate = $forexEnabled ? Forex::getCachedExchangeRate($defaultCurrencyCode, $state) : null;
-
-                                                $set('name', $currency_code->getName() ?? '');
-
-                                                if ($forexEnabled && $exchangeRate !== null) {
-                                                    $set('rate', $exchangeRate);
-                                                }
-                                            })
-                                            ->required(),
-                                        Forms\Components\TextInput::make('name')
-                                            ->localizeLabel()
-                                            ->maxLength(100)
-                                            ->required(),
-                                        Forms\Components\TextInput::make('rate')
-                                            ->localizeLabel()
-                                            ->numeric()
-                                            ->required(),
-                                    ])->createOptionAction(static function (Forms\Components\Actions\Action $action) {
-                                        return $action
-                                            ->label('Add Currency')
-                                            ->slideOver()
-                                            ->modalWidth('md')
-                                            ->action(static function (array $data) {
-                                                return DB::transaction(static function () use ($data) {
-                                                    $code = $data['code'];
-                                                    $name = $data['name'];
-                                                    $rate = $data['rate'];
-
-                                                    return (new CreateCurrency())->create($code, $name, $rate);
-                                                });
-                                            });
-                                    }),
+                                CreateCurrencySelect::make('currency_code')
+                                    ->relationship('currency', 'name'),
                             ]),
                         Forms\Components\Group::make()
                             ->columns()
         ];
     }
 
-    public static function groupSubtypesBySubtypeType($typeString): array
+    public static function groupSubtypesBySubtypeType(BankAccountType $bankAccountType): array
     {
-        $category = match ($typeString) {
-            BankAccountType::Depository->value, BankAccountType::Investment->value => AccountCategory::Asset,
-            BankAccountType::Credit->value, BankAccountType::Loan->value => AccountCategory::Liability,
+        $category = match ($bankAccountType) {
+            BankAccountType::Depository, BankAccountType::Investment => AccountCategory::Asset,
+            BankAccountType::Credit, BankAccountType::Loan => AccountCategory::Liability,
             default => null,
         };
 

app/Filament/Company/Resources/Banking/AccountResource/Pages/CreateAccount.php

 
 use App\Filament\Company\Resources\Banking\AccountResource;
 use Filament\Resources\Pages\CreateRecord;
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Support\Facades\Log;
 
 class CreateAccount extends CreateRecord
 {
     {
         $data['enabled'] = (bool) ($data['enabled'] ?? false);
 
-        Log::info('CreateAccount::mutateFormDataBeforeCreate', $data);
-
         return $data;
     }
-
-    protected function handleRecordCreation(array $data): Model
-    {
-        Log::info('CreateAccount::handleRecordCreation', $data);
-
-        return parent::handleRecordCreation($data);
-    }
 }

app/Filament/Forms/Components/CreateCurrencySelect.php

+<?php
+
+namespace App\Filament\Forms\Components;
+
+use App\Actions\OptionAction\CreateCurrency;
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use Filament\Forms\Components\Actions\Action;
+use Filament\Forms\Components\Select;
+use Filament\Forms\Components\TextInput;
+use Filament\Forms\Set;
+use Filament\Support\Enums\MaxWidth;
+use Illuminate\Support\Facades\DB;
+
+class CreateCurrencySelect extends Select
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->localizeLabel('Currency')
+            ->default(CurrencyAccessor::getDefaultCurrency())
+            ->preload()
+            ->searchable()
+            ->live()
+            ->required()
+            ->createOptionForm($this->createCurrencyForm())
+            ->createOptionAction(fn (Action $action) => $this->createCurrencyAction($action));
+    }
+
+    protected function createCurrencyForm(): array
+    {
+        return [
+            Select::make('code')
+                ->localizeLabel()
+                ->searchable()
+                ->options(CurrencyAccessor::getAvailableCurrencies())
+                ->live()
+                ->afterStateUpdated(static function (Set $set, $state) {
+                    CurrencyConverter::handleCurrencyChange($set, $state);
+                })
+                ->required(),
+            TextInput::make('name')
+                ->localizeLabel()
+                ->maxLength(100)
+                ->required(),
+            TextInput::make('rate')
+                ->localizeLabel()
+                ->numeric()
+                ->required(),
+        ];
+    }
+
+    protected function createCurrencyAction(Action $action): Action
+    {
+        return $action
+            ->label('Add Currency')
+            ->slideOver()
+            ->modalWidth(MaxWidth::Medium)
+            ->action(static function (array $data) {
+                return DB::transaction(static function () use ($data) {
+                    $code = $data['code'];
+                    $name = $data['name'];
+                    $rate = $data['rate'];
+
+                    return CreateCurrency::create($code, $name, $rate);
+                });
+            });
+    }
+}

app/Forms/Components/DateRangeSelect.php → app/Filament/Forms/Components/DateRangeSelect.php

 <?php
 
-namespace App\Forms\Components;
+namespace App\Filament\Forms\Components;
 
 use App\Facades\Accounting;
 use App\Models\Company;

app/Forms/Components/JournalEntryRepeater.php → app/Filament/Forms/Components/JournalEntryRepeater.php

 <?php
 
-namespace App\Forms\Components;
+namespace App\Filament\Forms\Components;
 
 use Awcodes\TableRepeater\Components\TableRepeater;
 use Closure;
 
     public function getView(): string
     {
-        return 'forms.components.journal-entry-repeater';
+        return 'filament.forms.components.journal-entry-repeater';
     }
 }

app/Listeners/UpdateAccountBalances.php

                 /** @var BankAccount $bankAccount */
                 $account = $bankAccount->account;
 
-                $oldConvertedBalanceInCents = $account->ending_balance->convert()->getConvertedValue();
+                $oldConvertedBalanceInCents = $account->ending_balance->convert()->getConvertedAmount();
                 $ratio = $event->newRate / $event->oldRate;
                 $newConvertedBalance = bcmul($oldConvertedBalanceInCents, $ratio, 2);
                 $newConvertedBalanceInCents = (int) round($newConvertedBalance);

app/Models/Accounting/JournalEntry.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\MoneyCast;
+use App\Casts\JournalEntryCast;
+use App\Collections\Accounting\JournalEntryCollection;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\JournalEntryType;
 use App\Observers\JournalEntryObserver;
 use Database\Factories\Accounting\JournalEntryFactory;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
-use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 
     protected $casts = [
         'type' => JournalEntryType::class,
-        'amount' => MoneyCast::class,
+        'amount' => JournalEntryCast::class,
     ];
 
     public function account(): BelongsTo
         return $this->account->isUncategorized();
     }
 
-    public function scopeDebit(Builder $query): Builder
-    {
-        return $query->where('type', JournalEntryType::Debit);
-    }
-
-    public function scopeCredit(Builder $query): Builder
+    protected static function newFactory(): Factory
     {
-        return $query->where('type', JournalEntryType::Credit);
+        return JournalEntryFactory::new();
     }
 
-    protected static function newFactory(): Factory
+    public function newCollection(array $models = []): JournalEntryCollection
     {
-        return JournalEntryFactory::new();
+        return new JournalEntryCollection($models);
     }
 }

app/Models/Accounting/Transaction.php

         return $this->journalEntries->contains(fn (JournalEntry $entry) => $entry->account->isUncategorized());
     }
 
+    public function updateAmountIfBalanced(): void
+    {
+        if ($this->journalEntries->areBalanced() && $this->journalEntries->sumDebits()->formatSimple() !== $this->getAttributeValue('amount')) {
+            $this->setAttribute('amount', $this->journalEntries->sumDebits()->formatSimple());
+            $this->save();
+        }
+    }
+
     protected static function newFactory(): Factory
     {
         return TransactionFactory::new();

app/Observers/JournalEntryObserver.php

     }
 
     /**
-     * Handle the JournalEntry "deleting" event.
-     */
-    public function deleting(JournalEntry $journalEntry): void
-    {
-        //
-    }
-
-    /**
-     * Handle the JournalEntry "deleted" event.
+     * Handle the JournalEntry "updated" event.
      */
-    public function deleted(JournalEntry $journalEntry): void
+    public function updated(JournalEntry $journalEntry): void
     {
         //
     }
 
     /**
-     * Handle the JournalEntry "restored" event.
+     * Handle the JournalEntry "deleting" event.
      */
-    public function restored(JournalEntry $journalEntry): void
+    public function deleting(JournalEntry $journalEntry): void
     {
         //
     }
 
     /**
-     * Handle the JournalEntry "force deleted" event.
+     * Handle the JournalEntry "deleted" event.
      */
-    public function forceDeleted(JournalEntry $journalEntry): void
+    public function deleted(JournalEntry $journalEntry): void
     {
         //
     }

app/Observers/TransactionObserver.php

      */
     public function updated(Transaction $transaction): void
     {
+        $transaction->refresh(); // DO NOT REMOVE
+
         if ($transaction->type->isJournal() || $this->hasRelevantChanges($transaction) === false) {
             return;
         }
     private function getConvertedTransactionAmount(Transaction $transaction): string
     {
         $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
-        $transactionCurrency = $transaction->bankAccount->account->currency_code; // only account which would have a different currency compared to the default currency
+        $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+        $chartAccountCurrency = $transaction->account->currency_code;
 
-        if ($transactionCurrency !== $defaultCurrency) {
-            return $this->convertToDefaultCurrency($transaction->amount, $transactionCurrency, $defaultCurrency);
+        if ($bankAccountCurrency !== $defaultCurrency) {
+            return $this->convertToDefaultCurrency($transaction->amount, $bankAccountCurrency, $defaultCurrency);
+        } elseif ($chartAccountCurrency !== $defaultCurrency) {
+            return $this->convertToDefaultCurrency($transaction->amount, $chartAccountCurrency, $defaultCurrency);
         }
 
         return $transaction->amount;

app/Providers/MacroServiceProvider.php

 
 use Akaunting\Money\Currency;
 use Akaunting\Money\Money;
+use App\Enums\Setting\DateFormat;
 use App\Models\Accounting\AccountSubtype;
+use App\Models\Setting\Localization;
 use App\Utilities\Accounting\AccountCode;
 use App\Utilities\Currency\CurrencyAccessor;
 use BackedEnum;
 use Filament\Forms\Components\Field;
 use Filament\Forms\Components\TextInput;
 use Filament\Tables\Columns\TextColumn;
+use Illuminate\Support\Carbon;
 use Illuminate\Support\ServiceProvider;
 use Illuminate\Support\Str;
 
             return $this;
         });
 
+        TextColumn::macro('localizeDate', function (): static {
+            $localization = Localization::firstOrFail();
+
+            $dateFormat = $localization->date_format->value ?? DateFormat::DEFAULT;
+            $timezone = $localization->timezone ?? Carbon::now()->timezoneName;
+
+            $this->date($dateFormat, $timezone);
+
+            return $this;
+        });
+
         TextColumn::macro('currency', function (string | Closure | null $currency = null, ?bool $convert = null): static {
             $this->formatStateUsing(static function (TextColumn $column, $state) use ($currency, $convert): ?string {
                 if (blank($state)) {

app/Services/AccountService.php

 use App\Models\Banking\BankAccount;
 use App\Repositories\Accounting\JournalEntryRepository;
 use App\Utilities\Currency\CurrencyAccessor;
-use App\ValueObjects\BalanceValue;
+use App\ValueObjects\Money;
 use Illuminate\Database\Eloquent\Collection;
 
 class AccountService implements AccountHandler
         $this->journalEntryRepository = $journalEntryRepository;
     }
 
-    public function getDebitBalance(Account $account, string $startDate, string $endDate): BalanceValue
+    public function getDebitBalance(Account $account, string $startDate, string $endDate): Money
     {
         $amount = $this->journalEntryRepository->sumDebitAmounts($account, $startDate, $endDate);
 
-        return new BalanceValue($amount, $account->currency_code);
+        return new Money($amount, $account->currency_code);
     }
 
-    public function getCreditBalance(Account $account, string $startDate, string $endDate): BalanceValue
+    public function getCreditBalance(Account $account, string $startDate, string $endDate): Money
     {
         $amount = $this->journalEntryRepository->sumCreditAmounts($account, $startDate, $endDate);
 
-        return new BalanceValue($amount, $account->currency_code);
+        return new Money($amount, $account->currency_code);
     }
 
-    public function getNetMovement(Account $account, string $startDate, string $endDate): BalanceValue
+    public function getNetMovement(Account $account, string $startDate, string $endDate): Money
     {
         $debitBalance = $this->journalEntryRepository->sumDebitAmounts($account, $startDate, $endDate);
         $creditBalance = $this->journalEntryRepository->sumCreditAmounts($account, $startDate, $endDate);
         $netMovement = $this->calculateNetMovementByCategory($account->category, $debitBalance, $creditBalance);
 
-        return new BalanceValue($netMovement, $account->currency_code);
+        return new Money($netMovement, $account->currency_code);
     }
 
-    public function getStartingBalance(Account $account, string $startDate): ?BalanceValue
+    public function getStartingBalance(Account $account, string $startDate): ?Money
     {
         if (in_array($account->category, [AccountCategory::Expense, AccountCategory::Revenue], true)) {
             return null;
         $creditBalanceBefore = $this->journalEntryRepository->sumCreditAmounts($account, $startDate);
         $startingBalance = $this->calculateNetMovementByCategory($account->category, $debitBalanceBefore, $creditBalanceBefore);
 
-        return new BalanceValue($startingBalance, $account->currency_code);
+        return new Money($startingBalance, $account->currency_code);
     }
 
-    public function getEndingBalance(Account $account, string $startDate, string $endDate): ?BalanceValue
+    public function getEndingBalance(Account $account, string $startDate, string $endDate): ?Money
     {
         if (in_array($account->category, [AccountCategory::Expense, AccountCategory::Revenue], true)) {
             return null;
         }
 
-        $startingBalance = $this->getStartingBalance($account, $startDate)?->getValue();
-        $netMovement = $this->getNetMovement($account, $startDate, $endDate)->getValue();
+        $startingBalance = $this->getStartingBalance($account, $startDate)?->getAmount();
+        $netMovement = $this->getNetMovement($account, $startDate, $endDate)->getAmount();
         $endingBalance = $startingBalance + $netMovement;
 
-        return new BalanceValue($endingBalance, $account->currency_code);
+        return new Money($endingBalance, $account->currency_code);
     }
 
     public function calculateNetMovementByCategory(AccountCategory $category, int $debitBalance, int $creditBalance): int
 
     public function getBalances(Account $account, string $startDate, string $endDate): array
     {
-        $debitBalance = $this->getDebitBalance($account, $startDate, $endDate)->getValue();
-        $creditBalance = $this->getCreditBalance($account, $startDate, $endDate)->getValue();
-        $netMovement = $this->getNetMovement($account, $startDate, $endDate)->getValue();
+        $debitBalance = $this->getDebitBalance($account, $startDate, $endDate)->getAmount();
+        $creditBalance = $this->getCreditBalance($account, $startDate, $endDate)->getAmount();
+        $netMovement = $this->getNetMovement($account, $startDate, $endDate)->getAmount();
 
         $balances = [
             'debit_balance' => $debitBalance,
         ];
 
         if (! in_array($account->category, [AccountCategory::Expense, AccountCategory::Revenue], true)) {
-            $balances['starting_balance'] = $this->getStartingBalance($account, $startDate)?->getValue();
-            $balances['ending_balance'] = $this->getEndingBalance($account, $startDate, $endDate)?->getValue();
+            $balances['starting_balance'] = $this->getStartingBalance($account, $startDate)?->getAmount();
+            $balances['ending_balance'] = $this->getEndingBalance($account, $startDate, $endDate)?->getAmount();
         }
 
         return $balances;
         return new AccountBalanceReportDTO($accountCategories, $formattedReportTotalBalances);
     }
 
-    public function getTotalBalanceForAllBankAccounts(string $startDate, string $endDate): BalanceValue
+    public function getTotalBalanceForAllBankAccounts(string $startDate, string $endDate): Money
     {
         $bankAccountsAccounts = Account::where('accountable_type', BankAccount::class)
             ->get();
 
         // Get ending balance for each bank account
         foreach ($bankAccountsAccounts as $account) {
-            $endingBalance = $this->getEndingBalance($account, $startDate, $endDate)?->getValue() ?? 0;
+            $endingBalance = $this->getEndingBalance($account, $startDate, $endDate)?->getAmount() ?? 0;
             $totalBalance += $endingBalance;
         }
 
-        return new BalanceValue($totalBalance, CurrencyAccessor::getDefaultCurrency());
+        return new Money($totalBalance, CurrencyAccessor::getDefaultCurrency());
     }
 
     public function getAccountCategoryOrder(): array

app/Utilities/Currency/ConfigureCurrencies.php

         $customCurrencies = [];
 
         foreach ($currencies as $currency) {
+            /** @var CurrencyModel $currency */
             $customCurrencies[$currency->code] = [
                 'name' => $currency->name,
                 'rate' => $currency->rate,
             try {
                 $name = Currencies::getName($code, app()->getLocale());
                 $existingCurrencies[$code]['name'] = ucwords($name);
-            } catch (MissingResourceException $e) {
+            } catch (MissingResourceException) {
                 $existingCurrencies[$code]['name'] = $currency['name'];
             }
         }

app/Utilities/Currency/CurrencyConverter.php

 
 namespace App\Utilities\Currency;
 
+use App\Facades\Forex;
+use Filament\Forms\Set;
+
 class CurrencyConverter
 {
     public static function convertAndSet($newCurrency, $oldCurrency, $amount): ?string
     {
         return money($balance, $currency, true)->getAmount();
     }
+
+    public static function handleCurrencyChange(Set $set, $state): void
+    {
+        $currency = currency($state);
+        $defaultCurrencyCode = CurrencyAccessor::getDefaultCurrency();
+        $forexEnabled = Forex::isEnabled();
+        $exchangeRate = $forexEnabled ? Forex::getCachedExchangeRate($defaultCurrencyCode, $state) : null;
+
+        $set('name', $currency->getName() ?? '');
+
+        if ($forexEnabled && $exchangeRate !== null) {
+            $set('rate', $exchangeRate);
+        }
+    }
 }

app/ValueObjects/BalanceValue.php

-<?php
-
-namespace App\ValueObjects;
-
-use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
-
-class BalanceValue
-{
-    private int $value;
-
-    private string $currency;
-
-    private ?int $convertedValue = null;
-
-    public function __construct(int $value, string $currency)
-    {
-        $this->value = $value;
-        $this->currency = $currency;
-    }
-
-    public function getValue(): int
-    {
-        return $this->value;
-    }
-
-    public function getEffectiveValue(): int
-    {
-        return $this->convertedValue ?? $this->value;
-    }
-
-    public function getConvertedValue(): ?int
-    {
-        return $this->convertedValue;
-    }
-
-    public function getCurrency(): string
-    {
-        return $this->currency;
-    }
-
-    public function formatted(): string
-    {
-        return money($this->getEffectiveValue(), $this->getCurrency())->format();
-    }
-
-    public function formattedSimple(): string
-    {
-        return money($this->getEffectiveValue(), $this->getCurrency())->formatSimple();
-    }
-
-    public function formatWithCode(bool $codeBefore = false): string
-    {
-        return money($this->getEffectiveValue(), $this->getCurrency())->formatWithCode($codeBefore);
-    }
-
-    public function convert(): self
-    {
-        // The journal entry sums are stored in the default currency not the account currency (transaction amounts are stored in the account currency)
-        $fromCurrency = CurrencyAccessor::getDefaultCurrency();
-        $toCurrency = $this->currency;
-
-        if ($fromCurrency !== $toCurrency) {
-            $this->convertedValue = CurrencyConverter::convertBalance($this->value, $fromCurrency, $toCurrency);
-        }
-
-        return $this;
-    }
-}

app/ValueObjects/Money.php

+<?php
+
+namespace App\ValueObjects;
+
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+
+class Money
+{
+    private int $amount;
+
+    private string $currencyCode;
+
+    private ?int $convertedAmount = null;
+
+    public function __construct(int $amount, string $currencyCode)
+    {
+        $this->amount = $amount;
+        $this->currencyCode = $currencyCode;
+    }
+
+    public function getAmount(): int
+    {
+        return $this->amount;
+    }
+
+    public function getCurrencyCode(): string
+    {
+        return $this->currencyCode;
+    }
+
+    public function getEffectiveAmount(): int
+    {
+        return $this->convertedAmount ?? $this->amount;
+    }
+
+    public function getConvertedAmount(): ?int
+    {
+        return $this->convertedAmount;
+    }
+
+    public function getValue(): float
+    {
+        return money($this->amount, $this->currencyCode)->getValue();
+    }
+
+    public function format(): string
+    {
+        return money($this->getEffectiveAmount(), $this->getCurrencyCode())->format();
+    }
+
+    public function formatSimple(): string
+    {
+        return money($this->getEffectiveAmount(), $this->getCurrencyCode())->formatSimple();
+    }
+
+    public function formatWithCode(bool $codeBefore = false): string
+    {
+        return money($this->getEffectiveAmount(), $this->getCurrencyCode())->formatWithCode($codeBefore);
+    }
+
+    public function convert(): self
+    {
+        // The journal entry sums are stored in the default currency not the account currency (transaction amounts are stored in the account currency)
+        $fromCurrency = CurrencyAccessor::getDefaultCurrency();
+        $toCurrency = $this->currencyCode;
+
+        if ($fromCurrency !== $toCurrency) {
+            $this->convertedAmount = CurrencyConverter::convertBalance($this->amount, $fromCurrency, $toCurrency);
+        }
+
+        return $this;
+    }
+
+    public function __toString(): string
+    {
+        return $this->formatSimple();
+    }
+}

composer.lock

         },
         {
             "name": "brick/math",
-            "version": "0.11.0",
+            "version": "0.12.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/brick/math.git",
-                "reference": "0ad82ce168c82ba30d1c01ec86116ab52f589478"
+                "reference": "f510c0a40911935b77b86859eb5223d58d660df1"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/brick/math/zipball/0ad82ce168c82ba30d1c01ec86116ab52f589478",
-                "reference": "0ad82ce168c82ba30d1c01ec86116ab52f589478",
+                "url": "https://api.github.com/repos/brick/math/zipball/f510c0a40911935b77b86859eb5223d58d660df1",
+                "reference": "f510c0a40911935b77b86859eb5223d58d660df1",
                 "shasum": ""
             },
             "require": {
-                "php": "^8.0"
+                "php": "^8.1"
             },
             "require-dev": {
                 "php-coveralls/php-coveralls": "^2.2",
-                "phpunit/phpunit": "^9.0",
-                "vimeo/psalm": "5.0.0"
+                "phpunit/phpunit": "^10.1",
+                "vimeo/psalm": "5.16.0"
             },
             "type": "library",
             "autoload": {
                 "arithmetic",
                 "bigdecimal",
                 "bignum",
+                "bignumber",
                 "brick",
-                "math"
+                "decimal",
+                "integer",
+                "math",
+                "mathematics",
+                "rational"
             ],
             "support": {
                 "issues": "https://github.com/brick/math/issues",
-                "source": "https://github.com/brick/math/tree/0.11.0"
+                "source": "https://github.com/brick/math/tree/0.12.1"
             },
             "funding": [
                 {
                     "type": "github"
                 }
             ],
-            "time": "2023-01-15T23:15:59+00:00"
+            "time": "2023-11-29T23:19:16+00:00"
         },
         {
             "name": "carbonphp/carbon-doctrine-types",
         },
         {
             "name": "filament/actions",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/actions.git",
         },
         {
             "name": "filament/filament",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/panels.git",
-                "reference": "e00510fb4edc73b027f784317381f791b47c22de"
+                "reference": "28dc99ec5865982a1859a34e48ee88fb59f58313"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/panels/zipball/e00510fb4edc73b027f784317381f791b47c22de",
-                "reference": "e00510fb4edc73b027f784317381f791b47c22de",
+                "url": "https://api.github.com/repos/filamentphp/panels/zipball/28dc99ec5865982a1859a34e48ee88fb59f58313",
+                "reference": "28dc99ec5865982a1859a34e48ee88fb59f58313",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-04-21T22:24:02+00:00"
+            "time": "2024-04-28T08:39:16+00:00"
         },
         {
             "name": "filament/forms",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/forms.git",
-                "reference": "eea1a3ec87bbe62d470dd0a26d9f4b8ef9cb5d39"
+                "reference": "40988aa2cb540b17b86dc6684b9c3f57b9be3109"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/forms/zipball/eea1a3ec87bbe62d470dd0a26d9f4b8ef9cb5d39",
-                "reference": "eea1a3ec87bbe62d470dd0a26d9f4b8ef9cb5d39",
+                "url": "https://api.github.com/repos/filamentphp/forms/zipball/40988aa2cb540b17b86dc6684b9c3f57b9be3109",
+                "reference": "40988aa2cb540b17b86dc6684b9c3f57b9be3109",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-04-21T22:23:42+00:00"
+            "time": "2024-04-28T08:39:12+00:00"
         },
         {
             "name": "filament/infolists",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/infolists.git",
-                "reference": "d205fbeacc7faf4430abb05c49334a64fb4d84ae"
+                "reference": "612497be1c0e5b8b1e0ef9eeefe4754baab54271"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/infolists/zipball/d205fbeacc7faf4430abb05c49334a64fb4d84ae",
-                "reference": "d205fbeacc7faf4430abb05c49334a64fb4d84ae",
+                "url": "https://api.github.com/repos/filamentphp/infolists/zipball/612497be1c0e5b8b1e0ef9eeefe4754baab54271",
+                "reference": "612497be1c0e5b8b1e0ef9eeefe4754baab54271",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-04-18T11:26:13+00:00"
+            "time": "2024-04-28T08:39:09+00:00"
         },
         {
             "name": "filament/notifications",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/notifications.git",
-                "reference": "dcc47b498c2a5a89296c2f46da651a8aa5e0bf55"
+                "reference": "a37c926d2edbcb07e6fd8a354ce2f5daa59ad92e"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/notifications/zipball/dcc47b498c2a5a89296c2f46da651a8aa5e0bf55",
-                "reference": "dcc47b498c2a5a89296c2f46da651a8aa5e0bf55",
+                "url": "https://api.github.com/repos/filamentphp/notifications/zipball/a37c926d2edbcb07e6fd8a354ce2f5daa59ad92e",
+                "reference": "a37c926d2edbcb07e6fd8a354ce2f5daa59ad92e",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-04-18T11:26:15+00:00"
+            "time": "2024-04-28T08:39:09+00:00"
         },
         {
             "name": "filament/support",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/support.git",
-                "reference": "594f8d38e365578b6d91455c5beade6c54def5a4"
+                "reference": "169fa6303337ad1f5d0203b9d34baa76bc938384"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/support/zipball/594f8d38e365578b6d91455c5beade6c54def5a4",
-                "reference": "594f8d38e365578b6d91455c5beade6c54def5a4",
+                "url": "https://api.github.com/repos/filamentphp/support/zipball/169fa6303337ad1f5d0203b9d34baa76bc938384",
+                "reference": "169fa6303337ad1f5d0203b9d34baa76bc938384",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-04-21T22:24:20+00:00"
+            "time": "2024-04-28T08:39:28+00:00"
         },
         {
             "name": "filament/tables",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/tables.git",
-                "reference": "b3bc1d2b5947562eb64748e6d3f59ed1073effe7"
+                "reference": "c3fce6d9e3b9a41d48cbccdacef3508f0cf73f56"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/tables/zipball/b3bc1d2b5947562eb64748e6d3f59ed1073effe7",
-                "reference": "b3bc1d2b5947562eb64748e6d3f59ed1073effe7",
+                "url": "https://api.github.com/repos/filamentphp/tables/zipball/c3fce6d9e3b9a41d48cbccdacef3508f0cf73f56",
+                "reference": "c3fce6d9e3b9a41d48cbccdacef3508f0cf73f56",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-04-21T22:24:20+00:00"
+            "time": "2024-04-28T08:39:27+00:00"
         },
         {
             "name": "filament/widgets",
-            "version": "v3.2.71",
+            "version": "v3.2.72",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/widgets.git",
         },
         {
             "name": "ramsey/uuid",
-            "version": "4.7.5",
+            "version": "4.7.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/ramsey/uuid.git",
-                "reference": "5f0df49ae5ad6efb7afa69e6bfab4e5b1e080d8e"
+                "reference": "91039bc1faa45ba123c4328958e620d382ec7088"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/ramsey/uuid/zipball/5f0df49ae5ad6efb7afa69e6bfab4e5b1e080d8e",
-                "reference": "5f0df49ae5ad6efb7afa69e6bfab4e5b1e080d8e",
+                "url": "https://api.github.com/repos/ramsey/uuid/zipball/91039bc1faa45ba123c4328958e620d382ec7088",
+                "reference": "91039bc1faa45ba123c4328958e620d382ec7088",
                 "shasum": ""
             },
             "require": {
-                "brick/math": "^0.8.8 || ^0.9 || ^0.10 || ^0.11",
+                "brick/math": "^0.8.8 || ^0.9 || ^0.10 || ^0.11 || ^0.12",
                 "ext-json": "*",
                 "php": "^8.0",
                 "ramsey/collection": "^1.2 || ^2.0"
             ],
             "support": {
                 "issues": "https://github.com/ramsey/uuid/issues",
-                "source": "https://github.com/ramsey/uuid/tree/4.7.5"
+                "source": "https://github.com/ramsey/uuid/tree/4.7.6"
             },
             "funding": [
                 {
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-11-08T05:53:05+00:00"
+            "time": "2024-04-27T21:32:50+00:00"
         },
         {
             "name": "ryangjchandler/blade-capture-directive",

database/migrations/2023_09_08_040159_create_company_defaults_table.php

         Schema::create('company_defaults', function (Blueprint $table) {
             $table->id();
             $table->foreignId('company_id')->constrained()->cascadeOnDelete();
-            $table->foreignId('bank_account_id')->nullable()->constrained('bank_accounts')->restrictOnDelete();
+            $table->foreignId('bank_account_id')->nullable()->constrained('bank_accounts')->nullOnDelete();
             $table->string('currency_code')->nullable();
-            $table->foreignId('sales_tax_id')->nullable()->constrained('taxes')->cascadeOnDelete();
-            $table->foreignId('purchase_tax_id')->nullable()->constrained('taxes')->cascadeOnDelete();
-            $table->foreignId('sales_discount_id')->nullable()->constrained('discounts')->cascadeOnDelete();
-            $table->foreignId('purchase_discount_id')->nullable()->constrained('discounts')->cascadeOnDelete();
-            $table->foreignId('created_by')->nullable()->constrained('users')->restrictOnDelete();
-            $table->foreignId('updated_by')->nullable()->constrained('users')->restrictOnDelete();
+            $table->foreignId('sales_tax_id')->nullable()->constrained('taxes')->nullOnDelete();
+            $table->foreignId('purchase_tax_id')->nullable()->constrained('taxes')->nullOnDelete();
+            $table->foreignId('sales_discount_id')->nullable()->constrained('discounts')->nullOnDelete();
+            $table->foreignId('purchase_discount_id')->nullable()->constrained('discounts')->nullOnDelete();
+            $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
+            $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamps();
-
-            $table->foreign(['company_id', 'currency_code'])
-                ->references(['company_id', 'code'])
-                ->on('currencies')
-                ->restrictOnDelete();
         });
     }
 

package-lock.json

             }
         },
         "node_modules/@rollup/rollup-android-arm-eabi": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.16.4.tgz",
-            "integrity": "sha512-GkhjAaQ8oUTOKE4g4gsZ0u8K/IHU1+2WQSgS1TwTcYvL+sjbaQjNHFXbOJ6kgqGHIO1DfUhI/Sphi9GkRT9K+Q==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.17.0.tgz",
+            "integrity": "sha512-nNvLvC2fjC+3+bHYN9uaGF3gcyy7RHGZhtl8TB/kINj9hiOQza8kWJGZh47GRPMrqeseO8U+Z8ElDMCZlWBdHA==",
             "cpu": [
                 "arm"
             ],
             ]
         },
         "node_modules/@rollup/rollup-android-arm64": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.16.4.tgz",
-            "integrity": "sha512-Bvm6D+NPbGMQOcxvS1zUl8H7DWlywSXsphAeOnVeiZLQ+0J6Is8T7SrjGTH29KtYkiY9vld8ZnpV3G2EPbom+w==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.17.0.tgz",
+            "integrity": "sha512-+kjt6dvxnyTIAo7oHeYseYhDyZ7xRKTNl/FoQI96PHkJVxoChldJnne/LzYqpqidoK1/0kX0/q+5rrYqjpth6w==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-darwin-arm64": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.16.4.tgz",
-            "integrity": "sha512-i5d64MlnYBO9EkCOGe5vPR/EeDwjnKOGGdd7zKFhU5y8haKhQZTN2DgVtpODDMxUr4t2K90wTUJg7ilgND6bXw==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.17.0.tgz",
+            "integrity": "sha512-Oj6Tp0unMpGTBjvNwbSRv3DopMNLu+mjBzhKTt2zLbDJ/45fB1pltr/rqrO4bE95LzuYwhYn127pop+x/pzf5w==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-darwin-x64": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.16.4.tgz",
-            "integrity": "sha512-WZupV1+CdUYehaZqjaFTClJI72fjJEgTXdf4NbW69I9XyvdmztUExBtcI2yIIU6hJtYvtwS6pkTkHJz+k08mAQ==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.17.0.tgz",
+            "integrity": "sha512-3nJx0T+yptxMd+v93rBRxSPTAVCv8szu/fGZDJiKX7kvRe9sENj2ggXjCH/KK1xZEmJOhaNo0c9sGMgGdfkvEw==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.16.4.tgz",
-            "integrity": "sha512-ADm/xt86JUnmAfA9mBqFcRp//RVRt1ohGOYF6yL+IFCYqOBNwy5lbEK05xTsEoJq+/tJzg8ICUtS82WinJRuIw==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.17.0.tgz",
+            "integrity": "sha512-Vb2e8p9b2lxxgqyOlBHmp6hJMu/HSU6g//6Tbr7x5V1DlPCHWLOm37nSIVK314f+IHzORyAQSqL7+9tELxX3zQ==",
             "cpu": [
                 "arm"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.16.4.tgz",
-            "integrity": "sha512-tJfJaXPiFAG+Jn3cutp7mCs1ePltuAgRqdDZrzb1aeE3TktWWJ+g7xK9SNlaSUFw6IU4QgOxAY4rA+wZUT5Wfg==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.17.0.tgz",
+            "integrity": "sha512-Md60KsmC5ZIaRq/bYYDloklgU+XLEZwS2EXXVcSpiUw+13/ZASvSWQ/P92rQ9YDCL6EIoXxuQ829JkReqdYbGg==",
             "cpu": [
                 "arm"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm64-gnu": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.16.4.tgz",
-            "integrity": "sha512-7dy1BzQkgYlUTapDTvK997cgi0Orh5Iu7JlZVBy1MBURk7/HSbHkzRnXZa19ozy+wwD8/SlpJnOOckuNZtJR9w==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.17.0.tgz",
+            "integrity": "sha512-zL5rBFtJ+2EGnMRm2TqKjdjgFqlotSU+ZJEN37nV+fiD3I6Gy0dUh3jBWN0wSlcXVDEJYW7YBe+/2j0N9unb2w==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm64-musl": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.16.4.tgz",
-            "integrity": "sha512-zsFwdUw5XLD1gQe0aoU2HVceI6NEW7q7m05wA46eUAyrkeNYExObfRFQcvA6zw8lfRc5BHtan3tBpo+kqEOxmg==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.17.0.tgz",
+            "integrity": "sha512-s2xAyNkJqUdtRVgNK4NK4P9QttS538JuX/kfVQOdZDI5FIKVAUVdLW7qhGfmaySJ1EvN/Bnj9oPm5go9u8navg==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.16.4.tgz",
-            "integrity": "sha512-p8C3NnxXooRdNrdv6dBmRTddEapfESEUflpICDNKXpHvTjRRq1J82CbU5G3XfebIZyI3B0s074JHMWD36qOW6w==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.17.0.tgz",
+            "integrity": "sha512-7F99yzVT67B7IUNMjLD9QCFDCyHkyCJMS1dywZrGgVFJao4VJ9szrIEgH67cR+bXQgEaY01ur/WSL6B0jtcLyA==",
             "cpu": [
                 "ppc64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.16.4.tgz",
-            "integrity": "sha512-Lh/8ckoar4s4Id2foY7jNgitTOUQczwMWNYi+Mjt0eQ9LKhr6sK477REqQkmy8YHY3Ca3A2JJVdXnfb3Rrwkng==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.17.0.tgz",
+            "integrity": "sha512-leFtyiXisfa3Sg9pgZJwRKITWnrQfhtqDjCamnZhkZuIsk1FXmYwKoTkp6lsCgimIcneFFkHKp/yGLxDesga4g==",
             "cpu": [
                 "riscv64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-s390x-gnu": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.16.4.tgz",
-            "integrity": "sha512-1xwwn9ZCQYuqGmulGsTZoKrrn0z2fAur2ujE60QgyDpHmBbXbxLaQiEvzJWDrscRq43c8DnuHx3QorhMTZgisQ==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.17.0.tgz",
+            "integrity": "sha512-FtOgui6qMJ4jbSXTxElsy/60LEe/3U0rXkkz2G5CJ9rbHPAvjMvI+3qF0A0fwLQ5hW+/ZC6PbnS2KfRW9JkgDQ==",
             "cpu": [
                 "s390x"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-x64-gnu": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.16.4.tgz",
-            "integrity": "sha512-LuOGGKAJ7dfRtxVnO1i3qWc6N9sh0Em/8aZ3CezixSTM+E9Oq3OvTsvC4sm6wWjzpsIlOCnZjdluINKESflJLA==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.17.0.tgz",
+            "integrity": "sha512-v6eiam/1w3HUfU/ZjzIDodencqgrSqzlNuNtiwH7PFJHYSo1ezL0/UIzmS2lpSJF1ORNaplXeKHYmmdt81vV2g==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-x64-musl": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.16.4.tgz",
-            "integrity": "sha512-ch86i7KkJKkLybDP2AtySFTRi5fM3KXp0PnHocHuJMdZwu7BuyIKi35BE9guMlmTpwwBTB3ljHj9IQXnTCD0vA==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.17.0.tgz",
+            "integrity": "sha512-OUhkSdpM5ofVlVU2k4CwVubYwiwu1a4jYWPpubzN7Vzao73GoPBowHcCfaRSFRz1SszJ3HIsk3dZYk4kzbqjgw==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-win32-arm64-msvc": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.16.4.tgz",
-            "integrity": "sha512-Ma4PwyLfOWZWayfEsNQzTDBVW8PZ6TUUN1uFTBQbF2Chv/+sjenE86lpiEwj2FiviSmSZ4Ap4MaAfl1ciF4aSA==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.17.0.tgz",
+            "integrity": "sha512-uL7UYO/MNJPGL/yflybI+HI+n6+4vlfZmQZOCb4I+z/zy1wisHT3exh7oNQsnL6Eso0EUTEfgQ/PaGzzXf6XyQ==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-win32-ia32-msvc": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.16.4.tgz",
-            "integrity": "sha512-9m/ZDrQsdo/c06uOlP3W9G2ENRVzgzbSXmXHT4hwVaDQhYcRpi9bgBT0FTG9OhESxwK0WjQxYOSfv40cU+T69w==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.17.0.tgz",
+            "integrity": "sha512-4WnSgaUiUmXILwFqREdOcqvSj6GD/7FrvSjhaDjmwakX9w4Z2F8JwiSP1AZZbuRkPqzi444UI5FPv33VKOWYFQ==",
             "cpu": [
                 "ia32"
             ],
             ]
         },
         "node_modules/@rollup/rollup-win32-x64-msvc": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.16.4.tgz",
-            "integrity": "sha512-YunpoOAyGLDseanENHmbFvQSfVL5BxW3k7hhy0eN4rb3gS/ct75dVD0EXOWIqFT/nE8XYW6LP6vz6ctKRi0k9A==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.17.0.tgz",
+            "integrity": "sha512-ve+D8t1prRSRnF2S3pyDtTXDlvW1Pngbz76tjgYFQW1jxVSysmQCZfPoDAo4WP+Ano8zeYp85LsArZBI12HfwQ==",
             "cpu": [
                 "x64"
             ],
             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001612",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001612.tgz",
-            "integrity": "sha512-lFgnZ07UhaCcsSZgWW0K5j4e69dK1u/ltrL9lTUiFOwNHs12S3UMIEYgBV0Z6C6hRDev7iRnMzzYmKabYdXF9g==",
+            "version": "1.0.30001613",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001613.tgz",
+            "integrity": "sha512-BNjJULJfOONQERivfxte7alLfeLW4QnwHvNW4wEcLEbXfV6VSCYvr+REbf2Sojv8tC1THpjPXBxWgDbq4NtLWg==",
             "dev": true,
             "funding": [
                 {
             }
         },
         "node_modules/rollup": {
-            "version": "4.16.4",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.16.4.tgz",
-            "integrity": "sha512-kuaTJSUbz+Wsb2ATGvEknkI12XV40vIiHmLuFlejoo7HtDok/O5eDDD0UpCVY5bBX5U5RYo8wWP83H7ZsqVEnA==",
+            "version": "4.17.0",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.17.0.tgz",
+            "integrity": "sha512-wZJSn0WMtWrxhYKQRt5Z6GIXlziOoMDFmbHmRfL3v+sBTAshx2DBq1AfMArB7eIjF63r4ocn2ZTAyUptg/7kmQ==",
             "dev": true,
             "dependencies": {
                 "@types/estree": "1.0.5"
                 "npm": ">=8.0.0"
             },
             "optionalDependencies": {
-                "@rollup/rollup-android-arm-eabi": "4.16.4",
-                "@rollup/rollup-android-arm64": "4.16.4",
-                "@rollup/rollup-darwin-arm64": "4.16.4",
-                "@rollup/rollup-darwin-x64": "4.16.4",
-                "@rollup/rollup-linux-arm-gnueabihf": "4.16.4",
-                "@rollup/rollup-linux-arm-musleabihf": "4.16.4",
-                "@rollup/rollup-linux-arm64-gnu": "4.16.4",
-                "@rollup/rollup-linux-arm64-musl": "4.16.4",
-                "@rollup/rollup-linux-powerpc64le-gnu": "4.16.4",
-                "@rollup/rollup-linux-riscv64-gnu": "4.16.4",
-                "@rollup/rollup-linux-s390x-gnu": "4.16.4",
-                "@rollup/rollup-linux-x64-gnu": "4.16.4",
-                "@rollup/rollup-linux-x64-musl": "4.16.4",
-                "@rollup/rollup-win32-arm64-msvc": "4.16.4",
-                "@rollup/rollup-win32-ia32-msvc": "4.16.4",
-                "@rollup/rollup-win32-x64-msvc": "4.16.4",
+                "@rollup/rollup-android-arm-eabi": "4.17.0",
+                "@rollup/rollup-android-arm64": "4.17.0",
+                "@rollup/rollup-darwin-arm64": "4.17.0",
+                "@rollup/rollup-darwin-x64": "4.17.0",
+                "@rollup/rollup-linux-arm-gnueabihf": "4.17.0",
+                "@rollup/rollup-linux-arm-musleabihf": "4.17.0",
+                "@rollup/rollup-linux-arm64-gnu": "4.17.0",
+                "@rollup/rollup-linux-arm64-musl": "4.17.0",
+                "@rollup/rollup-linux-powerpc64le-gnu": "4.17.0",
+                "@rollup/rollup-linux-riscv64-gnu": "4.17.0",
+                "@rollup/rollup-linux-s390x-gnu": "4.17.0",
+                "@rollup/rollup-linux-x64-gnu": "4.17.0",
+                "@rollup/rollup-linux-x64-musl": "4.17.0",
+                "@rollup/rollup-win32-arm64-msvc": "4.17.0",
+                "@rollup/rollup-win32-ia32-msvc": "4.17.0",
+                "@rollup/rollup-win32-x64-msvc": "4.17.0",
                 "fsevents": "~2.3.2"
             }
         },
             }
         },
         "node_modules/yaml": {
-            "version": "2.4.1",
-            "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.4.1.tgz",
-            "integrity": "sha512-pIXzoImaqmfOrL7teGUBt/T7ZDnyeGBWyXQBvOVhLkWLN37GXv8NMLK406UY6dS51JfcQHsmcW5cJ441bHg6Lg==",
+            "version": "2.4.2",
+            "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.4.2.tgz",
+            "integrity": "sha512-B3VqDZ+JAg1nZpaEmWtTXUlBneoGx6CPM9b0TENK6aoSu5t73dItudwdgmi6tHlIZZId4dZ9skcAQ2UbcyAeVA==",
             "dev": true,
             "bin": {
                 "yaml": "bin.mjs"