Add support for parsing negative numbers in OSF files

## Summary
- Introduced functionality to handle negative numeric literals in the parser.
- Updated the `parseNumber` function to correctly interpret negative signs and validate number formats.
- Added comprehensive test cases to ensure accurate parsing of negative numbers in various contexts, including arrays, nested objects, and sheet data.
- Implemented error handling for invalid negative number formats.

## Testing
- Run `pnpm test` to verify all new and existing tests pass successfully.

Author: alpha912

examples/negative_numbers.osf

@@ -0,0 +1,43 @@
+@meta {
+  title: "Negative Numbers Example";
+  author: "OSF Parser";
+  version: "0.5.0";
+  temperature: -25;
+  balance: -1000.50;
+  coordinates: [-10, -5.5, 0, 5.5, 10];
+}
+
+@sheet {
+  name: "Financial Data";
+  cols: [Account, Balance, Change];
+  data {
+    (1,1) = "Checking";
+    (1,2) = -500.25;
+    (1,3) = -50.00;
+    (2,1) = "Savings";
+    (2,2) = 1000.00;
+    (2,3) = -25.50;
+    (3,1) = "Credit";
+    (3,2) = -2500.75;
+    (3,3) = -100.00;
+  }
+  formula (4,2): "=B1+B2+B3";
+  formula (4,3): "=C1+C2+C3";
+}
+
+@slide {
+  title: "Temperature Data";
+  layout: TitleAndBullets;
+  bullets {
+    "Minimum temperature: -40°C";
+    "Average winter temp: -15.5°C";
+    "Freezing point: 0°C";
+    "Room temperature: 22°C";
+  }
+  metadata: {
+    minTemp: -40;
+    maxTemp: 45;
+    range: 85;
+    measurements: [-40, -30, -20, -10, 0, 10, 20, 30, 40];
+  };
+} 

parser/src/parser.ts

@@ -90,7 +90,20 @@ function parseString(str: string, i: number): { value: string; index: number } {
 
 function parseNumber(str: string, i: number): { value: number; index: number } {
   let j = i;
+  
+  // Handle optional negative sign
+  if (j < str.length && str[j] === '-') {
+    j++;
+  }
+  
+  // Parse digits and decimal point
   while (j < str.length && /[0-9.]/.test(str[j]!)) j++;
+  
+  // Ensure we actually parsed some digits after the optional minus sign
+  if (j === i || (j === i + 1 && str[i] === '-')) {
+    throw new Error('Invalid number format');
+  }
+  
   return { value: Number(str.slice(i, j)), index: j };
 }
 
@@ -120,6 +133,7 @@ function parseValue(str: string, i: number): { value: any; index: number } {
     return { value: res.obj, index: res.index + 1 };
   }
   if (/\d/.test(ch)) return parseNumber(str, i);
+  if (ch === '-' && i + 1 < str.length && /\d/.test(str[i + 1]!)) return parseNumber(str, i);
   if (str.startsWith('true', i)) return { value: true, index: i + 4 };
   if (str.startsWith('false', i)) return { value: false, index: i + 5 };
   const id = parseIdentifier(str, i);

parser/tests/parser.test.ts

@@ -283,6 +283,126 @@ describe('OSF Parser', () => {
       expect(docBlock.content).toBe('');
     });
 
+    it('should parse negative numeric literals', () => {
+      const input = `@meta {
+        temperature: -25;
+        balance: -1000.50;
+        offset: -0.5;
+        zero: 0;
+        positive: 42;
+      }`;
+
+      const result = parse(input);
+
+      expect(result.blocks).toHaveLength(1);
+      expect(result.blocks[0]?.type).toBe('meta');
+
+      const metaBlock = result.blocks[0] as MetaBlock;
+      expect(metaBlock.props.temperature).toBe(-25);
+      expect(metaBlock.props.balance).toBe(-1000.50);
+      expect(metaBlock.props.offset).toBe(-0.5);
+      expect(metaBlock.props.zero).toBe(0);
+      expect(metaBlock.props.positive).toBe(42);
+    });
+
+    it('should parse negative numbers in arrays', () => {
+      const input = `@meta {
+        values: [-10, -5.5, 0, 5.5, 10];
+        coordinates: [-1, -2, -3];
+      }`;
+
+      const result = parse(input);
+      const metaBlock = result.blocks[0] as MetaBlock;
+      
+      expect(metaBlock.props.values).toEqual([-10, -5.5, 0, 5.5, 10]);
+      expect(metaBlock.props.coordinates).toEqual([-1, -2, -3]);
+    });
+
+    it('should parse negative numbers in nested objects', () => {
+      const input = `@meta {
+        position: { x: -10; y: -20.5; z: -0.1; };
+        range: { min: -100; max: 100; };
+      }`;
+
+      const result = parse(input);
+      const metaBlock = result.blocks[0] as MetaBlock;
+      
+      expect(metaBlock.props.position).toEqual({ x: -10, y: -20.5, z: -0.1 });
+      expect(metaBlock.props.range).toEqual({ min: -100, max: 100 });
+    });
+
+    it('should parse negative numbers in sheet data', () => {
+      const input = `@sheet {
+        name: "NegativeNumbers";
+        data {
+          (1,1) = -42;
+          (1,2) = -3.14159;
+          (2,1) = -0.001;
+          (2,2) = 100;
+        }
+      }`;
+
+      const result = parse(input);
+      const sheetBlock = result.blocks[0] as SheetBlock;
+      
+      expect(sheetBlock.data).toEqual({
+        '1,1': -42,
+        '1,2': -3.14159,
+        '2,1': -0.001,
+        '2,2': 100
+      });
+    });
+
+    it('should handle edge cases for negative numbers', () => {
+      const input = `@meta {
+        minusZero: -0;
+        largeNegative: -999999999;
+        smallNegative: -0.000001;
+      }`;
+
+      const result = parse(input);
+      const metaBlock = result.blocks[0] as MetaBlock;
+      
+      expect(metaBlock.props.minusZero).toBe(-0);
+      expect(metaBlock.props.largeNegative).toBe(-999999999);
+      expect(metaBlock.props.smallNegative).toBe(-0.000001);
+    });
+
+    it('should throw error for invalid negative number formats', () => {
+      const invalidInputs = [
+        `@meta { invalid: -; }`,
+        `@meta { invalid: -abc; }`,
+        `@meta { invalid: --5; }`,
+      ];
+
+      invalidInputs.forEach(input => {
+        expect(() => parse(input)).toThrow();
+      });
+    });
+
+    it('should serialize negative numbers correctly', () => {
+      const doc: OSFDocument = {
+        blocks: [
+          {
+            type: 'meta',
+            props: {
+              negative: -42,
+              decimal: -3.14,
+              zero: -0,
+              positive: 100
+            }
+          } as MetaBlock
+        ]
+      };
+
+      const serialized = serialize(doc);
+      
+      expect(serialized).toContain('negative: -42');
+      expect(serialized).toContain('decimal: -3.14');
+      expect(serialized).toContain('zero: 0'); // -0 should serialize as 0
+      expect(serialized).toContain('positive: 100');
+    });
+
   });
 
   describe('serialize', () => {