@emasoft/svg-matrix 1.0.18 → 1.0.20

package/README.md

@@ -1,896 +1,393 @@
 # @emasoft/svg-matrix
 
-High-precision matrix, vector, and SVG transformation library for JavaScript. Built on decimal.js for 80-digit precision arithmetic.
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='600' height='80' viewBox='0 0 600 80'%3E%3Cdefs%3E%3ClinearGradient id='g' x1='0%25' y1='0%25' x2='100%25' y2='0%25'%3E%3Cstop offset='0%25' stop-color='%23e0e0e0'/%3E%3Cstop offset='50%25' stop-color='%23404040'/%3E%3Cstop offset='100%25' stop-color='%23e0e0e0'/%3E%3C/linearGradient%3E%3C/defs%3E%3Cg stroke='%23888' stroke-width='0.5' fill='none'%3E%3Ccircle cx='40' cy='40' r='25'/%3E%3Ccircle cx='40' cy='40' r='18'/%3E%3Cline x1='40' y1='15' x2='40' y2='65'/%3E%3Cline x1='15' y1='40' x2='65' y2='40'/%3E%3Cline x1='22' y1='22' x2='58' y2='58'/%3E%3Cline x1='58' y1='22' x2='22' y2='58'/%3E%3Crect x='100' y='20' width='40' height='40' transform='rotate(15 120 40)'/%3E%3Crect x='100' y='20' width='40' height='40' transform='rotate(30 120 40)'/%3E%3Crect x='100' y='20' width='40' height='40' transform='rotate(45 120 40)'/%3E%3Cpath d='M180 60 Q220 10 260 60' /%3E%3Ccircle cx='180' cy='60' r='3'/%3E%3Ccircle cx='220' cy='10' r='2'/%3E%3Ccircle cx='260' cy='60' r='3'/%3E%3Cline x1='180' y1='60' x2='220' y2='10' stroke-dasharray='4,2'/%3E%3Cline x1='220' y1='10' x2='260' y2='60' stroke-dasharray='4,2'/%3E%3Cpolygon points='320,15 360,40 320,65 340,40' /%3E%3Cline x1='320' y1='15' x2='360' y2='40'/%3E%3Cline x1='360' y1='40' x2='320' y2='65'/%3E%3Cpath d='M400 20 L440 20 L440 60 L400 60 Z M400 20 L440 60 M440 20 L400 60'/%3E%3Cg transform='translate(480 40)'%3E%3Ccircle r='25'/%3E%3Cpath d='M-25 0 A25 25 0 0 1 0 -25'/%3E%3Cpath d='M0 -25 A25 25 0 0 1 25 0'/%3E%3Cline x1='0' y1='-25' x2='0' y2='0'/%3E%3Cline x1='0' y1='0' x2='25' y2='0'/%3E%3Ctext x='-8' y='4' font-size='8' fill='%23666' font-family='monospace'%3E90%C2%B0%3C/text%3E%3C/g%3E%3Cline x1='540' y1='40' x2='600' y2='40'/%3E%3C/g%3E%3C/svg%3E" alt="Geometric precision illustration"/>
+</p>
+
+<p align="center">
+  <strong>Arbitrary-precision mathematics for vectors, matrices, and SVG transformations</strong><br/>
+  <em>80 significant digits. Mathematically verified. Zero floating-point errors.</em>
+</p>
+
+<p align="center">
+  <a href="#part-1-core-math-library">Core Math</a> &#8226;
+  <a href="#part-2-svg-toolbox">SVG Toolbox</a> &#8226;
+  <a href="#installation">Install</a> &#8226;
+  <a href="API.md">API Reference</a>
+</p>
 
-## Features
-
-**Linear Algebra**
-- Matrix and Vector classes with full linear algebra operations
-- LU/QR decomposition, determinant, inverse, solve, matrix exponential
-
-**Affine Transforms**
-- 2D (3x3 homogeneous): translation, rotation, scale, skew, reflection
-- 3D (4x4 homogeneous): translation, rotation (X/Y/Z/arbitrary axis), scale
-
-**SVG Processing**
-- Transform attribute parsing and CTM (Current Transform Matrix) building
-- viewBox, preserveAspectRatio, nested viewports, unit resolution
-- Shape-to-path conversion (circle, ellipse, rect, line, polygon, polyline)
-- Path parsing, normalization (absolute, cubics), transformation
-
-**SVG Element Resolution**
-- ClipPath flattening to polygons
-- Mask resolution (luminance and alpha)
-- Pattern tiling expansion
-- Use/symbol inlining with proper transforms
-- Marker positioning and orientation
-
-**Advanced**
-- Polygon boolean operations (intersection, union, difference, convex hull)
-- SVG 2.0 mesh gradient parsing and rasterization
-- Text-to-path conversion with font support
-- Browser verification against Chrome's native W3C SVG2 implementation
-
-## Requirements
-
-- **Node.js 24.0.0** or higher (ES modules, modern JavaScript features)
-- **Playwright** (optional) - for browser verification features
-
-## Precision
-
-| Scenario | Float Error | This Library | Improvement |
-|----------|-------------|--------------|-------------|
-| GIS/CAD coordinates (1e6+ scale) | 1.69e-7 | 0 | 10^93x |
-| 6-level SVG hierarchy | 1.14e-13 | 1e-77 | 10^64x |
-| 1000 round-trip transforms | 5.41e-14 | 0 | 10^86x |
-
-**When precision matters:** GIS, CAD, scientific visualization, deep transform hierarchies, accumulated operations.
-
-**When floats suffice:** Simple transforms, small coordinates, visual applications where sub-pixel errors are imperceptible.
-
-```bash
-node test/benchmark-precision.js
-```
-
-## Installation
-
-### Node.js (Local Installation)
-
-**What does "local installation" mean?** It means downloading the library to your computer so you can use it in your Node.js projects. This is what most developers do.
-
-#### Step 1: Install the package
-
-Open your terminal and run:
-
-```bash
-npm install @emasoft/svg-matrix
-```
-
-This downloads the library into a folder called `node_modules` in your project.
-
-#### Upgrading to the Latest Version
-
-To update to the latest version:
+---
 
-```bash
-npm update @emasoft/svg-matrix
-```
+## What Is This?
 
-Or to install a specific version:
+This package contains **two libraries** that work together:
 
