@emasoft/svg-matrix 1.0.1

package/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js 24 (npm 11.6.2 with OIDC support)
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Install dependencies (for prepublishOnly script)
+        run: npm install --production=false
+
+      - name: Verify npm version (should be >= 11.5.1)
+        run: npm --version
+
+      - name: Publish to npm (using OIDC trusted publishing)
+        run: npm publish --access public

package/.github/workflows/release.yml

@@ -0,0 +1,37 @@
+name: Release and Publish to npm
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - 'v*.*.*'
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Create GitHub Release (if tag present)
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ github.ref_name }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: CI Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - name: Install
+        run: npm ci
+      - name: Run tests/examples
+        run: npm test

package/CLAUDE.md

@@ -0,0 +1,60 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+svg-matrix is an arbitrary-precision matrix, vector, and affine transformation library for JavaScript using decimal.js. It provides Decimal-backed Matrix and Vector classes along with 2D (3x3) and 3D (4x4) transform helpers for geometry operations requiring high precision.
+
+## Commands
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests (executes test/examples.js)
+npm test
+
+# CI test (clean install + test)
+npm run ci-test
+```
+
+## Architecture
+
+### Core Classes (src/)
+
+**Matrix** (`matrix.js`) - Decimal-backed matrix class with:
+- Factory methods: `Matrix.from()`, `Matrix.zeros()`, `Matrix.identity()`
+- Operations: `add()`, `sub()`, `mul()`, `transpose()`, `inverse()`, `clone()`
+- Linear algebra: `lu()` (LU decomposition), `qr()` (QR via Householder), `determinant()`, `solve()`, `exp()` (matrix exponential)
+- Vector application: `applyToVector()`
+
+**Vector** (`vector.js`) - Decimal-backed vector class with:
+- Basic ops: `add()`, `sub()`, `scale()`, `dot()`, `cross()`, `outer()`
+- Geometry: `norm()`, `normalize()`, `angleBetween()`, `projectOnto()`, `orthogonal()`
+- Conversion: `toArray()`, `toNumberArray()`, `toStringArray()`
+
+### Transform Helpers
+
+**Transforms2D** (`transforms2d.js`) - 3x3 affine matrices:
+- `translation(tx, ty)`, `scale(sx, sy)`, `rotate(theta)`, `rotateAroundPoint()`, `skew()`, `stretchAlongAxis()`
+- `applyTransform(M, x, y)` - applies matrix to 2D point with homogeneous division
+
+**Transforms3D** (`transforms3d.js`) - 4x4 affine matrices:
+- `translation(tx, ty, tz)`, `scale(sx, sy, sz)`, `rotateAroundAxis(ux, uy, uz, theta)`
+
+### Key Patterns
+
+All numeric inputs are converted to Decimal via the helper `const D = x => (x instanceof Decimal ? x : new Decimal(x))`. This allows passing numbers, strings, or Decimal instances.
+
+Transform composition uses right-to-left multiplication: `T.mul(R).mul(S)` applies S first, then R, then T.
+
+## Dependencies
+
+- **decimal.js** (^11.4.3) - Arbitrary-precision decimal arithmetic (runtime)
+- **@actions/oidc-client** - GitHub Actions OIDC for npm publishing (dev)
+- **node-fetch** - For npm token retrieval scripts (dev)
+
+## Publishing
+
+Releases are triggered by pushing version tags (`v*`). The publish workflow uses npm OIDC trusted publishing (Node 24 / npm 11.6+).

package/LICENSE

@@ -0,0 +1,8 @@
+MIT License
+
+Copyright (c) 2025 Emasoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction...
+(standard MIT text omitted here — include the full text in your repo)

package/README.md

@@ -0,0 +1,25 @@
+# SVG-MATRIX
+
+Arbitrary-precision matrix, vector and affine transformation library for JavaScript using decimal.js.
+
+This repository contains:
+- Decimal-backed Matrix and Vector classes.
+- 2D (3x3) and 3D (4x4) transform helpers.
+
+Install:
+```
+  npm install svg-matrix
+```
+
+Usage example:
+```js
+import { Decimal, Matrix, Vector, Transforms2D } from 'svg-matrix';
+Decimal.set({ precision: 80 });
+
+const M = Transforms2D.translation(2, 3).mul(Transforms2D.rotate(Math.PI/4)).mul(Transforms2D.scale(1.5));
+const p2 = Transforms2D.applyTransform(M, 1, 0);
+console.log('Transformed point:', p2.map(x => x.toString()));
+```
+
+See test/examples.js for more use cases.
+

package/SVG-MATRIX/README.md

@@ -0,0 +1,22 @@
+# SVG-MATRIX
+
+Arbitrary-precision matrix, vector and affine transformation library for JavaScript using decimal.js.
+
+This repository contains:
+- Decimal-backed Matrix and Vector classes.
+- 2D (3x3) and 3D (4x4) transform helpers.
+- Examples and GitHub Actions workflows:
+  - .github/workflows/test.yml  => runs tests/examples on push/PR
+  - .github/workflows/publish.yml => publishes to npm via OIDC trusted publishing on tag push
+
+Install
+  npm ci
+
+Usage example:
+```js
+import { Decimal, Matrix, Vector, Transforms2D } from 'svg-matrix';
+Decimal.set({ precision: 80 });
+
+const M = Transforms2D.translation(2, 3).mul(Transforms2D.rotate(Math.PI/4)).mul(Transforms2D.scale(1.5));
+const p2 = Transforms2D.applyTransform(M, 1, 0);
+console.log('Transformed point:', p2.map(x => x.toString()));

