Changed Github Actions to used TrustedPublisher/OIDC for NPM Publishing

Author: FiddlyDigital

.github/workflows/main.yml

@@ -6,31 +6,34 @@ on:
      - main
 
 permissions:
-  contents: write
+  id-token: write  # Required for OIDC
+  contents: read
 
 jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup Node.js
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+
+      # Ensure npm 11.5.1 or later is installed
+      - name: Update npm
+        run: npm install -g npm@latest
 
       - name: Install Package Dependencies
         run: npm ci
 
       - name: Build the Package
-        run: npm run build
+        run: npm run build --if-present
 
       - name: Run Tests
         run: npm run test
 
       - name: Publish Package to NPM 🚀
-        uses: JS-DevTools/npm-publish@v1
-        with:
-          token: ${{ secrets.NPM_TOKEN }}
-          access: public
+        run: npm publish

README.md

@@ -1,6 +1,60 @@
 # FastMap
 
-A simple 2D map that is optimized for performance.
+An simple alternative to 2D arrays, with comparative performance.
+
+## Benefits:
+
+- Memory Efficient 
+  - Built on a 1d array; Uses a single contiguous block of memory
+  - Fewer object allocations = less garbage collection overhead
+  - Better memory layout for very large maps
+
+- Cleaner API and Type Safety
+  - Single generic type: `FastMap<T>` vs `T[][]`
+  - No need to manage nested array initialization
+  - Consistent bounds checking across all operations (with safe Get/Set methods)
+
+## Usage:
+
+Let's be honest: If you're just storing simple data and don't need safety guarantees, _a 2D array is simpler_. 
+
+FastMap is best used for:
+- Game dev (tile maps, grids where safety + performance matter)
+- Image processing (pixel buffers)
+- Large grid simulations
+- Other cases where you want built-in bounds checking without manual if statements
+
+## How to use:
+`npm install "@speakingsoftware/fastmap"`
+
+``` typescript
+import { FastMap } from '@speakingsoftware/fastmap';
+
+interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+
+const image = new FastMap<RGB>(100, 100);
+
+// Draw a simple gradient
+for (let y = 0; y < 100; y++) {
+    for (let x = 0; x < 100; x++) {
+        image.Set(x, y, {
+            r: Math.floor(255 * (x / 100)),
+            g: Math.floor(255 * (y / 100)),
+            b: 128
+        });
+    }
+}
+```
+
+----------
+
+Inspired by the CImage class in Vladimir Kovalevsky's book "Modern Algorithms for Image Processing"
+
+
+
+
 
- * Internally, it is a 1D array that is accessed using 2D coordinates. This makes is extremely performant for larger maps, as it avoids the overhead and mess of nested arrays.
- * Inspired by the CImage class in Vladimir Kovalevsky's book "Modern Algorithms for Image Processing"