-```bash
-npm install @emasoft/svg-matrix@latest
-```
+| Library | Purpose | Precision |
+|---------|---------|-----------|
+| **Core Math** | Vectors, matrices, 2D/3D transforms | 80 digits (configurable to 10^9) |
+| **SVG Toolbox** | Parse, transform, validate, optimize SVG files | 80 digits + visual verification |
 
-To check your current version:
+**Think of it like this:**
 
-```bash
-npm list @emasoft/svg-matrix
-```
+> **Core Math** is a calculator that never makes rounding errors.
+> **SVG Toolbox** uses that calculator to work with SVG graphics perfectly.
 
-#### Step 2: Create a JavaScript file
+---
 
-Create a new file called `example.js` in your project folder.
+<!-- Geometric divider: Golden ratio spiral construction -->
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='20' viewBox='0 0 400 20'%3E%3Cg stroke='%23ccc' stroke-width='0.5' fill='none'%3E%3Cline x1='0' y1='10' x2='120' y2='10'/%3E%3Crect x='125' y='5' width='10' height='10'/%3E%3Crect x='137' y='5' width='6.18' height='6.18'/%3E%3Crect x='145' y='5' width='3.82' height='3.82'/%3E%3Crect x='150' y='5' width='2.36' height='2.36'/%3E%3Cpath d='M160 10 Q170 3 180 10 Q190 17 200 10 Q210 3 220 10 Q230 17 240 10'/%3E%3Crect x='250' y='7' width='2.36' height='2.36'/%3E%3Crect x='254' y='5' width='3.82' height='3.82'/%3E%3Crect x='259' y='5' width='6.18' height='6.18'/%3E%3Crect x='267' y='5' width='10' height='10'/%3E%3Cline x1='280' y1='10' x2='400' y2='10'/%3E%3C/g%3E%3C/svg%3E" alt=""/>
+</p>
 
-#### Step 3: Import what you need
+# Part 1: Core Math Library
 
-There are two ways to import the library:
+**For:** Scientists, engineers, game developers, anyone who needs exact calculations.
 
-**Way 1: Pick only what you need (recommended)**
+## What Can It Do?
 
-This is like ordering specific items from a menu:
+Imagine you want to rotate a spaceship in a game, or calculate where two laser beams cross. Normal JavaScript math has tiny errors that add up. This library has **zero errors** because it uses 80-digit precision.
 
 ```js
-// example.js
-
-// Import only the modules you need
-import { Matrix, Vector, Transforms2D } from '@emasoft/svg-matrix';
-
-// Now you can use them directly
-const v = Vector.from([1, 2, 3]);
-const rotation = Transforms2D.rotate(Math.PI / 4);  // 45 degrees
-
-console.log('Vector:', v.toNumberArray());
-console.log('Rotation matrix created!');
+// Normal JavaScript: 0.1 + 0.2 = 0.30000000000000004 (wrong!)
+// svg-matrix:        0.1 + 0.2 = 0.3 (exactly right)
 ```
 
-**Way 2: Import everything at once**
+### Vectors (Arrows in Space)
 
-This is like getting the entire toolbox:
+A vector is like an arrow pointing somewhere. You can add arrows, measure them, find angles between them.
 
 ```js
-// example.js
-
-// Import EVERYTHING as one big object called "SVGMatrix"
-import * as SVGMatrix from '@emasoft/svg-matrix';
-
-// Now use SVGMatrix.ModuleName to access each tool
-const v = SVGMatrix.Vector.from([1, 2, 3]);
-const m = SVGMatrix.Matrix.identity(3);
-const rotation = SVGMatrix.Transforms2D.rotate(Math.PI / 4);
-const pathData = SVGMatrix.GeometryToPath.circleToPathData(100, 100, 50);
-
-// See everything that's available:
-console.log('Available modules:', Object.keys(SVGMatrix));
-```
+import { Vector } from '@emasoft/svg-matrix';
 
-**What's inside the toolbox?** When you import everything, you get:
-- `SVGMatrix.Matrix` - For matrix math
-- `SVGMatrix.Vector` - For vector math
-- `SVGMatrix.Transforms2D` - For 2D rotations, translations, scaling
-- `SVGMatrix.Transforms3D` - For 3D transformations
-- `SVGMatrix.SVGFlatten` - For flattening SVG transforms
-- `SVGMatrix.GeometryToPath` - For converting shapes to paths
-- `SVGMatrix.PolygonClip` - For polygon boolean operations
-- ...and many more!
+// Create an arrow pointing right 3 units and up 4 units
+const arrow = Vector.from([3, 4]);
 
-#### Step 4: Run your code
+// How long is the arrow? (It's 5 - like a 3-4-5 triangle!)
+console.log(arrow.norm().toString());  // "5"
 
-```bash
-node example.js
+// Make it exactly 1 unit long (normalize)
+const unit = arrow.normalize();
+console.log(unit.toNumberArray());  // [0.6, 0.8]
 ```
 
-#### Complete Working Example
+### Matrices (Grids of Numbers)
 
-Save this as `my-first-example.js`:
+A matrix is a grid of numbers. You can multiply them, flip them, use them to solve puzzles.
 
 ```js
-// my-first-example.js
-// A complete example showing the main features
-
-import {
-  Matrix,
-  Vector,
-  Transforms2D,
-  GeometryToPath,
-  SVGFlatten
-} from '@emasoft/svg-matrix';
-
-console.log('=== Vector Example ===');
-const v = Vector.from([1, 2, 3]);
-const w = Vector.from([4, 5, 6]);
-console.log('Vector v:', v.toNumberArray());
-console.log('Vector w:', w.toNumberArray());
-console.log('Dot product (v · w):', v.dot(w).toString());
-
-console.log('\n=== Matrix Example ===');
-const A = Matrix.from([[1, 2], [3, 4]]);
-console.log('Matrix A:', A.toNumberArray());
-console.log('Determinant:', A.determinant().toString());
-
-console.log('\n=== Transform Example ===');
-// Create a transform: move 100 right, rotate 45°, scale 2x
-const transform = Transforms2D.translation(100, 0)
-  .mul(Transforms2D.rotate(Math.PI / 4))
-  .mul(Transforms2D.scale(2));
-
-// Apply to a point
-const [x, y] = Transforms2D.applyTransform(transform, 10, 0);
-console.log(`Point (10, 0) after transform: (${x.toFixed(2)}, ${y.toFixed(2)})`);
-
-console.log('\n=== SVG Path Example ===');
-// Convert a circle to a path
-const circlePath = GeometryToPath.circleToPathData(0, 0, 50);
-console.log('Circle as path:', circlePath.substring(0, 50) + '...');
-
-console.log('\nDone! Everything works!');
-```
-
-Run it:
-```bash
-node my-first-example.js
-```
-
-#### Troubleshooting
+import { Matrix } from '@emasoft/svg-matrix';
 