package/SVG-MATRIX/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "svg-matrix",
+  "version": "1.0.0",
+  "description": "Arbitrary-precision matrix, vector and affine transformation library for JavaScript using decimal.js",
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node test/examples.js",
+    "ci-test": "npm ci && npm test",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Emasoft/SVG-MATRIX.git"
+  },
+  "keywords": [
+    "matrix",
+    "vector",
+    "arbitrary-precision",
+    "decimal",
+    "linear-algebra",
+    "affine",
+    "transform",
+    "svg",
+    "geometry"
+  ],
+  "author": "Emasoft",
+  "license": "MIT",
+  "dependencies": {
+    "decimal.js": "^11.4.3"
+  },
+  "devDependencies": {}
+}

package/npm-shrinkwrap.json

@@ -0,0 +1,22 @@
+{
+  "name": "@emasoft/svg-matrix",
+  "version": "1.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@emasoft/svg-matrix",
+      "version": "1.0.1",
+      "license": "MIT",
+      "dependencies": {
+        "decimal.js": "^10.6.0"
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@emasoft/svg-matrix",
+  "version": "1.0.1",
+  "description": "Arbitrary-precision matrix, vector and affine transformation library for JavaScript using decimal.js",
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node test/examples.js",
+    "ci-test": "npm ci && npm test",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Emasoft/SVG-MATRIX.git"
+  },
+  "keywords": [
+    "matrix",
+    "vector",
+    "arbitrary-precision",
+    "decimal",
+    "linear-algebra",
+    "affine",
+    "transform",
+    "svg",
+    "geometry"
+  ],
+  "author": "Emasoft",
+  "license": "MIT",
+  "dependencies": {
+    "decimal.js": "^10.6.0"
+  }
+}

package/scripts/bootstrap_repo.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# bootstrap_repo.sh
+# Creates a new repository (owner/repo), populates it with SVG-MATRIX files,
+# commits and pushes initial branch, and optionally sets OIDC secrets.
+#
+# Requirements:
+#  - gh CLI authenticated (gh auth status)
+#  - git installed
+#  - node/npm not required to run script (only to run tests later)
+#
+# Usage:
+#   OWNER=Emasoft REPO=SVG-MATRIX ./bootstrap_repo.sh
+# Optional env vars:
+#   VISIBILITY (public|private) default: public
+#   BRANCH default: main
+#   NPM_OIDC_TOKEN_URL and NPM_OIDC_AUDIENCE - optional secrets to set in the repo (if provided they'll be added)
+
+OWNER="${OWNER:-Emasoft}"
+REPO="${REPO:-SVG-MATRIX}"
+VISIBILITY="${VISIBILITY:-public}"
+BRANCH="${BRANCH:-main}"
+DIR="${REPO}"
+
+echo "Bootstrap repo: ${OWNER}/${REPO} (visibility=${VISIBILITY}, branch=${BRANCH})"
+
+# check prerequisites
+if ! command -v gh >/dev/null 2>&1; then
+  echo "gh CLI not found. Install and authenticate (gh auth login) and try again."
+  exit 1
+fi
+if ! command -v git >/dev/null 2>&1; then
+  echo "git not found. Please install git and try again."
+  exit 1
+fi
+
+# check gh auth
+if ! gh auth status >/dev/null 2>&1; then
+  echo "gh CLI not authenticated. Run: gh auth login"
+  gh auth status || true
+  exit 1
+fi
+
+# create local dir (safe)
+if [ -d "${DIR}" ]; then
+  echo "Directory ${DIR} already exists. Please remove or move it and re-run, or run in a different location."
+  exit 1
+fi
+
+mkdir "${DIR}"
+cd "${DIR}"
+
+# create files (each file is written with a here-doc)
+mkdir -p src test .github/workflows scripts
+
+cat > .gitignore <<'EOF'
+node_modules
+dist
+.DS_Store
+.env
+EOF
+
+cat > package.json <<'EOF'
+{
+  "name": "svg-matrix",
+  "version": "1.0.0",
+  "description": "Arbitrary-precision matrix, vector and affine transformation library for JavaScript using decimal.js",
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node test/examples.js",
+    "ci-test": "npm ci && npm test",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Emasoft/SVG-MATRIX.git"
+  },
+  "keywords": [
+    "matrix",
+    "vector",
+    "arbitrary-precision",
+    "decimal",
+    "linear-algebra",
+    "affine",
+    "transform",
+    "svg",
+    "geometry"
+  ],
+  "author": "Emasoft",
+  "license": "MIT",
+  "dependencies": {
+    "decimal.js": "^11.4.3"
+  },
+  "devDependencies": {}
+}
+EOF
+

