ig-serialize 1.0.5 → 1.1.0

package/README.md

@@ -65,6 +65,8 @@ Extensions to JSON:
 
 ### Recursion
 
+If an object is encountered 
+
 ### null types
 
 ### BigInt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-serialize",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "experimental extended json serializaion...",
   "main": "serialize.js",
   "scripts": {

package/serialize.js

@@ -51,9 +51,9 @@ var NAN = 'NaN'
 var INFINITY = 'Infinity'
 var NEG_INFINITY = '-Infinity'
 
-var RECURSIVE = '<RECURSIVE%>'
+var REFERENCE = '<REF%>'
 
-var FUNCTION = '<FUNCTION[%]>'
+var FUNCTION = '<FUNC[%]>'
 
 
 
@@ -77,7 +77,7 @@ var debug = {
 
 //---------------------------------------------------------------------
 
-module.STRING_LENGTH_REF = RECURSIVE.length * 8
+module.STRING_LENGTH_REF = REFERENCE.length * 8
 
 
 //
@@ -148,11 +148,11 @@ function(obj, path=[], seen=new Map(), indent, depth=0, options={}){
 		options.string_length_ref 
 			?? module.STRING_LENGTH_REF
 
-	// recursive...
+	// reference...
 	var p = seen.get(obj)
 	if(p != null){
 		// NOTE: _serialize(..) is always printed flat here, regardless of indent/depth...
-		return RECURSIVE.replace('%', _serialize(p)) }
+		return REFERENCE.replace('%', _serialize(p)) }
 
 	// functions...
 	// NOTE: we are storing function length to avoid parsing the function...
@@ -260,7 +260,7 @@ function(obj, indent, depth=0, options){
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
 
 // XXX better error handling...
-// XXX try and make this single stage (see notes for : .recursive(..))
+// XXX try and make this single stage (see notes for : .reference(..))
 var eJSON = 
 module.eJSON = {
 	chars: {
@@ -287,9 +287,9 @@ module.eJSON = {
 		NaN: NaN,
 
 		'<empty>': 'empty',
-		'<RECURSIVE': 'recursive',
+		'<REF': 'reference',
 
-		'<FUNCTION[': 'func',
+		'<FUNC[': 'func',
 	},
 	
 
@@ -413,7 +413,7 @@ module.eJSON = {
 		var mode = 'dec'
 		if(str[j] == '0' 
 				&& 'xXbBoO'.includes(str[j+1])){
-			mode = str[j+1]
+			mode = str[j+1].toLowerCase()
 			j++ }
 		j++
 		while(j < str.length
@@ -432,6 +432,7 @@ module.eJSON = {
 					// exponent...
 					|| str[j] == 'e'
 						|| str[j] == 'E')){
+			// exponent sign...
 			if('eE'.includes(str[j]) 
 				&& '+-'.includes(str[j+1])){
 				j++ }
@@ -613,15 +614,15 @@ module.eJSON = {
 	// 		directly reference that -- this would eliminate the need for 
 	// 		stage two... (XXX TEST)
 	// 		...need to use serialized paths as keys...
-	recursive: function(state, path, match, str, i, line){
-		debug.lex('recursive', str, i, line)
+	reference: function(state, path, match, str, i, line){
+		debug.lex('reference', str, i, line)
 		return this.sequence(
 			state, path, str, i+match.length, line, 
 			'>',
 			function(res, index, str, i, line){
 				var obj
 				;[obj, i, line] = this.array(state, [...path, index], '[', str, i, line)
-				var rec = state.recursive ??= []
+				var rec = state.reference ??= []
 				rec.push([path, obj])
 				return [{}, i, line] }) },
 
@@ -694,8 +695,8 @@ module.eJSON = {
 		var state = {functions: options.functions}
 		var res = this.value(state, [], str)[0] 
 
-		// stage 2: link the recursive structures...
-		for(var [a, b] of state.recursive ?? []){
+		// stage 2: link the reference structures...
+		for(var [a, b] of state.reference ?? []){
 			this.setItem(res, a, this.getItem(res, b)) }
 
 		return res },

package/test.js

@@ -49,6 +49,8 @@ var setups = test.Setups({
 	//	return ['+123', json] },
 	'number-exp': function(assert){
 		return ['1e+100', json] },
+	'number-exp-neg': function(assert){
+		return ['1e-100', json] },
 	'number-zero': function(assert){
 		return ['0', json] },
 	'float-a': function(assert){
@@ -98,19 +100,19 @@ var setups = test.Setups({
 		return ['Map([])'] },
 
 	'function': function(assert){
-		return ['<FUNCTION[14,(function(){})]>'] },
+		return ['<FUNC[14,(function(){})]>'] },
 
 	// recursive...
 	'array-recursive': function(assert){
-		return ['[<RECURSIVE[]>]'] },
+		return ['[<REF[]>]'] },
 	'object-recursive': function(assert){
-		return ['{"r":<RECURSIVE[]>}'] },
+		return ['{"r":<REF[]>}'] },
 	'set-recursive': function(assert){
-		return ['Set([<RECURSIVE[]>])'] },
+		return ['Set([<REF[]>])'] },
 	'map-recursive-key': function(assert){
-		return ['Map([[<RECURSIVE[]>,"value"]])'] },
+		return ['Map([[<REF[]>,"value"]])'] },
 	'map-recursive-value': function(assert){
-		return ['Map([["key",<RECURSIVE[]>]])'] },
+		return ['Map([["key",<REF[]>]])'] },
 })
 
 test.Modifiers({
@@ -204,19 +206,33 @@ test.Cases({
 		['123.', '123'],
 		['+123', '123'],
 		['123e100', '123e+100'],
+		['123E100', '123e+100'],
 		['0xff', '255'],
+		['0Xff', '255'],
+		['0o77', '63'],
+		['0O77', '63'],
+		['0b11', '3'],
+		['0B11', '3'],
+		// XXX
+		//['010', '8'],
+		//['080', '80'],
 
 		// string quotes...
 		["'abc'", '"abc"'],
 		['`abc`', '"abc"'],
+		/* XXX test new lines...
+		[`\`a
+			b
+			c\``, '"a\\nb\\nc"'],
+		//*/
 
 		// arrays...
 		['[1,2,]', '[1,2]'],
 
 		// sparse arrays...
-		['[<empty>]', '[,]'],
-		['[1,2,<empty>]', '[1,2,,]'],
-		['[1,2,<empty>]', '[1,2,<empty>,]'],
+		['[,]', '[<empty>]'],
+		['[1,2,,]', '[1,2,<empty>]'],
+		['[1,2,<empty>,]', '[1,2,<empty>]'],
 	],
 	'syntax-simplifications': function(assert){
 		var aa, bb