-**"Cannot use import statement outside a module"**
+// Create a 2x2 grid
+const grid = Matrix.from([
+  [4, 7],
+  [2, 6]
+]);
 
-Add `"type": "module"` to your `package.json`:
+// Find the determinant (a special number about the grid)
+console.log(grid.determinant().toString());  // "10"
 
-```json
-{
-  "name": "my-project",
-  "type": "module"
-}
+// Solve a puzzle: find x and y where 4x + 7y = 1 and 2x + 6y = 0
+const answer = grid.solve([1, 0]);
+console.log(answer.toNumberArray());  // [0.6, -0.2]
 ```
 
-Or rename your file from `.js` to `.mjs`.
-
-**Using older Node.js syntax (require)?**
+### Transforms (Moving & Spinning Things)
 
-This library uses modern ES modules. If you have old code using `require()`:
+Transforms move, rotate, scale, or skew shapes. This is how video games move characters around!
 
 ```js
-// OLD WAY (doesn't work directly)
-// const { Matrix } = require('@emasoft/svg-matrix');  // ❌ Error!
-
-// NEW WAY (use dynamic import)
-async function main() {
-  const { Matrix, Vector } = await import('@emasoft/svg-matrix');
-
-  const v = Vector.from([1, 2, 3]);
-  console.log(v.norm().toString());
-}
-main();
-```
-
-### Browser Usage (CDN)
-
-You can use this library directly in a web browser without installing anything. Just add a `<script>` tag to your HTML file.
-
-**What is a CDN?** A CDN (Content Delivery Network) hosts the library files so you can load them directly in your browser. No `npm install` needed!
-
-#### Option 1: esm.sh (Recommended)
-
-Best for modern browsers. Automatically handles dependencies.
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <title>SVG Matrix Example</title>
-</head>
-<body>
-  <script type="module">
-    // Import the modules you need
-    import { Matrix, Vector, Transforms2D } from 'https://esm.sh/@emasoft/svg-matrix';
-
-    // Now you can use them!
-    const rotation = Transforms2D.rotate(Math.PI / 4);  // 45 degrees
-    const [x, y] = Transforms2D.applyTransform(rotation, 10, 0);
-
-    console.log(`Point (10, 0) rotated 45 degrees = (${x}, ${y})`);
-  </script>
-</body>
-</html>
-```
-
-#### Option 2: unpkg
-
-Another reliable CDN option.
-
-```html
-<script type="module">
-  import { SVGFlatten, GeometryToPath } from 'https://unpkg.com/@emasoft/svg-matrix/src/index.js';
-
-  // Convert a circle to a path
-  const pathData = GeometryToPath.circleToPathData(100, 100, 50);
-  console.log(pathData);
-</script>
-```
+import { Transforms2D } from '@emasoft/svg-matrix';
 
-#### Option 3: jsDelivr
+// Move something 100 pixels right
+const move = Transforms2D.translation(100, 0);
 
-Popular CDN with good caching.
+// Spin something 45 degrees
+const spin = Transforms2D.rotate(Math.PI / 4);
 
-```html
-<script type="module">
-  import { Matrix, Vector } from 'https://cdn.jsdelivr.net/npm/@emasoft/svg-matrix/src/index.js';
+// Make something twice as big
+const grow = Transforms2D.scale(2);
 
