PHPackages                             azaharizaman/nexus-financial-ratios - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. azaharizaman/nexus-financial-ratios

ActiveLibrary[Utility & Helpers](/categories/utility)

azaharizaman/nexus-financial-ratios
===================================

Financial ratio calculations including liquidity, profitability, leverage, and efficiency ratios

v0.1.0-alpha1(1mo ago)00MITPHPPHP ^8.3

Since May 5Pushed 1mo agoCompare

[ Source](https://github.com/azaharizaman/nexus-financial-ratios)[ Packagist](https://packagist.org/packages/azaharizaman/nexus-financial-ratios)[ RSS](/packages/azaharizaman-nexus-financial-ratios/feed)WikiDiscussions main Synced 1w ago

READMEChangelogDependencies (2)Versions (2)Used By (0)

Nexus\\FinancialRatios
======================

[](#nexusfinancialratios)

**Framework-Agnostic Financial Ratio Analysis Engine**

[![PHP Version](https://camo.githubusercontent.com/ef0054230522e542bc1f908ac005c6c75888dea255bac910f9015e12095e31d7/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d253545382e332d626c7565)](https://www.php.net/)[![License](https://camo.githubusercontent.com/f8df3091bbe1149f398a5369b2c39e896766f9f6efba3477c63e9b4aa940ef14/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d677265656e)](LICENSE)

Overview
--------

[](#overview)

`Nexus\FinancialRatios` is a pure PHP package that provides the core engine for calculating and analyzing financial ratios. It covers liquidity, profitability, leverage, efficiency, cash flow, and market ratios. The package includes DuPont analysis decomposition and benchmarking capabilities.

This package is **framework-agnostic** and contains no database access, no HTTP controllers, and no framework-specific code. Consuming applications provide financial data through injected interfaces.

Installation
------------

[](#installation)

```
composer require azaharizaman/nexus-financial-ratios
```

Package Responsibilities
------------------------

[](#package-responsibilities)

ResponsibilityDescription**Ratio Calculation**Calculate standard financial ratios**DuPont Analysis**Decompose ROE into component drivers**Benchmarking**Compare ratios against industry standards**Health Assessment**Evaluate financial health indicators**Trend Analysis**Track ratio changes over time**Multi-Period Comparison**Compare ratios across periodsKey Concepts
------------

[](#key-concepts)

### Ratio Categories

[](#ratio-categories)

CategoryPurposeKey Ratios**Liquidity**Short-term solvencyCurrent, Quick, Cash**Profitability**Earnings generationGross Margin, Net Margin, ROA, ROE**Leverage**Debt managementDebt-to-Equity, Interest Coverage**Efficiency**Asset utilizationInventory Turnover, AR Turnover**Cash Flow**Cash generationOperating Cash Flow, Free Cash Flow**Market**Investor metricsEPS, P/E, Dividend Yield---

Architecture
------------

[](#architecture)

```
src/
├── Contracts/           # Interfaces defining the public API
├── ValueObjects/        # Immutable ratio data structures
├── Enums/               # Ratio categories and types
├── Services/            # Ratio calculation logic
└── Exceptions/          # Domain-specific errors

```

---

Contracts (Interfaces)
----------------------

[](#contracts-interfaces)

### Core Interfaces

[](#core-interfaces)

#### `RatioCalculatorInterface`

[](#ratiocalculatorinterface)

Unified interface for all ratio calculations.

```
interface RatioCalculatorInterface
{
    /**
     * Calculate a specific ratio
     *
     * @param RatioType $type The ratio to calculate
     * @param RatioInput $input The financial data
     * @return RatioResult
     */
    public function calculate(RatioType $type, RatioInput $input): RatioResult;

    /**
     * Calculate all ratios in a category
     *
     * @return array
     */
    public function calculateCategory(
        RatioCategory $category,
        RatioInput $input
    ): array;

    /**
     * Calculate all standard ratios
     *
     * @return array
     */
    public function calculateAll(RatioInput $input): array;
}
```

#### `LiquidityRatioInterface`

[](#liquidityratiointerface)

Calculates short-term solvency ratios.

```
interface LiquidityRatioInterface
{
    /**
     * Current Ratio = Current Assets / Current Liabilities
     * Measures ability to pay short-term obligations
     */
    public function currentRatio(Money $currentAssets, Money $currentLiabilities): RatioResult;

    /**
     * Quick Ratio = (Current Assets - Inventory) / Current Liabilities
     * Excludes less liquid inventory
     */
    public function quickRatio(
        Money $currentAssets,
        Money $inventory,
        Money $currentLiabilities
    ): RatioResult;

    /**
     * Cash Ratio = Cash & Equivalents / Current Liabilities
     * Most conservative liquidity measure
     */
    public function cashRatio(Money $cashAndEquivalents, Money $currentLiabilities): RatioResult;

    /**
     * Working Capital = Current Assets - Current Liabilities
     * Absolute liquidity measure
     */
    public function workingCapital(Money $currentAssets, Money $currentLiabilities): Money;
}
```

#### `ProfitabilityRatioInterface`

[](#profitabilityratiointerface)

Calculates earnings and margin ratios.

```
interface ProfitabilityRatioInterface
{
    /**
     * Gross Profit Margin = Gross Profit / Revenue
     */
    public function grossProfitMargin(Money $grossProfit, Money $revenue): RatioResult;

    /**
     * Operating Margin = Operating Income / Revenue
     */
    public function operatingMargin(Money $operatingIncome, Money $revenue): RatioResult;

    /**
     * Net Profit Margin = Net Income / Revenue
     */
    public function netProfitMargin(Money $netIncome, Money $revenue): RatioResult;

    /**
     * Return on Assets = Net Income / Total Assets
     */
    public function returnOnAssets(Money $netIncome, Money $totalAssets): RatioResult;

    /**
     * Return on Equity = Net Income / Shareholders' Equity
     */
    public function returnOnEquity(Money $netIncome, Money $shareholdersEquity): RatioResult;

    /**
     * Return on Invested Capital = NOPAT / Invested Capital
     */
    public function returnOnInvestedCapital(Money $nopat, Money $investedCapital): RatioResult;
}
```

#### `LeverageRatioInterface`

[](#leverageratiointerface)

Calculates debt and leverage ratios.

```
interface LeverageRatioInterface
{
    /**
     * Debt-to-Equity = Total Debt / Shareholders' Equity
     */
    public function debtToEquity(Money $totalDebt, Money $shareholdersEquity): RatioResult;

    /**
     * Debt-to-Assets = Total Debt / Total Assets
     */
    public function debtToAssets(Money $totalDebt, Money $totalAssets): RatioResult;

    /**
     * Interest Coverage = EBIT / Interest Expense
     */
    public function interestCoverage(Money $ebit, Money $interestExpense): RatioResult;

    /**
     * Equity Multiplier = Total Assets / Shareholders' Equity
     * (Used in DuPont analysis)
     */
    public function equityMultiplier(Money $totalAssets, Money $shareholdersEquity): RatioResult;

    /**
     * Debt Service Coverage = Operating Income / Total Debt Service
     */
    public function debtServiceCoverage(
        Money $operatingIncome,
        Money $totalDebtService
    ): RatioResult;
}
```

#### `EfficiencyRatioInterface`

[](#efficiencyratiointerface)

Calculates asset utilization ratios.

```
interface EfficiencyRatioInterface
{
    /**
     * Inventory Turnover = COGS / Average Inventory
     */
    public function inventoryTurnover(Money $cogs, Money $averageInventory): RatioResult;

    /**
     * Days Inventory Outstanding = 365 / Inventory Turnover
     */
    public function daysInventoryOutstanding(RatioResult $inventoryTurnover): RatioResult;

    /**
     * Receivables Turnover = Revenue / Average AR
     */
    public function receivablesTurnover(Money $revenue, Money $averageAR): RatioResult;

    /**
     * Days Sales Outstanding = 365 / Receivables Turnover
     */
    public function daysSalesOutstanding(RatioResult $receivablesTurnover): RatioResult;

    /**
     * Payables Turnover = COGS / Average AP
     */
    public function payablesTurnover(Money $cogs, Money $averageAP): RatioResult;

    /**
     * Days Payables Outstanding = 365 / Payables Turnover
     */
    public function daysPayablesOutstanding(RatioResult $payablesTurnover): RatioResult;

    /**
     * Asset Turnover = Revenue / Total Assets
     */
    public function assetTurnover(Money $revenue, Money $totalAssets): RatioResult;

    /**
     * Cash Conversion Cycle = DIO + DSO - DPO
     */
    public function cashConversionCycle(
        RatioResult $dio,
        RatioResult $dso,
        RatioResult $dpo
    ): RatioResult;
}
```

#### `CashFlowRatioInterface`

[](#cashflowratiointerface)

Calculates cash flow health ratios.

```
interface CashFlowRatioInterface
{
    /**
     * Operating Cash Flow Ratio = Operating CF / Current Liabilities
     */
    public function operatingCashFlowRatio(
        Money $operatingCashFlow,
        Money $currentLiabilities
    ): RatioResult;

    /**
     * Free Cash Flow = Operating CF - CapEx
     */
    public function freeCashFlow(Money $operatingCashFlow, Money $capex): Money;

    /**
     * Cash Flow to Debt = Operating CF / Total Debt
     */
    public function cashFlowToDebt(Money $operatingCashFlow, Money $totalDebt): RatioResult;

    /**
     * Cash Flow Margin = Operating CF / Revenue
     */
    public function cashFlowMargin(Money $operatingCashFlow, Money $revenue): RatioResult;

    /**
     * Capital Expenditure Coverage = Operating CF / CapEx
     */
    public function capexCoverage(Money $operatingCashFlow, Money $capex): RatioResult;
}
```

#### `MarketRatioInterface`

[](#marketratiointerface)

Calculates investor and market ratios.

```
interface MarketRatioInterface
{
    /**
     * Earnings Per Share = Net Income / Shares Outstanding
     */
    public function earningsPerShare(Money $netIncome, int $sharesOutstanding): RatioResult;

    /**
     * Price-to-Earnings = Market Price / EPS
     */
    public function priceToEarnings(Money $marketPrice, RatioResult $eps): RatioResult;

    /**
     * Price-to-Book = Market Price / Book Value Per Share
     */
    public function priceToBook(Money $marketPrice, Money $bookValuePerShare): RatioResult;

    /**
     * Dividend Yield = Dividend Per Share / Market Price
     */
    public function dividendYield(Money $dividendPerShare, Money $marketPrice): RatioResult;

    /**
     * Dividend Payout Ratio = Dividends / Net Income
     */
    public function dividendPayoutRatio(Money $dividends, Money $netIncome): RatioResult;
}
```

#### `RatioDataProviderInterface`

[](#ratiodataproviderinterface)

Contract for consuming applications to provide financial data.

```
interface RatioDataProviderInterface
{
    /**
     * Get balance sheet data for ratio calculation
     */
    public function getBalanceSheetData(
        string $tenantId,
        string $periodId
    ): BalanceSheetData;

    /**
     * Get income statement data
     */
    public function getIncomeStatementData(
        string $tenantId,
        string $periodId
    ): IncomeStatementData;

    /**
     * Get cash flow data
     */
    public function getCashFlowData(
        string $tenantId,
        string $periodId
    ): CashFlowData;

    /**
     * Get market data (for public companies)
     */
    public function getMarketData(
        string $tenantId,
        string $periodId
    ): ?MarketData;

    /**
     * Get historical ratio values for trends
     */
    public function getHistoricalRatios(
        string $tenantId,
        RatioType $type,
        int $periods = 12
    ): array;
}
```

---

Value Objects
-------------

[](#value-objects)

### `RatioResult`

[](#ratioresult)

```
final readonly class RatioResult
{
    public function __construct(
        public RatioType $type,
        public float $value,
        public string $displayValue,
        public RatioCategory $category,
        public string $interpretation,
        public ?\DateTimeImmutable $calculatedFor = null
    ) {}

    public function isHealthy(): bool
    {
        // Based on ratio type and value
    }

    public function compareToIndustry(float $industryAverage): string
    {
        // Above average, below average, etc.
    }
}
```

### `RatioInput`

[](#ratioinput)

```
final readonly class RatioInput
{
    public function __construct(
        // Balance Sheet items
        public Money $currentAssets,
        public Money $totalAssets,
        public Money $currentLiabilities,
        public Money $totalLiabilities,
        public Money $totalDebt,
        public Money $shareholdersEquity,
        public Money $inventory,
        public Money $accountsReceivable,
        public Money $accountsPayable,
        public Money $cashAndEquivalents,

        // Income Statement items
        public Money $revenue,
        public Money $costOfGoodsSold,
        public Money $grossProfit,
        public Money $operatingIncome,
        public Money $netIncome,
        public Money $interestExpense,

        // Cash Flow items
        public Money $operatingCashFlow,
        public Money $capitalExpenditures,

        // Average values (for turnover ratios)
        public ?Money $averageInventory = null,
        public ?Money $averageReceivables = null,
        public ?Money $averagePayables = null,
        public ?Money $averageAssets = null
    ) {}
}
```

### `RatioBenchmark`

[](#ratiobenchmark)

```
final readonly class RatioBenchmark
{
    public function __construct(
        public RatioType $ratioType,
        public float $industryAverage,
        public float $industryMedian,
        public float $topQuartile,
        public float $bottomQuartile,
        public string $industryCode,
        public string $industryName,
        public BenchmarkSource $source,
        public \DateTimeImmutable $asOfDate
    ) {}
}
```

### `HealthIndicator`

[](#healthindicator)

```
final readonly class HealthIndicator
{
    public function __construct(
        public string $area,
        public string $status,
        public string $summary,
        public array $concerningRatios,
        public array $healthyRatios,
        public array $recommendations
    ) {}
}
```

---

Enums
-----

[](#enums)

### `RatioCategory`

[](#ratiocategory)

```
enum RatioCategory: string
{
    case LIQUIDITY = 'liquidity';
    case PROFITABILITY = 'profitability';
    case LEVERAGE = 'leverage';
    case EFFICIENCY = 'efficiency';
    case CASH_FLOW = 'cash_flow';
    case MARKET = 'market';
}
```

### `RatioType`

[](#ratiotype)

```
enum RatioType: string
{
    // Liquidity
    case CURRENT_RATIO = 'current_ratio';
    case QUICK_RATIO = 'quick_ratio';
    case CASH_RATIO = 'cash_ratio';

    // Profitability
    case GROSS_PROFIT_MARGIN = 'gross_profit_margin';
    case OPERATING_MARGIN = 'operating_margin';
    case NET_PROFIT_MARGIN = 'net_profit_margin';
    case RETURN_ON_ASSETS = 'return_on_assets';
    case RETURN_ON_EQUITY = 'return_on_equity';
    case RETURN_ON_INVESTED_CAPITAL = 'return_on_invested_capital';

    // Leverage
    case DEBT_TO_EQUITY = 'debt_to_equity';
    case DEBT_TO_ASSETS = 'debt_to_assets';
    case INTEREST_COVERAGE = 'interest_coverage';
    case EQUITY_MULTIPLIER = 'equity_multiplier';

    // Efficiency
    case INVENTORY_TURNOVER = 'inventory_turnover';
    case DAYS_INVENTORY_OUTSTANDING = 'days_inventory_outstanding';
    case RECEIVABLES_TURNOVER = 'receivables_turnover';
    case DAYS_SALES_OUTSTANDING = 'days_sales_outstanding';
    case PAYABLES_TURNOVER = 'payables_turnover';
    case DAYS_PAYABLES_OUTSTANDING = 'days_payables_outstanding';
    case ASSET_TURNOVER = 'asset_turnover';
    case CASH_CONVERSION_CYCLE = 'cash_conversion_cycle';

    // Cash Flow
    case OPERATING_CASH_FLOW_RATIO = 'operating_cash_flow_ratio';
    case FREE_CASH_FLOW = 'free_cash_flow';
    case CASH_FLOW_TO_DEBT = 'cash_flow_to_debt';
    case CASH_FLOW_MARGIN = 'cash_flow_margin';

    // Market
    case EARNINGS_PER_SHARE = 'earnings_per_share';
    case PRICE_TO_EARNINGS = 'price_to_earnings';
    case PRICE_TO_BOOK = 'price_to_book';
    case DIVIDEND_YIELD = 'dividend_yield';
    case DIVIDEND_PAYOUT_RATIO = 'dividend_payout_ratio';
}
```

### `BenchmarkSource`

[](#benchmarksource)

```
enum BenchmarkSource: string
{
    case INDUSTRY_REPORT = 'industry_report';
    case REGULATORY = 'regulatory';
    case INTERNAL = 'internal';
    case PEER_GROUP = 'peer_group';
}
```

---

Services
--------

[](#services)

### `LiquidityRatioCalculator`

[](#liquidityratiocalculator)

Calculates all liquidity ratios:

- Current Ratio
- Quick Ratio (Acid Test)
- Cash Ratio
- Working Capital

### `ProfitabilityRatioCalculator`

[](#profitabilityratiocalculator)

Calculates all profitability ratios:

- Gross Profit Margin
- Operating Margin
- Net Profit Margin
- ROA, ROE, ROIC

### `LeverageRatioCalculator`

[](#leverageratiocalculator)

Calculates all leverage ratios:

- Debt-to-Equity
- Debt-to-Assets
- Interest Coverage
- Equity Multiplier

### `EfficiencyRatioCalculator`

[](#efficiencyratiocalculator)

Calculates all efficiency ratios:

- Inventory Turnover & DIO
- Receivables Turnover & DSO
- Payables Turnover & DPO
- Asset Turnover
- Cash Conversion Cycle

### `CashFlowRatioCalculator`

[](#cashflowratiocalculator)

Calculates all cash flow ratios:

- Operating Cash Flow Ratio
- Free Cash Flow
- Cash Flow to Debt
- Cash Flow Margin

### `MarketRatioCalculator`

[](#marketratiocalculator)

Calculates all market ratios:

- EPS
- P/E Ratio
- P/B Ratio
- Dividend Yield

### `DuPontAnalyzer`

[](#dupontanalyzer)

Performs DuPont analysis to decompose ROE:

```
ROE = Net Profit Margin × Asset Turnover × Equity Multiplier

Where:
- Net Profit Margin = Net Income / Revenue
- Asset Turnover = Revenue / Total Assets
- Equity Multiplier = Total Assets / Equity

```

3-Factor Model:

```
ROE = (Net Income / Revenue) × (Revenue / Assets) × (Assets / Equity)

```

5-Factor Extended Model:

```
ROE = Tax Burden × Interest Burden × Operating Margin × Asset Turnover × Leverage

```

### `RatioBenchmarker`

[](#ratiobenchmarker)

Compares calculated ratios against benchmarks:

- Industry averages
- Peer group comparisons
- Historical trends
- Regulatory minimums

---

Exceptions
----------

[](#exceptions)

ExceptionWhen Thrown`RatioCalculationException`Ratio calculation fails (e.g., division by zero)`BenchmarkNotFoundException`No benchmark data available for comparison`InsufficientDataException`Not enough data to calculate ratio---

Usage Example
-------------

[](#usage-example)

```
use Nexus\FinancialRatios\Contracts\RatioCalculatorInterface;
use Nexus\FinancialRatios\Services\DuPontAnalyzer;
use Nexus\FinancialRatios\ValueObjects\RatioInput;
use Nexus\FinancialRatios\Enums\RatioCategory;

final readonly class FinancialHealthReportService
{
    public function __construct(
        private RatioCalculatorInterface $calculator,
        private DuPontAnalyzer $dupontAnalyzer,
        private RatioDataProviderInterface $dataProvider
    ) {}

    public function generateHealthReport(string $tenantId, string $periodId): array
    {
        // Get financial data
        $balanceSheet = $this->dataProvider->getBalanceSheetData($tenantId, $periodId);
        $incomeStatement = $this->dataProvider->getIncomeStatementData($tenantId, $periodId);
        $cashFlow = $this->dataProvider->getCashFlowData($tenantId, $periodId);

        // Build ratio input
        $input = new RatioInput(
            currentAssets: $balanceSheet->currentAssets,
            totalAssets: $balanceSheet->totalAssets,
            // ... other inputs
        );

        // Calculate all ratios
        $allRatios = $this->calculator->calculateAll($input);

        // Perform DuPont analysis
        $dupont = $this->dupontAnalyzer->analyze($input);

        return [
            'liquidity' => $allRatios[RatioCategory::LIQUIDITY->value],
            'profitability' => $allRatios[RatioCategory::PROFITABILITY->value],
            'leverage' => $allRatios[RatioCategory::LEVERAGE->value],
            'efficiency' => $allRatios[RatioCategory::EFFICIENCY->value],
            'cash_flow' => $allRatios[RatioCategory::CASH_FLOW->value],
            'dupont_analysis' => $dupont,
            'health_score' => $this->calculateOverallHealth($allRatios),
        ];
    }
}
```

---

Standard Ratio Formulas
-----------------------

[](#standard-ratio-formulas)

### Liquidity Ratios

[](#liquidity-ratios)

RatioFormulaHealthy RangeCurrent RatioCurrent Assets / Current Liabilities1.5 - 3.0Quick Ratio(Current Assets - Inventory) / Current Liabilities1.0 - 2.0Cash RatioCash / Current Liabilities0.5 - 1.0### Profitability Ratios

[](#profitability-ratios)

RatioFormulaInterpretationGross MarginGross Profit / RevenueHigher = betterNet MarginNet Income / RevenueHigher = betterROANet Income / Total AssetsHigher = betterROENet Income / Equity15-20%+ is good### Leverage Ratios

[](#leverage-ratios)

RatioFormulaHealthy RangeDebt-to-EquityTotal Debt / Equity< 2.0 typicallyInterest CoverageEBIT / Interest Expense> 3.0 is healthy### Efficiency Ratios

[](#efficiency-ratios)

RatioFormulaInterpretationInventory TurnoverCOGS / Avg InventoryHigher = betterDSO365 / AR TurnoverLower = faster collectionCash Conversion CycleDIO + DSO - DPOLower = better---

Integration with Other Packages
-------------------------------

[](#integration-with-other-packages)

PackageIntegration`Nexus\FinancialStatements`Provides statement data for calculations`Nexus\Finance`Provides account balances`Nexus\AccountVarianceAnalysis`Ratio trend analysis`Nexus\Reporting`Ratio reports generation---

Related Documentation
---------------------

[](#related-documentation)

- [ARCHITECTURE.md](../../ARCHITECTURE.md) - Overall system architecture
- [CODING\_GUIDELINES.md](../../CODING_GUIDELINES.md) - Coding standards
- [Nexus Packages Reference](../../docs/NEXUS_PACKAGES_REFERENCE.md) - All available packages

---

License
-------

[](#license)

MIT License - See [LICENSE](LICENSE) for details.

###  Health Score

34

—

LowBetter than 75% of packages

Maintenance93

Actively maintained with recent releases

Popularity0

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity34

Early-stage or recently created project

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

36d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/117408?v=4)[Azahari Zaman](/maintainers/azaharizaman)[@azaharizaman](https://github.com/azaharizaman)

---

Top Contributors

[![azaharizaman](https://avatars.githubusercontent.com/u/117408?v=4)](https://github.com/azaharizaman "azaharizaman (5 commits)")

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/azaharizaman-nexus-financial-ratios/health.svg)

```
[![Health](https://phpackages.com/badges/azaharizaman-nexus-financial-ratios/health.svg)](https://phpackages.com/packages/azaharizaman-nexus-financial-ratios)
```

###  Alternatives

[lstrojny/functional-php

Functional primitives for PHP

2.0k7.5M50](/packages/lstrojny-functional-php)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)