Wrote basic encoder / decoder

Author: PhoneDroid

Source/Node.js

@@ -0,0 +1,179 @@
+
+import { printify } from './Stringify.js'
+
+
+const { entries } = Object;
+
+
+export default class Node {
+    
+    #properties = {}
+    #items = []
+    
+    name = 'Root'
+    
+    
+    /**
+     *  Append one or more items to the node.
+     */
+    
+    push ( ... items ){
+        this.#items.push(...items);
+    }
+    
+    
+    /**
+     *  Pop the last value on the node.
+     */
+     
+    pop (){
+        return this.#items.pop();
+    }
+    
+    
+    /**
+     *  Shift one or more items into the node.
+     */
+    
+    unshift ( ... items ){
+        this.#items.unshift(...items);
+    }
+    
+    
+    /**
+     *  Shift an item from the node.
+     */
+    
+    shift (){
+        return this.#items.shift();
+    }
+    
+    
+    /**
+     *  Appends a named item to the node.
+     *  If the index is given, inserts
+     *  it at that position instead.
+     *
+     *  @param name Name of the item.
+     *  @param value Value of the item.
+     *  @param index Position of insertion.
+     */
+     
+    assign ( name , value , index ){
+        
+        const { items } = this;
+        
+        index ??= items.length - 1;
+        
+        let item = { name , value };
+        
+        if(value instanceof Node){
+            value.name  = name;
+            item = value;
+        }
+        
+        items.splice(index,0,item);
+        this.#properties[name] = index;
+    }
+    
+    
+    /**
+     *  Returns the item at the given position.
+     *  Negative indexes start from the end.
+     *  @param index Index of the item.
+     */
+     
+    item ( index ){
+        return this.items.at(index)
+    }
+    
+    
+    /**
+     *  Returns the value or node uniquely
+     *  associated with the given name.
+     *  @param name Name of the property.
+     */
+    
+    named ( name ){
+        
+        const item = this.item(this.#properties[key]);
+        
+        if(item instanceof Node)
+            return item
+        
+        return item?.value
+    }
+    
+    
+    /**
+     *  A list of all items.
+     */
+     
+    get items (){
+        return this.#items
+    }
+    
+    
+    /**
+     *  The nodes item count.
+     */
+    
+    get size (){
+        return this.items.length;
+    }
+    
+    
+    /**
+     *  Stringifies this node and all of it's value.
+     */
+     
+    toString (){
+        return printify(this);
+
+    }
+    
+    
+    /**
+     *  Generate a node from raw graph data.
+     */
+    
+    static from ( data ){
+        
+        const { name , value } = data;
+
+        const graph = new Node;
+        graph.#items = value;
+        graph.name = name ?? 'Root';
+        
+        for ( const [ index , item ] of entries(value) )
+            if(typeof item === 'object')
+                integrate(index,item);
+        
+        
+        function integrate ( index , item ){
+            
+            const { value , name } = item;
+
+            graph.#properties[name] = index;
+
+            if(Array.isArray(value)){
+
+                const { length } = value;
+
+                switch ( true ){
+                case length < 1 :
+                    graph.#items[index] = null;
+                    return
+                case length === 1 :
+                    graph.#items[index] = value[0];
+                    return
+                default:
+                    graph.#items[index] = Node.from(item);
+                    return
+                }
+            }
+        }
+            
+        return graph
+    }
+}

Source/Parse.js

@@ -0,0 +1,182 @@
+
+import Node from './Node.js'
+
+
+const Tokens = [
+    [ /^{/ , '{' , 1 ] ,
+    [ /^}/ , '}'   , 1 ] ,
+    [ /^\/\*/ , '/*' , 2 ] ,
+    [ /^\*\// , '*/'   , 2 ] ,
+    [ /^"/ , '"' , 1 ] ,
+    [ /^[a-z][a-z0-9_]*/i , 'Name' ] ,
+    [ /^(\+|\-)?[0-9]+(\.[0-9]+)?/ , 'Number' ] ,
+    [ /^\\\S/ , 'Escaped' ] ,
+]
+
+
+
+
+export default function parse ( string ){
+    
+    const tree = buildAST(parseNumbers(dropUnknown(normalizeStrings(toTokens(string)))));
+    
+    return Node.from(tree);
+}
+
+
+function buildAST ( tokens ){
+    
+    const root = { value : [] };
+    
+    let parent = root ,
+        stack = [] ;
+    
+    for ( const token of tokens ){
+        
+        const [ type , value ] = token;
+        
+        
+        // console.log(type,parent,stack)
+        
+        switch (type){
+        case 'String' :
+        case 'Number' :
+            parent.value.push(value);
+            continue
+        case 'Name' :
+        
+            const child = { name : value , value : [] };
+            parent.value.push(child);
+            
+            stack.push(parent);
+            parent = child;
+            
+            continue
+        case '}' :
+            
+            switch ( parent.value.length ){
+            case 0 :
+                parent.value = null;
+                break;
+            case 1 :
+                parent.value = parent.value[0];
+                break;
+            }
+            
+            parent = stack.pop();
+            continue
+        }
+    }
+    
+    
+    return root
+}
+
+
+function findToken ( string ){
+    
+    for ( const [ pattern , token , length ] of Tokens)
+        if(length){
+            if(pattern.test(string))
+                return [ token , length ]
+        } else {
+            
+            const value = string
+                .match(pattern)
+                ?.at(0);
+            
+            if(value)
+                return [ token , value.length , value ]
+        }
+}
+
+function * toTokens ( string ){
+    
+    while ( true ){
+        
+        matchNext:
+        
+        if(string.length < 1)
+            return
+            
+        const match = findToken(string);
+        
+        if(match){
+            
+            const [ token , take , value ] = match;
+            
+            yield [ token , value ]
+            
+            string = string.substring(take);
+            
+        } else {
+            yield [ 'Unknown' , string.at(0) ]
+            string = string.substring(1);
+        }
+    }
+}
+
+
+function * normalizeStrings ( tokens ){
+    
+    let combined , process ;
+
+
+    const normal = ( token ) => {
+        
+        const [ type ] = token;
+    
+        if(type === '"'){
+            process = string;
+            combined = '';
+            return
+        }
+        
+        return token
+    }
+    
+    
+    const string = ( token ) => {
+        
+        const [ type , value ] = token;
+        
+        if(type === '"'){
+            process = normal;
+            return [ 'String' , combined ]
+        }
+        
+        combined += value;
+    }
+    
+    
+    process = normal;
+    
+    for ( const token of tokens ){
+        
+        const value = process(token);
+        
+        if(value)
+            yield value
+    }
+}
+
+
+function * dropUnknown ( tokens ){
+    for ( const token of tokens )
+        if(token[0] !== 'Unknown')
+            yield token
+}
+
+
+function * parseNumbers ( tokens ){
+    
+    for ( const token of tokens ){
+        
+        const [ type , value ] = token;
+        
+        if(type === 'Number')
+            token[1] = parseFloat(value);
+            
+        yield token
+    }
+}