-  const v = Vector.from([1, 2, 3]);
-  const w = Vector.from([4, 5, 6]);
-  console.log('Dot product:', v.dot(w).toString());
-</script>
+// Apply spin to a point at (10, 0)
+const [x, y] = Transforms2D.applyTransform(spin, 10, 0);
+console.log(x.toFixed(4), y.toFixed(4));  // "7.0711 7.0711"
 ```
 
-#### Import Everything at Once
+---
 
-**What if I don't know what I need yet?** You can import the entire library as one big object. This is like getting the whole toolbox instead of picking individual tools.
+<!-- Geometric divider: Intersecting circles construction -->
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='20' viewBox='0 0 400 20'%3E%3Cg stroke='%23ccc' stroke-width='0.5' fill='none'%3E%3Cline x1='0' y1='10' x2='140' y2='10'/%3E%3Ccircle cx='170' cy='10' r='8'/%3E%3Ccircle cx='182' cy='10' r='8'/%3E%3Ccircle cx='200' cy='10' r='3'/%3E%3Ccircle cx='218' cy='10' r='8'/%3E%3Ccircle cx='230' cy='10' r='8'/%3E%3Cline x1='260' y1='10' x2='400' y2='10'/%3E%3C/g%3E%3C/svg%3E" alt=""/>
+</p>
 
-```html
-<script type="module">
-  // Import EVERYTHING as one object called "SVGMatrix"
-  // The "* as" means "everything as"
-  import * as SVGMatrix from 'https://esm.sh/@emasoft/svg-matrix';
-
-  // Now use SVGMatrix.ModuleName to access each tool
-  const v = SVGMatrix.Vector.from([1, 2, 3]);
-  const m = SVGMatrix.Matrix.identity(3);
-  const rotation = SVGMatrix.Transforms2D.rotate(Math.PI / 4);
-  const [x, y] = SVGMatrix.Transforms2D.applyTransform(rotation, 10, 0);
-
-  // See everything that's available:
-  console.log('All modules:', Object.keys(SVGMatrix));
-  // Output: ['Matrix', 'Vector', 'Transforms2D', 'Transforms3D', 'SVGFlatten', ...]
-</script>
-```
+## Core Math API Quick Reference
 
-**What's inside?** Here's everything you get:
+### Vector
 
-| Module | What it does |
+| Method | What It Does |
+|--------|--------------|
+| `Vector.from([x, y, z])` | Create a vector |
+| `.add(v)` | Add two vectors |
+| `.sub(v)` | Subtract vectors |
+| `.scale(n)` | Multiply by a number |
+| `.dot(v)` | Dot product (single number result) |
+| `.cross(v)` | Cross product (3D only) |
+| `.norm()` | Length of the vector |
+| `.normalize()` | Make length = 1 |
+| `.angleBetween(v)` | Angle between two vectors |
+| `.toNumberArray()` | Convert to regular JavaScript array |
+
+### Matrix
+
+| Method | What It Does |
+|--------|--------------|
+| `Matrix.from([[...], [...]])` | Create from 2D array |
+| `Matrix.identity(n)` | Identity matrix (1s on diagonal) |
+| `Matrix.zeros(r, c)` | Matrix of zeros |
+| `.mul(M)` | Multiply matrices |
+| `.transpose()` | Flip rows and columns |
+| `.determinant()` | Calculate determinant |
+| `.inverse()` | Calculate inverse |
+| `.solve(b)` | Solve system of equations |
+| `.lu()` | LU decomposition |
+| `.qr()` | QR decomposition |
+
+### Transforms2D / Transforms3D
+
+| Method | What It Does |
 |--------|--------------|
-| `SVGMatrix.Matrix` | Matrix math (multiply, inverse, determinant) |
-| `SVGMatrix.Vector` | Vector math (add, dot product, cross product) |
-| `SVGMatrix.Transforms2D` | 2D transforms (rotate, scale, translate) |
-| `SVGMatrix.Transforms3D` | 3D transforms (rotate around axes) |
-| `SVGMatrix.SVGFlatten` | Flatten SVG transforms into paths |
-| `SVGMatrix.GeometryToPath` | Convert shapes (circle, rect) to paths |
-| `SVGMatrix.PolygonClip` | Boolean operations on polygons |
-| `SVGMatrix.ClipPathResolver` | Resolve SVG clipPath elements |
-| `SVGMatrix.BrowserVerify` | Verify against browser's SVG engine |
-| `SVGMatrix.Logger` | Control library logging |
+| `translation(x, y)` | Move transform |
+| `scale(sx, sy)` | Size transform |
+| `rotate(angle)` | Spin transform (radians) |
+| `rotateAroundPoint(angle, px, py)` | Spin around a specific point |
+| `skew(ax, ay)` | Slant transform |
+| `reflectX()` / `reflectY()` | Mirror transform |
+| `applyTransform(M, x, y)` | Apply transform to a point |
 
-#### Pin to a Specific Version
+---
 
-To avoid breaking changes, pin to a specific version:
+<!-- Geometric divider: Bezier curve construction -->
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='30' viewBox='0 0 400 30'%3E%3Cg stroke='%23ccc' stroke-width='0.5' fill='none'%3E%3Cline x1='0' y1='15' x2='100' y2='15'/%3E%3Cpath d='M110 25 C130 5, 150 5, 170 15 S210 25, 230 15 S270 5, 290 15' stroke='%23999'/%3E%3Ccircle cx='110' cy='25' r='2' fill='%23999'/%3E%3Ccircle cx='170' cy='15' r='2' fill='%23999'/%3E%3Ccircle cx='230' cy='15' r='2' fill='%23999'/%3E%3Ccircle cx='290' cy='15' r='2' fill='%23999'/%3E%3Cline x1='110' y1='25' x2='130' y2='5' stroke-dasharray='2,2'/%3E%3Cline x1='150' y1='5' x2='170' y2='15' stroke-dasharray='2,2'/%3E%3Cline x1='300' y1='15' x2='400' y2='15'/%3E%3C/g%3E%3C/svg%3E" alt=""/>
+</p>
 
-```html
-<!-- esm.sh with version -->
-<script type="module">
-  import { Transforms2D } from 'https://esm.sh/@emasoft/svg-matrix@1.0.7';
-</script>
+# Part 2: SVG Toolbox
 
-<!-- unpkg with version -->
-<script type="module">
-  import { Matrix } from 'https://unpkg.com/@emasoft/svg-matrix@1.0.7/src/index.js';
-</script>
+**For:** Web developers, designers, anyone working with SVG graphics.
 
-<!-- jsDelivr with version -->
-<script type="module">
-  import { Vector } from 'https://cdn.jsdelivr.net/npm/@emasoft/svg-matrix@1.0.7/src/index.js';
-</script>
-```
+## What Can It Do?
 
-#### Complete Working Example
+SVG files are pictures made of shapes, paths, and effects. This toolbox can:
 
-Save this as `example.html` and open it in your browser:
+- **Flatten** - Bake all transforms into coordinates (no more `transform="rotate(45)"`)
+- **Convert** - Turn circles, rectangles into path commands
+- **Validate** - Find and fix problems in SVG files
+- **Optimize** - Remove unused elements, simplify paths
 
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <title>SVG Matrix - Complete Example</title>
-  <style>
-    body { font-family: sans-serif; padding: 20px; }
-    svg { border: 1px solid #ccc; }
-    pre { background: #f5f5f5; padding: 10px; }
-  </style>
-</head>
-<body>
-  <h1>SVG Matrix Demo</h1>
-
-  <h2>Original Circle</h2>
-  <svg width="200" height="200">
-    <circle id="original" cx="100" cy="100" r="40" fill="blue" opacity="0.5"/>
-  </svg>
-
-  <h2>Transformed (rotate 45 + scale 1.5)</h2>
-  <svg width="200" height="200">
-    <path id="transformed" fill="red" opacity="0.5"/>
-  </svg>
-
-  <h2>Generated Path Data</h2>
-  <pre id="output"></pre>
-
-  <script type="module">
-    import {
-      Transforms2D,
-      GeometryToPath,
-      SVGFlatten
-    } from 'https://esm.sh/@emasoft/svg-matrix';
-
-    // Step 1: Convert circle to path
-    const circlePath = GeometryToPath.circleToPathData(100, 100, 40);
-
-    // Step 2: Create a combined transform (rotate 45 degrees, then scale 1.5x)
-    const transform = Transforms2D.scale(1.5)
-      .mul(Transforms2D.rotate(Math.PI / 4));
-
-    // Step 3: Apply transform to the path
-    const transformedPath = SVGFlatten.transformPathData(circlePath, transform);
-
-    // Step 4: Display the result
-    document.getElementById('transformed').setAttribute('d', transformedPath);
-    document.getElementById('output').textContent = transformedPath;
-  </script>
-</body>
-</html>
-```
+### Why Use This Instead of SVGO?
 
