Fix/remove class

src/lib/components/tools/CIDRInput.svelte

@@ -29,9 +29,9 @@
    * Quick CIDR presets
    */
   const cidrPresets = [
-    { cidr: 8, label: '/8 (Class A)', hosts: '16M hosts' },
-    { cidr: 16, label: '/16 (Class B)', hosts: '65K hosts' },
-    { cidr: 24, label: '/24 (Class C)', hosts: '254 hosts' },
+    { cidr: 8, label: '/8', hosts: '16M hosts' },
+    { cidr: 16, label: '/16', hosts: '65K hosts' },
+    { cidr: 24, label: '/24', hosts: '254 hosts' },
     { cidr: 25, label: '/25', hosts: '126 hosts' },
     { cidr: 26, label: '/26', hosts: '62 hosts' },
     { cidr: 27, label: '/27', hosts: '30 hosts' },

src/lib/components/tools/IPEnumerate.svelte

@@ -50,7 +50,7 @@
       description: '10 addresses',
     },
     {
-      label: 'Class C /24',
+      label: 'Medium /24 network',
       input: '192.168.0.0/24',
       description: '256 addresses',
     },

src/lib/components/tools/IPValidator.svelte

@@ -111,32 +111,32 @@
       details.scope = 'Host';
       details.info.push('Used for local loopback communications');
     } else if (a === 10) {
-      details.addressType = 'Private (Class A)';
+      details.addressType = 'Private';
       details.scope = 'Private Network';
       details.isPrivate = true;
-      details.info.push('RFC 1918 private address space');
+      details.info.push('RFC 1918 private address space (10.0.0.0/8)');
     } else if (a === 172 && b >= 16 && b <= 31) {
-      details.addressType = 'Private (Class B)';
+      details.addressType = 'Private';
       details.scope = 'Private Network';
       details.isPrivate = true;
-      details.info.push('RFC 1918 private address space');
+      details.info.push('RFC 1918 private address space (172.16.0.0/12)');
     } else if (a === 192 && b === 168) {
-      details.addressType = 'Private (Class C)';
+      details.addressType = 'Private';
       details.scope = 'Private Network';
       details.isPrivate = true;
-      details.info.push('RFC 1918 private address space');
+      details.info.push('RFC 1918 private address space (192.168.0.0/16)');
     } else if (a === 169 && b === 254) {
       details.addressType = 'Link-Local (APIPA)';
       details.scope = 'Link-Local';
       details.isReserved = true;
       details.info.push('Automatic Private IP Addressing');
     } else if (a >= 224 && a <= 239) {
-      details.addressType = 'Multicast (Class D)';
+      details.addressType = 'Multicast';
       details.scope = 'Multicast';
       details.isReserved = true;
-      details.info.push('Used for multicast communications');
+      details.info.push('Used for multicast communications (224.0.0.0/4)');
     } else if (a >= 240) {
-      details.addressType = 'Reserved (Class E)';
+      details.addressType = 'Reserved';
       details.scope = 'Reserved';
       details.isReserved = true;
       details.info.push('Reserved for future use');

src/lib/components/tools/ReverseZonesCalculator.svelte

@@ -25,17 +25,17 @@
     {
       label: 'IPv4 /24 Network',
       cidr: '192.168.1.0/24',
-      description: 'Single class C zone delegation',
+      description: 'Single /24 zone delegation',
     },
     {
       label: 'IPv4 /16 Network',
       cidr: '10.0.0.0/16',
-      description: 'Class B with multiple /24 zones',
+      description: '/16 network with multiple /24 zones',
     },
     {
       label: 'IPv4 /20 Block',
       cidr: '172.16.32.0/20',
-      description: '16 class C zones needed',
+      description: '16 /24 zones needed',
     },
     {
       label: 'IPv4 /28 Subnet',
@@ -82,7 +82,7 @@
       let delegationType = '';
       if (ipv4Zones > 0) {
         if (ipv4Zones === 1) {
-          delegationType = zones[0].delegation.includes('/24') ? 'Class C (/24)' : `Custom (${zones[0].delegation})`;
+          delegationType = zones[0].delegation.includes('/24') ? '/24 network' : `Custom (${zones[0].delegation})`;
         } else {
           delegationType = `Multiple zones (${ipv4Zones} x /24)`;
         }
@@ -268,11 +268,11 @@ chmod 644 /etc/bind/zones/${zone.zone}`;
                 <div class="zone-description">
                   {#if zone.type === 'IPv4'}
                     {#if zone.delegation === '/24'}
-                      Standard class C reverse zone for 256 addresses
+                      Standard /24 reverse zone for 256 addresses
                     {:else if zone.delegation === '/16'}
-                      Class B reverse zone covering 65,536 addresses
+                      /16 reverse zone covering 65,536 addresses
                     {:else if zone.delegation === '/8'}
-                      Class A reverse zone covering 16,777,216 addresses
+                      /8 reverse zone covering 16,777,216 addresses
                     {:else}
                       Custom IPv4 reverse zone for {zone.delegation} prefix
                     {/if}

src/lib/constants/networks.ts

@@ -31,17 +31,17 @@ export const RESERVED_RANGES = {
   },
   PRIVATE_A: {
     range: '10.0.0.0/8',
-    description: 'Private network (Class A)',
+    description: 'Private network',
     rfc: 'RFC 1918',
   },
   PRIVATE_B: {
     range: '172.16.0.0/12',
-    description: 'Private network (Class B)',
+    description: 'Private network',
     rfc: 'RFC 1918',
   },
   PRIVATE_C: {
     range: '192.168.0.0/16',
-    description: 'Private network (Class C)',
+    description: 'Private network',
     rfc: 'RFC 1918',
   },
   LINK_LOCAL: {

src/lib/content/private-vs-public-ip.ts

@@ -17,23 +17,23 @@ The key difference is reachability: private IPs are only reachable within their
       range: '10.0.0.0/8',
       fullRange: '10.0.0.0 to 10.255.255.255',
       addresses: '16,777,216 addresses',
-      class: 'Class A private range',
+      class: 'RFC 1918 private range',
       commonUse: 'Large enterprises, ISP internal networks',
       examples: ['10.0.0.1', '10.1.1.1', '10.200.50.100'],
     },
     {
       range: '172.16.0.0/12',
       fullRange: '172.16.0.0 to 172.31.255.255',
       addresses: '1,048,576 addresses',
-      class: 'Class B private range',
+      class: 'RFC 1918 private range',
       commonUse: 'Medium businesses, cloud providers',
       examples: ['172.16.0.1', '172.20.1.1', '172.31.255.254'],
     },
     {
       range: '192.168.0.0/16',
       fullRange: '192.168.0.0 to 192.168.255.255',
       addresses: '65,536 addresses',
-      class: 'Class C private range',
+      class: 'RFC 1918 private range',
       commonUse: 'Home networks, small offices',
       examples: ['192.168.1.1', '192.168.0.100', '192.168.100.50'],
     },

src/lib/utils/dns-tools.ts

@@ -279,8 +279,8 @@ function calculateIPv4ReverseZones(ip: string, prefix: number, cidr: string): Re
       zones.push(`${thirdOctet}.${secondOctet}.${firstOctet}.in-addr.arpa`);
     }
   } else {
-    // Very large networks - show class-based zones
-    zones.push(`${networkOctets[0]}.in-addr.arpa (Class A network)`);
+    // Very large networks - show /8 zone
+    zones.push(`${networkOctets[0]}.in-addr.arpa (/8 network)`);
   }
 
   return {

src/lib/utils/ip-security.ts

@@ -36,13 +36,13 @@ function isPrivateIPv4(ip: string): boolean {
   // Loopback: 127.0.0.0/8
   if (a === 127) return true;
 
-  // Private Class A: 10.0.0.0/8
+  // Private: 10.0.0.0/8
   if (a === 10) return true;
 
-  // Private Class B: 172.16.0.0/12
+  // Private: 172.16.0.0/12
   if (a === 172 && b >= 16 && b <= 31) return true;
 
-  // Private Class C: 192.168.0.0/16
+  // Private: 192.168.0.0/16
   if (a === 192 && b === 168) return true;
 
   // Link-local: 169.254.0.0/16 (AWS metadata, APIPA)

src/lib/utils/ip-validation.ts

@@ -163,20 +163,20 @@ export function validateIPv4Detailed(ip: string): DetailedValidationResponse {
     details.scope = 'Host';
     details.info.push('Loopback address (localhost)');
   } else if (a === 10) {
-    details.addressType = 'Private (Class A)';
+    details.addressType = 'Private';
     details.scope = 'Private Network';
     details.isPrivate = true;
-    details.info.push('RFC 1918 private address space');
+    details.info.push('RFC 1918 private address space (10.0.0.0/8)');
   } else if (a === 172 && b >= 16 && b <= 31) {
-    details.addressType = 'Private (Class B)';
+    details.addressType = 'Private';
     details.scope = 'Private Network';
     details.isPrivate = true;
-    details.info.push('RFC 1918 private address space');
+    details.info.push('RFC 1918 private address space (172.16.0.0/12)');
   } else if (a === 192 && b === 168) {
-    details.addressType = 'Private (Class C)';
+    details.addressType = 'Private';
     details.scope = 'Private Network';
     details.isPrivate = true;
-    details.info.push('RFC 1918 private address space');
+    details.info.push('RFC 1918 private address space (192.168.0.0/16)');
   } else if (a === 169 && b === 254) {
     details.addressType = 'Link-Local (APIPA)';
     details.scope = 'Link-Local';

src/routes/subnetting/+page.svelte

@@ -110,7 +110,7 @@
             <th use:tooltip={'CIDR notation - number of network bits'}>CIDR</th>
             <th use:tooltip={'Decimal representation of the subnet mask'}>Subnet Mask</th>
             <th use:tooltip={'Number of usable host addresses per subnet'}>Hosts</th>
-            <th use:tooltip={'Number of possible subnets in a Class C'}>Subnets</th>
+            <th use:tooltip={'Number of possible subnets in a /24 network'}>Subnets</th>
           </tr>
         </thead>
         <tbody>

tests/unit/content/private-vs-public-ip.test.ts

@@ -16,23 +16,23 @@ describe('Private vs Public IP content', () => {
   it('defines RFC 1918 private ranges correctly', () => {
     expect(privateVsPublicContent.privateRanges).toHaveLength(3);
 
-    const classA = privateVsPublicContent.privateRanges[0];
-    expect(classA.range).toBe("10.0.0.0/8");
-    expect(classA.fullRange).toBe("10.0.0.0 to 10.255.255.255");
-    expect(classA.class).toBe("Class A private range");
-    expect(classA.examples).toContain("10.0.0.1");
-    
-    const classB = privateVsPublicContent.privateRanges[1];
-    expect(classB.range).toBe("172.16.0.0/12");
-    expect(classB.fullRange).toBe("172.16.0.0 to 172.31.255.255");
-    expect(classB.class).toBe("Class B private range");
-    expect(classB.examples).toContain("172.16.0.1");
-    
-    const classC = privateVsPublicContent.privateRanges[2];
-    expect(classC.range).toBe("192.168.0.0/16");
-    expect(classC.fullRange).toBe("192.168.0.0 to 192.168.255.255");
-    expect(classC.class).toBe("Class C private range");
-    expect(classC.examples).toContain("192.168.1.1");
+    const range10 = privateVsPublicContent.privateRanges[0];
+    expect(range10.range).toBe("10.0.0.0/8");
+    expect(range10.fullRange).toBe("10.0.0.0 to 10.255.255.255");
+    expect(range10.class).toBe("RFC 1918 private range");
+    expect(range10.examples).toContain("10.0.0.1");
+
+    const range172 = privateVsPublicContent.privateRanges[1];
+    expect(range172.range).toBe("172.16.0.0/12");
+    expect(range172.fullRange).toBe("172.16.0.0 to 172.31.255.255");
+    expect(range172.class).toBe("RFC 1918 private range");
+    expect(range172.examples).toContain("172.16.0.1");
+
+    const range192 = privateVsPublicContent.privateRanges[2];
+    expect(range192.range).toBe("192.168.0.0/16");
+    expect(range192.fullRange).toBe("192.168.0.0 to 192.168.255.255");
+    expect(range192.class).toBe("RFC 1918 private range");
+    expect(range192.examples).toContain("192.168.1.1");
   });
 
   it('has accurate address counts', () => {