package/src/index.js

@@ -0,0 +1,7 @@
+import Decimal from 'decimal.js';
+import { Matrix } from './matrix.js';
+import { Vector } from './vector.js';
+import * as Transforms2D from './transforms2d.js';
+import * as Transforms3D from './transforms3d.js';
+
+export { Decimal, Matrix, Vector, Transforms2D, Transforms3D };

package/src/matrix.js

@@ -0,0 +1,293 @@
+import Decimal from 'decimal.js';
+import { Vector } from './vector.js';
+const D = x => (x instanceof Decimal ? x : new Decimal(x));
+
+/**
+ * Matrix - Decimal-backed matrix class
+ */
+export class Matrix {
+  constructor(data) {
+    if (!Array.isArray(data) || data.length === 0) throw new Error('Matrix requires non-empty 2D array');
+    const cols = data[0].length;
+    for (const row of data) {
+      if (!Array.isArray(row) || row.length !== cols) throw new Error('All rows must have same length');
+    }
+    this.data = data.map(r => r.map(v => D(v)));
+    this.rows = data.length;
+    this.cols = cols;
+  }
+
+  static from(arr) {
+    return new Matrix(arr);
+  }
+
+  static zeros(r, c) {
+    const out = Array.from({ length: r }, () => Array.from({ length: c }, () => new Decimal(0)));
+    return new Matrix(out);
+  }
+
+  static identity(n) {
+    const out = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (i === j ? new Decimal(1) : new Decimal(0))));
+    return new Matrix(out);
+  }
+
+  clone() {
+    return new Matrix(this.data.map(r => r.map(v => new Decimal(v))));
+  }
+
+  toArrayOfStrings() {
+    return this.data.map(r => r.map(v => v.toString()));
+  }
+
+  // apply matrix to Vector or array: returns Vector
+  applyToVector(vec) {
+    let v;
+    if (vec instanceof Vector) v = vec;
+    else if (Array.isArray(vec)) v = Vector.from(vec);
+    else throw new Error('applyToVector expects Vector or array');
+    if (this.cols !== v.length) throw new Error('shape mismatch');
+    const out = [];
+    for (let i = 0; i < this.rows; i++) {
+      let sum = new Decimal(0);
+      for (let j = 0; j < this.cols; j++) sum = sum.plus(this.data[i][j].mul(v.data[j]));
+      out.push(sum);
+    }
+    return new Vector(out);
+  }
+
+  // elementwise add/sub or scalar
+  add(other) {
+    if (other instanceof Matrix) {
+      if (this.rows !== other.rows || this.cols !== other.cols) throw new Error('shape mismatch');
+      return new Matrix(this.data.map((r, i) => r.map((v, j) => v.plus(other.data[i][j]))));
+    } else {
+      const s = D(other);
+      return new Matrix(this.data.map(r => r.map(v => v.plus(s))));
+    }
+  }
+
+  sub(other) {
+    if (other instanceof Matrix) {
+      if (this.rows !== other.rows || this.cols !== other.cols) throw new Error('shape mismatch');
+      return new Matrix(this.data.map((r, i) => r.map((v, j) => v.minus(other.data[i][j]))));
+    } else {
+      const s = D(other);
+      return new Matrix(this.data.map(r => r.map(v => v.minus(s))));
+    }
+  }
+
+  mul(other) {
+    if (other instanceof Matrix) {
+      if (this.cols !== other.rows) throw new Error('shape mismatch');
+      const out = Array.from({ length: this.rows }, () => Array.from({ length: other.cols }, () => new Decimal(0)));
+      for (let i = 0; i < this.rows; i++) {
+        for (let k = 0; k < this.cols; k++) {
+          const aik = this.data[i][k];
+          if (aik.isZero()) continue;
+          for (let j = 0; j < other.cols; j++) out[i][j] = out[i][j].plus(aik.mul(other.data[k][j]));
+        }
+      }
+      return new Matrix(out);
+    } else {
+      const s = D(other);
+      return new Matrix(this.data.map(r => r.map(v => v.mul(s))));
+    }
+  }
+
+  transpose() {
+    const out = Array.from({ length: this.cols }, (_, i) => Array.from({ length: this.rows }, (_, j) => new Decimal(this.data[j][i])));
+    return new Matrix(out);
+  }
+
+  // LU decomposition (returns {L, U, P})
+  lu() {
+    if (this.rows !== this.cols) throw new Error('LU requires square');
+    const n = this.rows;
+    const A = this.clone().data.map(r => r.map(v => new Decimal(v)));
+    const Pvec = Array.from({ length: n }, (_, i) => i);
+    const L = Array.from({ length: n }, () => Array.from({ length: n }, () => new Decimal(0)));
+    for (let i = 0; i < n; i++) L[i][i] = new Decimal(1);
+
+    for (let k = 0; k < n; k++) {
+      let pivot = k;
+      let maxAbs = A[k][k].abs();
+      for (let i = k + 1; i < n; i++) {
+        const aabs = A[i][k].abs();
+        if (aabs.greaterThan(maxAbs)) { maxAbs = aabs; pivot = i; }
+      }
+      if (A[pivot][k].isZero()) throw new Error('Singular matrix in LU');
+      if (pivot !== k) {
+        const tmp = A[k]; A[k] = A[pivot]; A[pivot] = tmp;
+        const tmpIdx = Pvec[k]; Pvec[k] = Pvec[pivot]; Pvec[pivot] = tmpIdx;
+        for (let j = 0; j < k; j++) {
+          const t = L[k][j]; L[k][j] = L[pivot][j]; L[pivot][j] = t;
+        }
+      }
+      for (let i = k + 1; i < n; i++) {
+        const factor = A[i][k].div(A[k][k]);
+        L[i][k] = factor;
+        for (let j = k; j < n; j++) A[i][j] = A[i][j].minus(factor.mul(A[k][j]));
+      }
+    }
+
+    const U = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (j < i ? new Decimal(0) : A[i][j])));
+    const P = Matrix.zeros(n, n);
+    for (let i = 0; i < n; i++) P.data[i][Pvec[i]] = new Decimal(1);
+    return { L: new Matrix(L), U: new Matrix(U), P: P };
+  }
+
+  determinant() {
+    if (this.rows !== this.cols) throw new Error('Determinant only for square');
+    const n = this.rows;
+    const { L, U, P } = this.lu();
+    let det = new Decimal(1);
+    for (let i = 0; i < n; i++) det = det.mul(U.data[i][i]);
+    // permutation sign
+    const perm = [];
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) if (P.data[i][j].equals(1)) perm.push(j);
+    }
+    let inv = 0;
+    for (let i = 0; i < perm.length; i++) for (let j = i + 1; j < perm.length; j++) if (perm[i] > perm[j]) inv++;
+    if (inv % 2 === 1) det = det.negated();
+    return det;
+  }
+
+  inverse() {
+    if (this.rows !== this.cols) throw new Error('Inverse only for square');
+    const n = this.rows;
+    const aug = Array.from({ length: n }, (_, i) => Array.from({ length: 2 * n }, (_, j) => (j < n ? new Decimal(this.data[i][j]) : (j - n === i ? new Decimal(1) : new Decimal(0)))));
+    for (let col = 0; col < n; col++) {
+      let pivot = col;
+      let maxAbs = aug[col][col].abs();
+      for (let r = col + 1; r < n; r++) {
+        const aabs = aug[r][col].abs();
+        if (aabs.greaterThan(maxAbs)) { maxAbs = aabs; pivot = r; }
+      }
+      if (aug[pivot][col].isZero()) throw new Error('Singular matrix');
+      if (pivot !== col) {
+        const tmp = aug[col]; aug[col] = aug[pivot]; aug[pivot] = tmp;
+      }
+      const pivval = aug[col][col];
+      for (let j = 0; j < 2 * n; j++) aug[col][j] = aug[col][j].div(pivval);
+      for (let r = 0; r < n; r++) {
+        if (r === col) continue;
+        const factor = aug[r][col];
+        if (factor.isZero()) continue;
+        for (let j = 0; j < 2 * n; j++) aug[r][j] = aug[r][j].minus(factor.mul(aug[col][j]));
+      }
+    }
+    const inv = aug.map(row => row.slice(n));
+    return new Matrix(inv);
+  }
+
+  // solve Ax = b where b is Vector or array; returns Vector
+  solve(b) {
+    let B;
+    if (b instanceof Vector) B = b;
+    else if (Array.isArray(b)) B = Vector.from(b);
+    else throw new Error('b must be Vector or array');
+    if (this.rows !== this.cols) throw new Error('Solve only implemented for square A');
+    const n = this.rows;
+    if (B.length !== n) throw new Error('dimension mismatch');
+    // convert to augmented array
+    const aug = Array.from({ length: n }, (_, i) => Array.from({ length: n + 1 }, (_, j) => new Decimal(j < n ? this.data[i][j] : B.data[i])));
+    // forward elimination
+    for (let col = 0; col < n; col++) {
+      let pivot = col;
+      let maxAbs = aug[col][col].abs();
+      for (let r = col + 1; r < n; r++) {
+        const aabs = aug[r][col].abs();
+        if (aabs.greaterThan(maxAbs)) { maxAbs = aabs; pivot = r; }
+      }
+      if (aug[pivot][col].isZero()) throw new Error('Singular or no unique solution');
+      if (pivot !== col) { const tmp = aug[col]; aug[col] = aug[pivot]; aug[pivot] = tmp; }
+      for (let r = col + 1; r < n; r++) {
+        const factor = aug[r][col].div(aug[col][col]);
+        if (factor.isZero()) continue;
+        for (let j = col; j < n + 1; j++) aug[r][j] = aug[r][j].minus(factor.mul(aug[col][j]));
+      }
+    }
+    // back substitution
+    const x = Array.from({ length: n }, () => new Decimal(0));
+    for (let i = n - 1; i >= 0; i--) {
+      let sum = new Decimal(0);
+      for (let j = i + 1; j < n; j++) sum = sum.plus(aug[i][j].mul(x[j]));
+      x[i] = aug[i][n].minus(sum).div(aug[i][i]);
+    }
+    return new Vector(x);
+  }
+
+  // QR via Householder (returns {Q, R})
+  qr() {
+    const m = this.rows, n = this.cols;
+    let A = this.clone().data.map(r => r.map(v => new Decimal(v)));
+    const Q = Matrix.identity(m).data;
+    for (let k = 0; k < Math.min(m, n); k++) {
+      const x = [];
+      for (let i = k; i < m; i++) x.push(A[i][k]);
+      let normx = new Decimal(0);
+      for (const xi of x) normx = normx.plus(xi.mul(xi));
+      normx = normx.sqrt();
+      if (normx.isZero()) continue;
+      const sign = x[0].isNegative() ? new Decimal(-1) : new Decimal(1);
+      const v = x.slice();
+      v[0] = v[0].plus(sign.mul(normx));
+      let vnorm = new Decimal(0);
+      for (const vi of v) vnorm = vnorm.plus(vi.mul(vi));
+      vnorm = vnorm.sqrt();
+      if (vnorm.isZero()) continue;
+      for (let i = 0; i < v.length; i++) v[i] = v[i].div(vnorm);
+      for (let j = k; j < n; j++) {
+        let dot = new Decimal(0);
+        for (let i = 0; i < v.length; i++) dot = dot.plus(v[i].mul(A[k + i][j]));
+        for (let i = 0; i < v.length; i++) A[k + i][j] = A[k + i][j].minus(new Decimal(2).mul(v[i]).mul(dot));
+      }
+      for (let j = 0; j < m; j++) {
+        let dot = new Decimal(0);
+        for (let i = 0; i < v.length; i++) dot = dot.plus(v[i].mul(Q[k + i][j]));
+        for (let i = 0; i < v.length; i++) Q[k + i][j] = Q[k + i][j].minus(new Decimal(2).mul(v[i]).mul(dot));
+      }
+    }
+    const R = Array.from({ length: m }, (_, i) => Array.from({ length: n }, (_, j) => (i <= j ? A[i][j] : new Decimal(0))));
+    return { Q: new Matrix(Q).transpose(), R: new Matrix(R) };
+  }
+
+  // simple matrix exponential via Taylor + scaling & squaring (practical default)
+  exp(options = {}) {
+    const n = this.rows;
+    if (n !== this.cols) throw new Error('exp requires square matrix');
+    const ident = Matrix.identity(n);
+    const normInf = (M) => {
+      let max = new Decimal(0);
+      for (let i = 0; i < M.rows; i++) {
+        let rowSum = new Decimal(0);
+        for (let j = 0; j < M.cols; j++) rowSum = rowSum.plus(M.data[i][j].abs());
+        if (rowSum.greaterThan(max)) max = rowSum;
+      }
+      return max;
+    };
+    const maxNorm = normInf(this);
+    let s = 0;
+    if (maxNorm.greaterThan(new Decimal(1))) {
+      const ratio = maxNorm.div(new Decimal(1));
+      s = Math.max(0, Math.ceil(Math.log2(ratio.toNumber())));
+    }
+    let A = this;
+    if (s > 0) A = this.mul(new Decimal(1).div(new Decimal(2).pow(s)));
+    const maxIter = options.maxIter || 120;
+    const tol = new Decimal(options.tolerance || '1e-40');
+    let term = ident.clone();
+    let result = ident.clone();
+    for (let k = 1; k < maxIter; k++) {
+      term = term.mul(A).mul(new Decimal(1).div(k));
+      result = result.add(term);
+      // smallness check
+      let tnorm = new Decimal(0);
+      for (let i = 0; i < term.rows; i++) for (let j = 0; j < term.cols; j++) tnorm = tnorm.plus(term.data[i][j].abs());
+      if (tnorm.lessThan(tol)) break;
+    }
+    for (let i = 0; i < s; i++) result = result.mul(result);
+    return result;
+  }
+}