-#### Troubleshooting
+| | SVGO | svg-matrix |
+|--|------|-----------|
+| **Math precision** | 15 digits (can accumulate errors) | 80 digits (no errors) |
+| **Verification** | None (hope it works) | Mathematical proof each step is correct |
+| **Attribute handling** | May lose clip-path, mask, filter | Guarantees ALL attributes preserved |
+| **Use case** | Quick file size reduction | Precision-critical applications |
 
-**"Cannot use import statement outside a module"**
-Make sure you have `type="module"` in your script tag:
-```html
-<script type="module">  <!-- This is required! -->
-```
+**Use svg-matrix when:** CAD, GIS, scientific visualization, or when visual correctness matters more than file size.
 
-**CORS errors when opening HTML file directly**
-Some browsers block CDN imports when opening files with `file://`. Solutions:
-1. Use a local server: `npx serve .` or `python -m http.server`
-2. Or use a code playground like CodePen, JSFiddle, or StackBlitz
+**Use SVGO when:** Quick optimization where small rounding errors are acceptable.
 
-**Want to use with older browsers?**
-This library requires ES modules (modern browsers). For IE11 or very old browsers, you'll need a bundler like Webpack or Rollup.
+---
 
-## CLI
+## Command Line Tools
 
-The library includes a command-line interface for batch processing SVG files.
+### `svg-matrix` - Process SVG files
 
 ```bash
-# Show help
-svg-matrix --help
-
-# Show command-specific help
-svg-matrix flatten --help
-
-# Show version
-svg-matrix --version
-
-# Process single file
+# Flatten all transforms into coordinates
 svg-matrix flatten input.svg -o output.svg
 
-# Batch process folder
-svg-matrix flatten ./svgs/ -o ./output/
-
-# Process files from list
-svg-matrix flatten --list files.txt -o ./output/
-
-# Convert shapes to paths
+# Convert shapes (circle, rect, etc.) to paths
 svg-matrix convert input.svg -o output.svg
 
-# Normalize paths to cubic Beziers
+# Normalize all paths to cubic Beziers
 svg-matrix normalize input.svg -o output.svg
 
-# Show SVG file info
+# Show file information
 svg-matrix info input.svg
 ```
 
-### CLI Options
+**Options:**
 
-| Option | Description |
-|--------|-------------|
-| `-o, --output <path>` | Output file or directory |
-| `-l, --list <file>` | Read input files from text file |
-| `-r, --recursive` | Process directories recursively |
-| `-p, --precision <n>` | Decimal precision (default: 6) |
-| `-f, --force` | Overwrite existing files |
-| `-n, --dry-run` | Show what would be done |
-| `-q, --quiet` | Suppress all output except errors |
-| `-v, --verbose` | Enable verbose/debug output |
-| `--log-file <path>` | Write log to file |
+| Option | What It Does |
+|--------|--------------|
+| `-o file.svg` | Output file |
+| `-r` | Process folders recursively |
+| `-f` | Overwrite existing files |
+| `-p N` | Decimal precision (default: 6, max: 50) |
+| `-q` | Quiet mode |
+| `-v` | Verbose mode |
+| `--transform-only` | Only flatten transforms (faster) |
+| `--no-clip-paths` | Skip clip-path processing |
+| `--no-masks` | Skip mask processing |
 
-### File List Format
+Run `svg-matrix --help` for all options.
 
-Create a text file with one path per line:
+### `svglinter` - Find problems in SVG files
 
+```bash
+svglinter myfile.svg           # Check one file
+svglinter icons/               # Check all SVGs in folder
+svglinter --fix icons/         # Auto-fix problems
+svglinter --errors-only icons/ # Only show errors
 ```
-# This is a comment
-./folder1/file1.svg
-./folder2/file2.svg
-./entire-folder/
-```
-
-## Quick Start
 
-```js
-import { Decimal, Matrix, Vector, Transforms2D, SVGFlatten } from '@emasoft/svg-matrix';
-
-Decimal.set({ precision: 80 });
-
-// Compose transforms (right-to-left: scale first, then rotate, then translate)
-const M = Transforms2D.translation(10, 20)
-  .mul(Transforms2D.rotate(Math.PI / 4))
-  .mul(Transforms2D.scale(2));
+Finds: broken references, invalid colors, typos in element names, missing attributes.
 
-// Apply to point
-const [x, y] = Transforms2D.applyTransform(M, 1, 0);
-
-// Round-trip with inverse
-const [xBack, yBack] = Transforms2D.applyTransform(M.inverse(), x, y);
-```
+See [full svglinter documentation](docs/SVGLINTER.md).
 
 ---
 
-## API Reference
-
-### Linear Algebra
+<!-- Geometric divider: Triangle construction -->
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='20' viewBox='0 0 400 20'%3E%3Cg stroke='%23ccc' stroke-width='0.5' fill='none'%3E%3Cline x1='0' y1='10' x2='150' y2='10'/%3E%3Cpolygon points='175,5 200,15 175,15'/%3E%3Cline x1='175' y1='5' x2='187.5' y2='10' stroke-dasharray='2,2'/%3E%3Cpolygon points='210,15 235,5 235,15'/%3E%3Cline x1='235' y1='5' x2='222.5' y2='10' stroke-dasharray='2,2'/%3E%3Cline x1='250' y1='10' x2='400' y2='10'/%3E%3C/g%3E%3C/svg%3E" alt=""/>
+</p>
 
-#### Vector
+## SVG Toolbox API Quick Reference
 
-```js
-import { Vector } from '@emasoft/svg-matrix';
-
-const v = Vector.from([1, 2, 3]);
-const w = Vector.from([4, 5, 6]);
-
-v.add(w)              // Element-wise addition
-v.sub(w)              // Element-wise subtraction
-v.scale(2)            // Scalar multiplication
-v.dot(w)              // Dot product → Decimal
-v.cross(w)            // Cross product (3D)
-v.norm()              // Euclidean length
-v.normalize()         // Unit vector
-v.angleBetween(w)     // Angle in radians
-v.projectOnto(w)      // Vector projection
-v.orthogonal()        // Perpendicular vector
-v.distance(w)         // Euclidean distance
-v.toNumberArray()     // [1, 2, 3]
-```
+### GeometryToPath
 
-#### Matrix
+Convert shapes to path data:
 
 ```js
