@fagelsjo/blocks 0.0.1 → 0.0.2

package/Makefile

@@ -12,5 +12,5 @@ pub:
 	npm run pub
 
 clean:
-	rm -f *.ts
+	rm -f *.js
 

package/blocks.ts

@@ -0,0 +1,337 @@
+/* blocks.ts */
+
+let log:(...args:any[])=>void;
+let fail:(...args:any[])=>never;
+
+log = console.log;
+fail = (...args:any[]): never => {
+  console.error(...args);
+  throw new Error();
+
+  return void 0 as never;
+};
+
+type BlockData = Uint16Array;
+
+interface Block {
+    readonly data: BlockData;
+    readonly cidr: number;
+}
+
+let mkblock:(x:string)=>Block;
+let parse:(x:string)=>Block;
+let bestidx:(block:Block)=>number;
+let tostr:(block:Block)=>string;
+let hex16:(x:number,bigendian?:boolean)=>string;
+
+mkblock = (x:string): Block => 
+    parse(x)
+        || fail('parse error');
+
+//fe80::20c:29ff:fe9f:807c 
+//fe80:0000:0000:0000:0000:0000:0000:
+//   0000:0000:0000:0000:0000:0000:020c:29ff:fe9f:807c 
+
+hex16 = (x:number,littleendian:boolean=true): string => {
+    let x_:number;
+    let a:string;
+    let b:string;
+    let c:string;
+    let d:string;
+    let a_:boolean;
+    let b_:boolean;
+    let c_:boolean;
+    let d_:boolean;
+    let nibble:number;
+    let nib2str:(y:number)=>string;
+
+    nib2str = (y:number):string =>
+        (y<10) ?
+                y.toString() :
+        (y<16) ?
+                ['a','b','c','d','e','f'][(y-10)]||fail() :
+        nib2str((y&0x000f));
+
+    x_ = (x&0xffff);
+    nibble = (x_>>12); a=nib2str(nibble);
+    nibble = (x_>>8);  b=nib2str(nibble);
+    nibble = (x_>>4);  c=nib2str(nibble);
+    nibble = (x_&0x000f);
+    d = nib2str(x_);
+
+    a_ = (a!=='0');
+    b_ = (b!=='0');
+    c_ = (c!=='0');
+    d_ = (d!=='0');
+
+    if (littleendian) {
+        if (!a_ && !b_ && !c_)
+            return d;
+        else if (!a_ && !b_)
+            return (c+d);
+        else if (!a_)
+            return (b+c+d);
+        else
+            return (a+b+c+d);
+    }
+    else {
+        if (!d_ && !c_ && !b_)
+            return (a);
+        else if (!d_ && !c_)
+            return (b+a);
+        else if (!d_)
+            return (c+b+a);
+        else
+            return (d+c+b+a);
+    }
+}
+
+parse = (x:string): Block => {
+    let rs:RegExp[];
+    let rs_:boolean[];
+    let x_:string;
+    let ret:boolean;
+    let arr:BlockData;
+    let block:Block;
+    let split:string[];
+    let cidr:number;
+    let scidr:string;
+    let forward:boolean;
+    let idx:number;
+    let field_:number;
+    let idx_:number;
+    let next:()=>number;
+
+    next = (): number => {
+        let field:number;
+        let sfield:string;
+
+        if (idx === 255)
+            throw 1;
+
+        if ((idx < 0) || (idx > 15))
+            idx = 255;
+
+        sfield = split[idx]
+            || '';
+
+        if (forward)
+            idx++;
+        else
+            idx--;
+
+        if (sfield === '')
+            throw 2;
+        else
+            field = parseInt('0x'+sfield);
+
+        return field;
+    }
+
+    // peek = (): number => {
+    //     let field:number;
+    //     let sfield:string;
+    //     let idx_:number;
+
+    //     if (forward && (idx === 15))
+    //         throw 1;
+    //     else if (!forward && (!idx))
+    //         throw 1;
+
+    //     idx_ = (forward) ?
+    //             (idx+1) :
+    //         (idx-1);
+
+    //     sfield = split[idx_]
+    //         || '';
+
+    //     if (sfield === '')
+    //         throw 2;
+    //     else
+    //         field = parseInt('0x'+sfield);
+
+    //     return field;
+    // }
+
+    x_ = x
+        .toLowerCase();
+
+    rs = [
+        /^([0-9a-f]{1,4}[:]?){16}\/[0-9]{1,3}$/,
+        /^([0-9a-f]{1,4}[:])*[:]([0-9a-f]{1,4}[:]?)*$/,
+        /^([0-9a-f]{1,4}[:])*[:]([0-9a-f]{1,4}[:]?)*\/[0-9]{1,3}$/
+    ];
+    rs_ = rs
+        .map((r:RegExp): boolean => r.test(x_));
+    
+    ret = rs_.some((b:boolean): boolean => !!b);
+    if (!ret)
+        return null as never;
+
+    forward = true;
+    idx = 0;
+    cidr = 257;
+    arr = new Uint16Array(16);
+    split = (x_
+        .split('/')[0]||x_)
+        .split(':');
+
+    switch (true) {
+        case rs_[1]:
+        case rs_[2]:
+            scidr = x_
+                .split('/')[1]
+                    || '257';
+            cidr = parseInt(scidr);
+            if (cidr === 257)
+                return null as never;
+            
+            idx_ = idx;
+            while (true) {
+                field_ = 0;
+                try {
+                    field_ = next();
+                } catch(errno) {
+                    if (errno === 1)
+                        break;
+                    else if (errno === 2) {
+                        if (!forward)
+                            break;
+                        else {
+                            forward = false;
+                            idx = (split.length-1);
+                            idx_ = 15;
+
+                            continue;
+                        }
+                    }
+                }
+                arr[idx_] = field_;
+                idx_ = (forward) ?
+                        ++idx_ :
+                    --idx_;
+            }
+            break;
+
+         case rs_[0]:
+            scidr = x_
+                .split('/')[1]
+                    || '256';
+            cidr = parseInt(scidr);
+            
+            do {
+                field_ = 0;
+                idx_ = idx;
+                try {
+                    field_ = next();
+                } catch(errno) {
+                    if (errno === 1)
+                        break;
+                    else if (errno === 2)
+                        return null as never;
+                }
+                arr[idx_] = field_;
+            } while (idx_<15);
+            break;
+
+        default:
+            return null as never;
+    }
+
+    return {data: arr, cidr};
+}
+
+bestidx = (block:Block): number => {
+    type candidate = {idx:number,amount:number};
+    let idx:number;
+    let cur:candidate;
+    let cs:candidate[];
+    let counting:boolean;
+
+    idx = 0;
+    cur = {idx,amount:0};
+    cs = [];
+    counting = false;
+
+    block.data.forEach((x:number):void => {
+        if (!idx) {
+            idx++;
+            return void 0;
+        }
+        else if (idx===15)
+            if (counting) {
+                counting = false;
+
+                if (!x)
+                    cur.amount++;
+                cs.push(cur);
+                cur = {idx:0,amount:0};
+
+                return void 0;
+            }
+
+        if (!x)
+            if (!counting) {
+                counting = true;
+                cur = {idx,amount:1};
+            }
+            else
+                cur.amount++;
+        else
+            if (counting) {
+                counting = false;
+                cs.push(cur);
+                cur = {idx:0,amount:0};
+            }
+        idx++;
+    });
+
+    if (!cs.length)
+        return 0;
+
+    cs = cs
+        .sort((a:candidate,b:candidate): number => (a.amount<b.amount) ?
+                1 :
+            (a.amount>b.amount) ?
+                -1 :
+            0
+        );
+    cur = cs.shift()
+        || {idx:0,amount:0};
+    
+    return cur.idx;
+}
+
+tostr = (block:Block): string => {
+    let counting:boolean;
+    let best:number;
+    let arr:string[];
+    let str:string;
+
+    counting = false;
+    arr = [];
+    best = bestidx(block);
+    block.data
+        .forEach((x:number,idx:number): void =>{
+            if (counting)
+                if (!x)
+                    return void 0;
+                else
+                    counting = false;
+            else
+                if (idx && (idx===best)) {
+                    counting = true;
+                    arr.push('');
+
+                    return void 0;
+                }
+
+            arr.push(hex16(x));
+    });
+
+    return arr.join(':')
+        .concat('/'+block.cidr.toString());
+}
+
+export { mkblock,tostr };
+export type { Block };