package/src/transforms2d.js

@@ -0,0 +1,65 @@
+import Decimal from 'decimal.js';
+import { Matrix } from './matrix.js';
+const D = x => (x instanceof Decimal ? x : new Decimal(x));
+
+export function translation(tx, ty) {
+  return Matrix.from([
+    [new Decimal(1), new Decimal(0), D(tx)],
+    [new Decimal(0), new Decimal(1), D(ty)],
+    [new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+export function scale(sx, sy = null) {
+  if (sy === null) sy = sx;
+  return Matrix.from([
+    [D(sx), new Decimal(0), new Decimal(0)],
+    [new Decimal(0), D(sy), new Decimal(0)],
+    [new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+export function rotate(theta) {
+  const t = D(theta);
+  const c = new Decimal(Math.cos(t.toNumber()));
+  const s = new Decimal(Math.sin(t.toNumber()));
+  return Matrix.from([
+    [c, s.negated(), new Decimal(0)],
+    [s, c, new Decimal(0)],
+    [new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+export function rotateAroundPoint(theta, px, py) {
+  return translation(px, py).mul(rotate(theta)).mul(translation(new Decimal(px).neg(), new Decimal(py).neg()));
+}
+
+export function skew(ax, ay) {
+  return Matrix.from([
+    [new Decimal(1), D(ax), new Decimal(0)],
+    [D(ay), new Decimal(1), new Decimal(0)],
+    [new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+export function stretchAlongAxis(ux, uy, k) {
+  const uxD = D(ux), uyD = D(uy), kD = D(k);
+  const one = new Decimal(1);
+  const factor = kD.minus(one);
+  const m00 = one.plus(factor.mul(uxD.mul(uxD)));
+  const m01 = factor.mul(uxD.mul(uyD));
+  const m10 = factor.mul(uyD.mul(uxD));
+  const m11 = one.plus(factor.mul(uyD.mul(uyD)));
+  return Matrix.from([
+    [m00, m01, new Decimal(0)],
+    [m10, m11, new Decimal(0)],
+    [new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+export function applyTransform(M, x, y) {
+  const P = Matrix.from([[D(x)], [D(y)], [new Decimal(1)]]);
+  const R = M.mul(P);
+  const rx = R.data[0][0], ry = R.data[1][0], rw = R.data[2][0];
+  return [rx.div(rw), ry.div(rw)];
+}

package/src/transforms3d.js

@@ -0,0 +1,51 @@
+import Decimal from 'decimal.js';
+import { Matrix } from './matrix.js';
+const D = x => (x instanceof Decimal ? x : new Decimal(x));
+
+export function translation(tx, ty, tz) {
+  return Matrix.from([
+    [new Decimal(1), new Decimal(0), new Decimal(0), D(tx)],
+    [new Decimal(0), new Decimal(1), new Decimal(0), D(ty)],
+    [new Decimal(0), new Decimal(0), new Decimal(1), D(tz)],
+    [new Decimal(0), new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+export function scale(sx, sy = null, sz = null) {
+  if (sy === null) sy = sx;
+  if (sz === null) sz = sx;
+  return Matrix.from([
+    [D(sx), new Decimal(0), new Decimal(0), new Decimal(0)],
+    [new Decimal(0), D(sy), new Decimal(0), new Decimal(0)],
+    [new Decimal(0), new Decimal(0), D(sz), new Decimal(0)],
+    [new Decimal(0), new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}
+
+// rotation around arbitrary axis (ux,uy,uz) through origin by angle theta (radians)
+export function rotateAroundAxis(ux, uy, uz, theta) {
+  const u = [D(ux), D(uy), D(uz)];
+  let norm = u[0].mul(u[0]).plus(u[1].mul(u[1])).plus(u[2].mul(u[2])).sqrt();
+  if (norm.isZero()) throw new Error('Rotation axis cannot be zero');
+  u[0] = u[0].div(norm); u[1] = u[1].div(norm); u[2] = u[2].div(norm);
+  const t = D(theta);
+  const c = new Decimal(Math.cos(t.toNumber()));
+  const s = new Decimal(Math.sin(t.toNumber()));
+  const one = new Decimal(1);
+  const ux2 = u[0].mul(u[0]), uy2 = u[1].mul(u[1]), uz2 = u[2].mul(u[2]);
+  const m00 = ux2.plus(c.mul(one.minus(ux2)));
+  const m01 = u[0].mul(u[1]).mul(one.minus(c)).minus(u[2].mul(s));
+  const m02 = u[0].mul(u[2]).mul(one.minus(c)).plus(u[1].mul(s));
+  const m10 = u[1].mul(u[0]).mul(one.minus(c)).plus(u[2].mul(s));
+  const m11 = uy2.plus(c.mul(one.minus(uy2)));
+  const m12 = u[1].mul(u[2]).mul(one.minus(c)).minus(u[0].mul(s));
+  const m20 = u[2].mul(u[0]).mul(one.minus(c)).minus(u[1].mul(s));
+  const m21 = u[2].mul(u[1]).mul(one.minus(c)).plus(u[0].mul(s));
+  const m22 = uz2.plus(c.mul(one.minus(uz2)));
+  return Matrix.from([
+    [m00, m01, m02, new Decimal(0)],
+    [m10, m11, m12, new Decimal(0)],
+    [m20, m21, m22, new Decimal(0)],
+    [new Decimal(0), new Decimal(0), new Decimal(0), new Decimal(1)]
+  ]);
+}

package/src/vector.js

@@ -0,0 +1,140 @@
+import Decimal from 'decimal.js';
+const D = x => (x instanceof Decimal ? x : new Decimal(x));
+
+export class Vector {
+  constructor(components) {
+    if (!Array.isArray(components)) throw new Error('Vector requires array');
+    this.data = components.map(c => D(c));
+    this.length = this.data.length;
+  }
+
+  static from(arr) {
+    return new Vector(arr);
+  }
+
+  clone() {
+    return new Vector(this.data.map(v => new Decimal(v)));
+  }
+
+  toArray() {
+    return this.data.map(v => v);
+  }
+
+  toNumberArray() {
+    return this.data.map(v => v.toNumber());
+  }
+
+  toStringArray() {
+    return this.data.map(v => v.toString());
+  }
+
+  // elementwise add/sub
+  add(other) {
+    if (!(other instanceof Vector)) throw new Error('add expects Vector');
+    if (other.length !== this.length) throw new Error('shape mismatch');
+    return new Vector(this.data.map((v, i) => v.plus(other.data[i])));
+  }
+
+  sub(other) {
+    if (!(other instanceof Vector)) throw new Error('sub expects Vector');
+    if (other.length !== this.length) throw new Error('shape mismatch');
+    return new Vector(this.data.map((v, i) => v.minus(other.data[i])));
+  }
+
+  // scalar multiplication
+  scale(scalar) {
+    const s = D(scalar);
+    return new Vector(this.data.map(v => v.mul(s)));
+  }
+
+  // dot product
+  dot(other) {
+    if (!(other instanceof Vector)) throw new Error('dot expects Vector');
+    if (other.length !== this.length) throw new Error('shape mismatch');
+    return this.data.reduce((acc, v, i) => acc.plus(v.mul(other.data[i])), new Decimal(0));
+  }
+
+  // outer / tensor product returns Matrix-like 2D array (Decimal)
+  outer(other) {
+    if (!(other instanceof Vector)) throw new Error('outer expects Vector');
+    const rows = this.length, cols = other.length;
+    const out = Array.from({ length: rows }, (_, i) =>
+      Array.from({ length: cols }, (_, j) => this.data[i].mul(other.data[j]))
+    );
+    return out;
+  }
+
+  // cross product for 3D vectors
+  cross(other) {
+    if (this.length !== 3 || other.length !== 3) throw new Error('cross requires 3D vectors');
+    const [a1, a2, a3] = this.data;
+    const [b1, b2, b3] = other.data;
+    return new Vector([
+      a2.mul(b3).minus(a3.mul(b2)),
+      a3.mul(b1).minus(a1.mul(b3)),
+      a1.mul(b2).minus(a2.mul(b1))
+    ]);
+  }
+
+  // norm (Euclidean)
+  norm() {
+    let sum = new Decimal(0);
+    for (const v of this.data) sum = sum.plus(v.mul(v));
+    return sum.sqrt();
+  }
+
+  // normalize: returns a new Vector
+  normalize() {
+    const n = this.norm();
+    if (n.isZero()) throw new Error('Cannot normalize zero vector');
+    return this.scale(new Decimal(1).div(n));
+  }
+
+  // angle between vectors (radians)
+  angleBetween(other) {
+    const dot = this.dot(other);
+    const n1 = this.norm();
+    const n2 = other.norm();
+    if (n1.isZero() || n2.isZero()) throw new Error('Angle with zero vector undefined');
+    // clamp cosine to [-1,1] for numerical safety
+    let cosv = dot.div(n1.mul(n2));
+    // toNumber clamping fallback:
+    const cosNum = cosv.toNumber();
+    const clamped = Math.min(1, Math.max(-1, cosNum));
+    return new Decimal(Math.acos(clamped));
+  }
+
+  // projection of this onto other (vector)
+  projectOnto(other) {
+    const denom = other.dot(other);
+    if (denom.isZero()) throw new Error('Cannot project onto zero vector');
+    const coef = this.dot(other).div(denom);
+    return other.scale(coef);
+  }
+
+  // compute an orthogonal vector (for 2D returns perpendicular; for higher dims returns Gram-Schmidt complement)
+  orthogonal() {
+    if (this.length === 2) {
+      // perp: [-y, x]
+      return new Vector([this.data[1].negated(), this.data[0]]);
+    }
+    // for n>2: find a vector not colinear with this and make orthogonal via Gram-Schmidt with standard basis
+    for (let i = 0; i < this.length; i++) {
+      const ei = Array.from({ length: this.length }, (_, j) => new Decimal(j === i ? 1 : 0));
+      let candidate = new Vector(ei);
+      // check not parallel
+      const crossDim = Math.min(3, this.length);
+      // project candidate out of this
+      const proj = candidate.projectOnto(this);
+      const orth = candidate.sub(proj);
+      const norm = orth.norm();
+      if (!norm.isZero()) return orth.normalize();
+    }
+    throw new Error('Unable to find orthogonal vector');
+  }
+
+  // check orthogonality with other
+  isOrthogonalTo(other) {
+    return this.dot(other).isZero();
+  }
+}

package/test/example.js

@@ -0,0 +1,18 @@
+import { Matrix, Decimal } from '../src/index.js';
+
+Decimal.set({ precision: 40 });
+
+const A = Matrix.from([[1.234567890123456789, 2.34567890123456789], [3.4567890123456789, 4.567890123456789]]);
+console.log('A:', A.toArrayOfStrings());
+
+const det = A.determinant();
+console.log('det(A):', det.toString());
+
+const inv = A.inverse();
+console.log('inv(A):', inv.toArrayOfStrings());
+
+const x = A.solve([1, 2]);
+console.log('solution x for Ax=[1,2]:', x.toArrayOfStrings());
+
+const B = Matrix.from([[1, 0], [0, 1]]);
+console.log('A * inv(A):', A.mul(inv).toArrayOfStrings());

package/test/examples.js

@@ -0,0 +1,50 @@
+import Decimal from 'decimal.js';
+import { Matrix, Vector, Transforms2D, Transforms3D } from '../src/index.js';
+
+Decimal.set({ precision: 80 });
+
+// Vector operations
+const v = Vector.from(['1.234567890123456789', '2.34567890123456789', '3.4567890123456789']);
+const w = Vector.from(['3.333333333333333333', '4.444444444444444444', '5.555555555555555555']);
+console.log('v =', v.toStringArray());
+console.log('w =', w.toStringArray());
+console.log('dot(v,w) =', v.dot(w).toString());
+console.log('v cross w =', v.cross(w).toStringArray());
+console.log('v norm =', v.norm().toString());
+console.log('normalized v =', v.normalize().toStringArray());
+console.log('angle(v,w) =', v.angleBetween(w).toString());
+
+// Matrix * vector
+const M = Matrix.from([[1.5, 0, 0], [0, 2.5, 0], [0, 0, 3.5]]);
+const mv = M.applyToVector(v);
+console.log('M * v =', mv.toStringArray());
+
+// 2D transforms: concatenation and inverse
+const T = Transforms2D.translation(2, 3);
+const R = Transforms2D.rotate(Math.PI / 4);
+const S = Transforms2D.scale('1.5');
+const M2 = T.mul(R).mul(S);
+console.log('Combined 2D M2:', M2.toArrayOfStrings());
+const p = [1, 0];
+const p2 = Transforms2D.applyTransform(M2, ...p);
+console.log('Point', p, '->', p2.map(x => x.toString()));
+const Minv = M2.inverse();
+const pBack = Transforms2D.applyTransform(Minv, ...p2);
+console.log('Back:', pBack.map(x => x.toString()));
+
+// 3D example
+const R3 = Transforms3D.rotateAroundAxis(1, 1, 0, Math.PI / 3);
+const T3 = Transforms3D.translation('0.5', '1.2', '3.4');
+const M3 = T3.mul(R3);
+console.log('3D transform M3:', M3.toArrayOfStrings());
+
+// Matrix exponential example (2x2 rot generator)
+const A = Matrix.from([[0, -1], [1, 0]]);
+const expA = A.exp();
+console.log('exp(A) approx rotation:', expA.toArrayOfStrings());
+
+// Solve linear system
+const B = Matrix.from([[4, 7], [2, 6]]);
+const bvec = [1, 1];
+const x = B.solve(bvec);
+console.log('Solution x for B x = b:', x.toStringArray());