-import { Matrix } from '@emasoft/svg-matrix';
-
-const A = Matrix.from([[1, 2], [3, 4]]);
-const I = Matrix.identity(3);
-const Z = Matrix.zeros(2, 3);
-
-A.add(B)              // Element-wise addition
-A.sub(B)              // Element-wise subtraction
-A.mul(B)              // Matrix multiplication
-A.transpose()         // Transpose
-A.trace()             // Sum of diagonal
-A.determinant()       // Determinant
-A.inverse()           // Matrix inverse
-A.solve([1, 1])       // Solve Ax = b
-A.lu()                // { L, U, P } decomposition
-A.qr()                // { Q, R } decomposition
-A.exp()               // Matrix exponential
-A.applyToVector(v)    // Matrix-vector product
-```
-
-### Transforms
-
-#### 2D (3x3 matrices)
-
-```js
-import { Transforms2D } from '@emasoft/svg-matrix';
-
-Transforms2D.translation(tx, ty)
-Transforms2D.scale(sx, sy)              // sy defaults to sx
-Transforms2D.rotate(theta)              // radians
-Transforms2D.rotateAroundPoint(theta, px, py)
-Transforms2D.skew(ax, ay)
-Transforms2D.stretchAlongAxis(ux, uy, k)
-Transforms2D.reflectX()                 // flip across X axis
-Transforms2D.reflectY()                 // flip across Y axis
-Transforms2D.reflectOrigin()
-
-// Apply to point
-const [x, y] = Transforms2D.applyTransform(matrix, px, py);
-```
-
-#### 3D (4x4 matrices)
+import { GeometryToPath } from '@emasoft/svg-matrix';
 
-```js
-import { Transforms3D } from '@emasoft/svg-matrix';
-
-Transforms3D.translation(tx, ty, tz)
-Transforms3D.scale(sx, sy, sz)
-Transforms3D.rotateX(theta)
-Transforms3D.rotateY(theta)
-Transforms3D.rotateZ(theta)
-Transforms3D.rotateAroundAxis(ux, uy, uz, theta)
-Transforms3D.rotateAroundPoint(ux, uy, uz, theta, px, py, pz)
-Transforms3D.reflectXY()                // flip Z
-Transforms3D.reflectXZ()                // flip Y
-Transforms3D.reflectYZ()                // flip X
-
-const [x, y, z] = Transforms3D.applyTransform(matrix, px, py, pz);
+const circle = GeometryToPath.circleToPathData(50, 50, 25);
+const rect = GeometryToPath.rectToPathData(0, 0, 100, 50, 5, 5);
+const ellipse = GeometryToPath.ellipseToPathData(50, 50, 30, 20);
 ```
 
-### SVG Processing
+### SVGFlatten
 
-#### SVGFlatten - Transform Parsing & CTM
+Parse and transform SVG data:
 
 ```js
 import { SVGFlatten } from '@emasoft/svg-matrix';
 
-// Parse transform attributes
-const m = SVGFlatten.parseTransformAttribute('translate(50,50) rotate(45) scale(2)');
-
-// Build CTM from transform stack
-const ctm = SVGFlatten.buildCTM([
-  'scale(1.5)',
-  'translate(-13.6, -10.2)',
-  'rotate(15)',
-  'matrix(0.716, 0, 0, 1.397, 0, 0)'
-]);
-
-// Apply to point
-const { x, y } = SVGFlatten.applyToPoint(ctm, 10, 10);
+// Parse transform string
+const matrix = SVGFlatten.parseTransformAttribute('rotate(45) scale(2)');
 
 // Transform path data
-const transformed = SVGFlatten.transformPathData('M 100 100 L 200 200', ctm);
-
-// viewBox handling
-const viewBox = SVGFlatten.parseViewBox('0 0 100 100');
-const par = SVGFlatten.parsePreserveAspectRatio('xMidYMid meet');
-const vbTransform = SVGFlatten.computeViewBoxTransform(viewBox, 800, 600, par);
-
-// Full CTM with viewBox + nested transforms
-const fullCtm = SVGFlatten.buildFullCTM([
-  { type: 'svg', width: 800, height: 600, viewBox: '0 0 400 300' },
-  { type: 'g', transform: 'translate(50, 50)' },
-  { type: 'g', transform: 'rotate(45)' },
-  { type: 'element', transform: 'scale(2)' }
-]);
-
-// Unit resolution (px, %, em, pt, in, cm, mm, pc)
-SVGFlatten.resolveLength('50%', 800);   // → 400
-SVGFlatten.resolveLength('1in', 800);   // → 96
-
-// objectBoundingBox transform
-const bboxTransform = SVGFlatten.objectBoundingBoxTransform(100, 50, 200, 100);
-```
-
-#### GeometryToPath - Shape Conversion
-
-```js
-import { GeometryToPath } from '@emasoft/svg-matrix';
-
-// Shape to path
-GeometryToPath.circleToPathData(cx, cy, r, precision)
-GeometryToPath.ellipseToPathData(cx, cy, rx, ry, precision)
-GeometryToPath.rectToPathData(x, y, w, h, rx, ry, useArcs, precision)
-GeometryToPath.lineToPathData(x1, y1, x2, y2, precision)
-GeometryToPath.polylineToPathData(points, precision)
-GeometryToPath.polygonToPathData(points, precision)
-GeometryToPath.convertElementToPath(element, precision)
-
-// Path manipulation
-GeometryToPath.parsePathData(pathData)          // → [{command, args}]
-GeometryToPath.pathArrayToString(commands)      // → path string
-GeometryToPath.pathToAbsolute(pathData)         // relative → absolute
-GeometryToPath.pathToCubics(pathData)           // all → cubic Beziers
-GeometryToPath.transformPathData(pathData, matrix, precision)
-
-// Bezier kappa constant: 4*(sqrt(2)-1)/3
-GeometryToPath.getKappa()
-```
-
-#### BrowserVerify - Chrome Verification
+const newPath = SVGFlatten.transformPathData('M 0 0 L 100 100', matrix);
 
-```js
-import { BrowserVerify } from '@emasoft/svg-matrix';
-
-// One-off verification
-await BrowserVerify.verifyViewBox(800, 600, '0 0 400 300', 'xMidYMid meet');
-await BrowserVerify.verifyTransform('rotate(45) translate(100, 50) scale(2)');
-
-// Session-based verification
-const verifier = new BrowserVerify.BrowserVerifier();
-await verifier.init({ headless: true });
-await verifier.verifyViewBoxTransform(800, 600, '0 0 100 100');
-await verifier.verifyMatrix(ctm, { width: 100, height: 100, transform: '...' });
-await verifier.verifyPointTransform(ctm, 10, 20, config);
-await verifier.close();
-
-// Standard test suite (28 tests including W3C issue #215 cases)
-await BrowserVerify.runStandardTests({ verbose: true });
+// Resolve CSS units
+SVGFlatten.resolveLength('50%', 800);  // 400
+SVGFlatten.resolveLength('1in', 96);   // 96
 ```
 
-### Polygon Operations
-
-#### PolygonClip
-
-```js
-import { PolygonClip } from '@emasoft/svg-matrix';
-
-const square = [
-  PolygonClip.point(0, 0),
-  PolygonClip.point(2, 0),
-  PolygonClip.point(2, 2),
-  PolygonClip.point(0, 2)
-];
-
-// Boolean operations
-PolygonClip.polygonIntersection(poly1, poly2)
-PolygonClip.polygonUnion(poly1, poly2)
-PolygonClip.polygonDifference(poly1, poly2)
-
-// Properties
-PolygonClip.polygonArea(polygon)
-PolygonClip.isCounterClockwise(polygon)
-PolygonClip.isConvex(polygon)
-PolygonClip.pointInPolygon(point, polygon)  // 1=inside, 0=boundary, -1=outside
-
-// Convex hull
-PolygonClip.convexHull(points)
-
-// Bounding box
-PolygonClip.boundingBox(polygon)  // {minX, minY, maxX, maxY}
-PolygonClip.bboxIntersects(bbox1, bbox2)
-```
+### Validation
 
-#### ClipPathResolver
+Find and fix problems:
 
 ```js