package/index.ts

@@ -0,0 +1,27 @@
+/* index.ts */
+import { mkblock, tostr } from './blocks.js';
+import type { Block } from './blocks.js';
+
+let block:Block;
+let str:string;
+let str_:string;
+let idx:number;
+let log:(...args:any[])=>void;
+let fail:(...args:any[])=>never;
+
+log = console.log;
+fail = (...args:any[]): never => {
+  console.error(...args);
+  throw new Error();
+
+  return void 0 as never;
+};
+
+block = mkblock(str='fe80::20c:29ff:fe9f:807c/64');
+str_ = tostr(block);
+log(str, block, str_);
+
+block = mkblock(str='fe80:0000:0000:000a:0000:0000:0000:'
+    +'0000:0000:0000:0000:0000:020c:29ff:fe9f:807c/128');
+str_ = tostr(block);
+log(str, block, str_);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fagelsjo/blocks",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Handle blocks of bigints in an IPv6 kind of way.",
   "main": "index.js",
   "scripts": {
@@ -16,6 +16,10 @@
   ],
   "author": "@dr-Jonas-Birch",
   "license": "MIT",
+  "dependencies": {
+    "@types/node": "^25.2.3",
+    "@types/typescript": "^2.0.0"
+  },
   "devDependencies": {
     "@types/node": "^25.2.3",
     "@types/typescript": "^2.0.0",

package/tsconfig.json

@@ -9,7 +9,7 @@
     // See also https://aka.ms/tsconfig/module
     "module": "nodenext",
     "target": "esnext",
-    "types": [],
+    "types": ["node"],
     // For nodejs:
     // "lib": ["esnext"],
     // "types": ["node"],

package/index.js

@@ -1,12 +0,0 @@
-/* index.ts */
-let log;
-let fail;
-log = console.log;
-fail = (...args) => {
-    console.error(...args);
-    throw new Error();
-    return void 0;
-};
-log('foo');
-export {};
-//# sourceMappingURL=index.js.map