-import { ClipPathResolver } from '@emasoft/svg-matrix';
-
-// Parse and resolve clipPath
-const clipData = ClipPathResolver.parseClipPathElement(element);
-const clipPolygon = ClipPathResolver.resolveClipPath(clipData, targetBBox);
-
-// Shape to polygon
-ClipPathResolver.shapeToPolygon({ type: 'circle', cx: 100, cy: 100, r: 50 }, { samples: 32 })
-ClipPathResolver.pathToPolygon(pathData, { samples: 20 })
-ClipPathResolver.polygonToPathData(polygon)
-
-// Apply clipPath to element
-ClipPathResolver.applyClipPath(elementData, clipPathData, targetBBox)
-```
-
-### SVG Element Resolution
+import { validateSvg, fixInvalidSvg } from '@emasoft/svg-matrix';
 
-#### UseSymbolResolver
+const result = await validateSvg('icon.svg');
+console.log(result.valid);    // true/false
+console.log(result.issues);   // Array of problems
 
-```js
-import { UseSymbolResolver } from '@emasoft/svg-matrix';
-
-const useData = UseSymbolResolver.parseUseElement(useElement);
-const symbolData = UseSymbolResolver.parseSymbolElement(symbolElement);
-const resolved = UseSymbolResolver.resolveUse(useData, svgDocument);
-const flattened = UseSymbolResolver.flattenResolvedUse(resolved);
-UseSymbolResolver.resolveAllUses(svgDocument)
+const fixed = await fixInvalidSvg('broken.svg');
+console.log(fixed.svg);       // Fixed SVG string
 ```
 
-#### MarkerResolver
-
-```js
-import { MarkerResolver } from '@emasoft/svg-matrix';
-
-const markerData = MarkerResolver.parseMarkerElement(markerElement);
-const vertices = MarkerResolver.getPathVertices(pathData);
-const transform = MarkerResolver.getMarkerTransform(markerData, vertex, angle, strokeWidth);
-const instances = MarkerResolver.resolveMarkers(pathD, { 'marker-start': m1, 'marker-end': m2, strokeWidth: 2 });
-MarkerResolver.markersToPathData(instances)
-```
+### Exclusive Features (Not in SVGO)
 
-#### PatternResolver
+| Function | Description |
+|----------|-------------|
+| `flattenClipPaths()` | Flatten clip-paths to geometry |
+| `flattenMasks()` | Flatten masks to geometry |
+| `flattenGradients()` | Bake gradients into fills |
+| `flattenPatterns()` | Expand pattern tiles |
+| `flattenUseElements()` | Inline use/symbol references |
+| `textToPath()` | Convert text to path outlines |
+| `detectCollisions()` | GJK collision detection |
+| `validateSVG()` | W3C schema validation |
+| `decomposeTransform()` | Matrix decomposition |
 
-```js
-import { PatternResolver } from '@emasoft/svg-matrix';
+### Attribute Preservation
 
-const patternData = PatternResolver.parsePatternElement(patternElement);
-const tiles = PatternResolver.resolvePattern(patternData, targetBBox);
-PatternResolver.applyPattern(elementData, patternData, targetBBox)
-PatternResolver.patternToClipPath(patternData, targetBBox)
-PatternResolver.patternToPathData(patternData, targetBBox)
-```
+When converting shapes or flattening transforms, ALL attributes are preserved:
 
-#### MaskResolver
+| Category | Attributes |
+|----------|------------|
+| **Critical** | `clip-path`, `mask`, `filter`, `opacity` |
+| **Markers** | `marker-start`, `marker-mid`, `marker-end` |
+| **Paint** | `fill`, `stroke`, `fill-opacity`, `stroke-opacity` |
+| **Stroke** | `stroke-width`, `stroke-dasharray`, `stroke-linecap` |
+| **URL refs** | `url(#gradient)`, `url(#pattern)`, `url(#clip)` |
 
-```js
-import { MaskResolver } from '@emasoft/svg-matrix';
+> **Why this matters:** Many SVG tools silently drop `clip-path` and `mask` attributes, causing visual corruption. svg-matrix preserves everything.
 
-const maskData = MaskResolver.parseMaskElement(maskElement);
-const maskPolygon = MaskResolver.resolveMask(maskData, targetBBox);
-MaskResolver.applyMask(elementPolygon, maskData, targetBBox)
-MaskResolver.colorToLuminance({ r, g, b })  // sRGB luminance
-```
+---
 
-### Advanced Features
+<!-- Geometric divider: Angle construction -->
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='20' viewBox='0 0 400 20'%3E%3Cg stroke='%23ccc' stroke-width='0.5' fill='none'%3E%3Cline x1='0' y1='10' x2='160' y2='10'/%3E%3Cpath d='M180 15 L200 5 L220 15'/%3E%3Cpath d='M190 12 A7 7 0 0 1 195 8' stroke='%23999'/%3E%3Cline x1='240' y1='10' x2='400' y2='10'/%3E%3C/g%3E%3C/svg%3E" alt=""/>
+</p>
 
-#### MeshGradient (SVG 2.0)
+## Precision Comparison
 
-```js
-import { MeshGradient } from '@emasoft/svg-matrix';
+svg-matrix vs standard JavaScript (float64):
 
-// Parse mesh gradient
-const meshDef = MeshGradient.parseMeshGradientElement(element);
-const meshData = MeshGradient.parseMeshGradient(meshDef);
+| Operation | JS Error | svg-matrix Error | Improvement |
+|-----------|----------|------------------|-------------|
+| Point evaluation | `1.4e-14` | `0` (exact) | 14+ digits |
+| Bezier tangent | `1.1e-16` | `< 1e-78` | 62+ digits |
+| Arc length | `2.8e-13` | `< 1e-50` | 37+ digits |
+| Bounding box | `1.1e-13` | `0` (exact) | 13+ digits |
+| Self-intersection | Boolean only | `1.4e-58` | 58+ digits |
 
-// Coons patch evaluation
-const patch = new MeshGradient.CoonsPatch(topEdge, rightEdge, bottomEdge, leftEdge, cornerColors);
-const { point, color } = patch.evaluate(u, v);
+---
 
-// Rasterize to ImageData
-const imageData = MeshGradient.rasterizeMeshGradient(meshData, width, height);
+## Installation
 
-// Convert to polygons for vector export
-const polygons = MeshGradient.meshGradientToPolygons(meshData, { subdivisions: 16 });
+**Requires Node.js 24+** (released 2025)
 
-// Clip and export
-const clipped = MeshGradient.clipMeshGradient(meshData, clipPolygon, { subdivisions: 32 });
-const svgPaths = MeshGradient.clippedMeshToSVG(clipped);
+```bash
+npm install @emasoft/svg-matrix
 ```
 
-#### TextToPath
+### In JavaScript/TypeScript
 
 ```js
-import { TextToPath } from '@emasoft/svg-matrix';
-import opentype from 'opentype.js';
-
-const font = await opentype.load('font.ttf');
-
-// Convert text to path
-const pathData = TextToPath.textToPath("Hello", {
-  x: 100, y: 100,
-  fontSize: 24,
-  font: font,
-  textAnchor: TextToPath.TextAnchor.MIDDLE,
-  dominantBaseline: TextToPath.DominantBaseline.MIDDLE
-});
-
-// Parse text element
-const textData = TextToPath.parseTextElement(textElement);
-const result = TextToPath.textElementToPath(textData, { font });
-
-// Measure text
-const metrics = TextToPath.measureText("Hello", { fontSize: "20px" }, font);
-const bbox = TextToPath.getTextBBox(textData);
+import { Matrix, Vector, Transforms2D } from '@emasoft/svg-matrix';
 ```
 
-### Convenience Functions
-
-Direct exports for common operations:
-
-```js
-import {
-  // Transforms
-  translate2D, rotate2D, scale2D, transform2D,
-  translate3D, scale3D, transform3D,
-
-  // Shape conversion
-  circleToPath, ellipseToPath, rectToPath, lineToPath,
-  polygonToPath, polylineToPath,
-
-  // Path manipulation
-  parsePath, pathToString, pathToAbsolute, pathToCubics, transformPath,
-  elementToPath,
-
-  // Matrix/Vector creation
-  identity, zeros, vec, mat,
-
-  // Precision control
-  setPrecision, getPrecision,
+### In HTML (no install)
 
-  // Constants
-  getKappa
-} from '@emasoft/svg-matrix';
+```html
+<script type="module">
+  import { Matrix, Transforms2D } from 'https://esm.sh/@emasoft/svg-matrix';
+</script>
 ```
 
-### Logging
-
-Control library logging output:
-
-```js
-import { Logger, LogLevel, setLogLevel, enableFileLogging } from '@emasoft/svg-matrix';
+> **Note:** Node.js 24+ is required for modern ECMAScript features. If you need older Node support, please [open an issue](https://github.com/Emasoft/SVG-MATRIX/issues).
 
-// Suppress all logging
-setLogLevel(LogLevel.SILENT);
-
-// Enable only errors
-setLogLevel(LogLevel.ERROR);
-
-// Enable warnings and errors (default)
-setLogLevel(LogLevel.WARN);
+---
 
-// Enable all logging including debug
-setLogLevel(LogLevel.DEBUG);
+## More Documentation
 
-// Write logs to file
-enableFileLogging('/path/to/log.txt');
+- [Full API Reference](API.md)
+- [svglinter Documentation](docs/SVGLINTER.md)
+- [Bezier Analysis Examples](test/bezier-analysis-example.js)
+- [Path Analysis Examples](test/path-analysis-example.js)
 
-// Direct Logger access
-Logger.level = LogLevel.INFO;
-Logger.warn('Custom warning');
-Logger.debug('Debug info');
-```
+---
 
-## License
+<p align="center">
+  <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='200' height='30' viewBox='0 0 200 30'%3E%3Cg stroke='%23ddd' stroke-width='0.5' fill='none'%3E%3Cline x1='0' y1='15' x2='60' y2='15'/%3E%3Crect x='70' y='10' width='10' height='10' transform='rotate(45 75 15)'/%3E%3Ccircle cx='100' cy='15' r='5'/%3E%3Crect x='120' y='10' width='10' height='10' transform='rotate(45 125 15)'/%3E%3Cline x1='140' y1='15' x2='200' y2='15'/%3E%3C/g%3E%3C/svg%3E" alt=""/>
+</p>
 
-MIT
+<p align="center">
+  <strong>MIT License</strong><br/>
+  <em>Built with mathematical precision</em>
+</p>