node-red-contrib-prib-functions 0.21.0 → 0.23.2

package/lib/objectExtensions.js

@@ -1,71 +1,54 @@
-if(!Array.prototype.move)
-    Array.prototype.move = function(from, to) {
-         if(from<to) to--;
-         this.splice(to, 0, this.splice(from, 1)[0]);
-     };
-if(!Number.prototype.between)
-    Number.prototype.between  = function (min, max) {
-         return !(this < min || this > max);
-     };
-if(!String.prototype.in)
-    String.prototype.in = function (str) {
-         for (var i = 0; i < arguments.length; i++)
-             if(this==arguments[i]) return true;
-         return false;
-        };
-if(!String.prototype.startsWith)
-    String.prototype.startsWith = function (str) {
-         return this.slice(0, str.length) == str;
-        };
-if(!String.prototype.toTitle)
-    String.prototype.toTitle = function () {
-         var title=this.substr(0,1).toUpperCase()
-             ,lastLowerCase=false;
-         for(var i=1 ; i<this.length; i++ ) {
-             char=this.substr(i,1);
-             if(char==char.toUpperCase()) {
-                 if(lastLowerCase) title+=' ';
-                 lastLowerCase=false;
-                 if(char=='_') continue;
-                 if(char==' ') continue;
-             } else lastLowerCase=true;
-             title+=char;
-         }
-         return title;
-       };
-if(!String.prototype.to)
-    String.prototype.to = function (type) {
-        if (this==null) return null;
-        if (type==null) return value;
-        return this['to'+type.capitalize()];
+const defineMethod=(object,name,call)=>{
+    if(name in object.prototype) return
+    try{
+        Object.defineProperty(object.prototype, name, {
+            enumerable: false,
+              value: call
+        }) 
+    } catch(ex){
+        console.error("defining "+name,ex.message)
     }
-if(!String.prototype.toReal)
-    String.prototype.toReal = function () {
-        return parseFloat(this);
-    };
-if(!String.prototype.toInt)
- String.prototype.toInt = function () {
-        return parseInt(this);
-    };
-if(!String.prototype.toTimestamp)
-    String.prototype.toTimestamp = function () {
-        return Date.parse(this.substr(0,4)+'/'+this.substr(5,2)+'/'+this.substr(8,11))
-         + parseInt(this.substr(21,3));
-    };
-if(!String.prototype.toTime)
-    String.prototype.toTime = function () {
-        return  Date.parse(this);
-    };
-if(!String.prototype.toDatetime)
-    String.prototype.toDatetime = String.prototype.toTime;
-if(!String.prototype.toDate)
-    String.prototype.toDate = String.prototype.toTime;
-if(!String.prototype.CRLF2BR)
-    String.prototype.CRLF2BR = function () {
-        return  this.replace("\n\r","<br/>").replace("\n","<br/>");
-    };
+}
+const toDateType=aDate=>aDate instanceof Date? aDate : new Date(Date.parse(aDate))
+const toDateTypeZulu=aDate=>aDate instanceof Date? aDate : new Date(aDate)
+defineMethod(Array,'move',function(from, to) {
+    if(from<to) to--
+    this.splice(to, 0, this.splice(from, 1)[0])
+})
+defineMethod(String,"in",function (...str) {
+    for (var i = 0; i < arguments.length; i++)
+        if(this==arguments[i]) return true
+   return false
+})
+defineMethod(String,"capitalize",function() {return this.charAt(0).toUpperCase() + this.slice(1)})
+defineMethod(String,"toCapitalized",function() {return this.charAt(0).toUpperCase() + this.slice(1)})
+defineMethod(String,"to",function (type) {
+    if(type==null) return value
+    return this['to'+type.capitalize()]
+})
+defineMethod(String,"toReal",function (){return parseFloat(this)})
+defineMethod(String,"toTitle", function (){return this.replace(/\w\S*/g, text => text.capitalize())})
+
+defineMethod(String,"toTitleGrammatical", function (){   
+    const lowerCaseList = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'as', 'at', 
+        'by', 'from', 'in', 'into', 'of', 'on', 'onto', 'to', 'with', 'yet', 'so','upon', 'like', 'over', 'plus', 'up', 'down', 'off', 'near'];
+    const title=this.replace(/\p{L}+/gu, (word)=>{
+        const wordLowerCase=word.toLowerCase()
+        return lowerCaseList.includes(wordLowerCase) ? wordLowerCase : word.capitalize()
+    })
+    return title.capitalize()
+})
 
-Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this.length - 1) {
+defineMethod(String,"toInt",function() {return parseInt(this)})
+if(!String.prototype.toInt) String.prototype.toInteger=String.prototype.toInt
+defineMethod(String,"toTimestamp",function () {
+    return Date.parse(this.substring(0,4)+'/'+this.substring(5,2)+'/'+this.substring(8,11))
+         + parseInt(this.substring(21,3));
+})
+defineMethod(String,"toTime",function () {return  Date.parse(this)})
+defineMethod(String,"CRLF2BR", function(){return  this.replace("\n\r","<br/>").replace("\n","<br/>")})
+
+defineMethod(Array,"findSorted",function(searchElement,minIndex = 0,maxIndex = this.length - 1) {
     let currentIndex, currentElement
     while(minIndex <= maxIndex) {
         currentIndex = (minIndex + maxIndex) / 2 | 0
@@ -77,8 +60,8 @@ Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this
         } else return currentIndex
     }
     return -minIndex
- }
- Array.prototype.addSorted = function(element) {
+ })
+ defineMethod(Array,"addSorted",function(element) {
    if(this.length){
     const position = -this.findSorted(element)
     if(position<0 ) return -position
@@ -87,15 +70,16 @@ Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this
    }
    this.push(element)
    return 0
-}
-Object.prototype.addList = function(property,object) {
+})
+
+defineMethod(Object,"addList",function(property,object) {
     try{
         this[property].push(object)
     } catch(ex) {
         this[property]=[object]
     }
-}
-Object.prototype.addErrorFunctions = function(){ 
+})
+defineMethod(Object,"addErrorFunctions",function(){ 
     this.onError=function(call){
         if(this.errorStack) this.errorStack.push(call)
         else this.errorStack=[this.call]
@@ -113,8 +97,9 @@ Object.prototype.addErrorFunctions = function(){
         if(typeof ex == "string") throw Error(ex)
         throw ex
     }
-}
-if(!colourSmallList) var colourSmallList={
+})
+
+const colourSmallList={
     "Red":'#FF0000',
     "Turquoise":'#00FFFF',
     "Grass Green":'#408080',
@@ -132,7 +117,7 @@ if(!colourSmallList) var colourSmallList={
     "Light Purple":'#FF0080',  	 	
     "Dark Grey":'#808080'
 }
-if(!colours) var colours ={
+const colours ={
     AliceBlue: '#F0F8FF',
     AntiqueWhite: '#FAEBD7',
     Aqua: '#00FFFF',
@@ -282,8 +267,7 @@ if(!colours) var colours ={
     Yellow: '#FFFF00',
     YellowGreen: '#9ACD32'
 }
-
-String.prototype.csvLine=function(delimiter=",",quote='"'){
+defineMethod(String,"csvLine",function(delimiter=",",quote='"'){
     let i=this.length,j=i,charInQuote,result=[]
     if(i==0) return result
     delimiter:while(i--){
@@ -317,9 +301,8 @@ String.prototype.csvLine=function(delimiter=",",quote='"'){
     const v=this.substring(i+1,j)
     result.unshift(v.length?isNaN(v)? v : Number(v):null)
     return result
-}
-
-String.prototype.csvFile=function(delimiter=",",quote='"'){
+})
+defineMethod(String,"csvFile",function(delimiter=",",quote='"'){
     let i=this.length,j=i,charInQuote,result=[],line=[]
     if(i==0) return result
     line:while(i--){
@@ -358,4 +341,131 @@ String.prototype.csvFile=function(delimiter=",",quote='"'){
         result.unshift(line)
     }
     return result
+})
+
+defineMethod(Date,"isBetween",function(min, max) {return !(this < toDateType(min) || this > toDateType(max))}) 
+defineMethod(Number,"isBetween",function(min, max) {return !(this < min || this > max)})
+defineMethod(String,"isBetween",function(min, max) {return !(this < min || this > max)})
+defineMethod(Object,"toSimpleArray",function(prefix) {
+	const returnValue=[]
+	for (let property in this) {
+		if(this[property]==null || this[property].enumerable==null || this[property].enumerable)
+		  	returnValue.push([(prefix?prefix:"")+property,this[property],typeof this[property]])
+		}
+	return returnValue
+})
+defineMethod(Object,"toSimpleArrayIgnoreNulls",function(prefix) {
+	const returnValue=[]
+	for (let property in this) {
+		if(this[property]==null ) continue
+		if(this[property].enumerable==null || this[property].enumerable)
+		  	returnValue.push([(prefix?prefix:"")+property,this[property],typeof this[property]])
+		}
+	return returnValue
+})
+
+defineMethod(String,"in",function () {
+	for (let i = 0; i < arguments.length; i++)
+		if(this.toString()===arguments[i]) return true;
+	return false
+})
+defineMethod(String,"startsWithList",function () {
+	for (var i = 0; i < arguments.length; i++)
+		if(this.slice(0, arguments[i].length)===arguments[i]) return true
+	return false
+})
+defineMethod(String,"startsWithListAnyCase",function (...list) {
+	for (var i = 0; i < list.length; i++){
+        const testString=list[i].toLowerCase()
+		if(this.slice(0, testString.length).toLowerCase()==testString) return true
+    }
+	return false
+})
+defineMethod(String,"xmlStringEncode",function() {
+	return this.toString().replace(/([\&"<>])/g, function(str, item) {
+		return {
+			'&': '&amp;',
+			'"': '&quot;',
+			'<': '&lt;',
+			'>': '&gt;'
+		}[item]
+	});
+})
+
+defineMethod(Number,"toAbbreviated",function() {
+    const digits=(v,e)=>{
+        const nv=v/Math.pow(10,e)
+        const anv=Math.abs(nv)
+        if(anv<10)   return nv.toFixed(2).toString()    
+        if(anv<100)   return nv.toFixed(1).toString()
+        return nv.toFixed(0).toString()    
+    }
+    const a=Math.abs(this)
+	if(a>Math.pow(10,15)) return digits(this,15)+'P'
+	if(a>Math.pow(10,12)) return digits(this,12)+'T'
+	if(a>Math.pow(10,9)) return digits(this,9)+'G'
+	if(a>Math.pow(10,6)) return digits(this,6)+'M'
+	if(a>Math.pow(10,3)) return digits(this,3)+'K'
+	return digits(this,0)
+})
+
+defineMethod(BigInt,"toAbbreviated",function() {
+    const digits=(v,e)=>{
+        const nv=v/Math.pow(10,e)
+        const anv=Math.abs(nv)
+        if(anv<10)   return nv.toFixed(2).toString()    
+        if(anv<100)   return nv.toFixed(1).toString()
+        return nv.toFixed(0).toString()    
+    }
+    const a=Math.abs(this)
+	if(a>Math.pow(10,15)) return digits(this,15)+'P'
+	if(a>Math.pow(10,12)) return digits(this,12)+'T'
+	if(a>Math.pow(10,9)) return digits(this,9)+'G'
+	if(a>Math.pow(10,6)) return digits(this,6)+'M'
+	if(a>Math.pow(10,3)) return digits(this,3)+'K'
+	return digits(this,0)
+})
+
+
+defineMethod(String,"getWord",function(wordPosition) {return this.split(/\s+/g,wordPosition+1)[wordPosition-1]??""})
+
+const coalesce=(...args)=>{
+	for (var i=0; i<args.length; ++i)
+ 		if (args[i] !=  null) return args[i]
+	return null; 
 }
+const nullif=(a,b)=>{return a==b?null:a}
+//missing Float16Array,
+[ArrayBuffer,Number,Boolean,BigInt,Date,String,Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,BigInt64Array,BigUint64Array,Float32Array,Float64Array].forEach(type=>{
+  defineMethod(type,"deepClone",function(){ return new type(this)})
+})
+
+
+//defineMethod(TypedArray,"deepClone",function(){ return new type(this)})
+defineMethod(Array,"deepClone",function(){
+    const clone=[]
+	for (let i in this)
+		clone[i]=this[i].deepClone()
+    return clone
+})
+defineMethod(Object,"deepClone",function(){
+    const clone={}
+	for (let i in this)
+		clone[i]=this[i].deepClone()
+    return clone
+})
+defineMethod(Number, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(BigInt, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(Date, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(String, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(String,"deunderscore",function(){return this.replace(/_/g," ")})
+defineMethod(String,"deunderscoreCapitilize",function(){return this.replace(/_/g," ").toTitle()})
+defineMethod(String,"dropSquareBracketPrefix",function(bracket="[",endBracket="]"){return (this.substr(0,1)==bracket)? this.split(endBracket+" ")[1] : this})
+module.exports={
+    coalesce:coalesce,
+    colours:colours,
+    colourSmallList:colourSmallList,
+    nullif:nullif,
+    toDateType,
+    toDateTypeZulu,
+}

package/lib/typedInput.js

@@ -0,0 +1,77 @@
+
+const setGetFunction=(RED,node,propertyName)=>node["get"+propertyName[0].toUpperCase() + propertyName.slice(1)]=getFunction(RED,node,propertyName)
+
+const getFunction=(RED,node,propertyName)=>{
+	try{
+		const property=node[propertyName];
+		if(property==null) throw Error("no value for "+propertyName);
+		const propertyType=propertyName+"Type";
+		if(! (propertyType in node)) return eval("()=>node."+property)
+        const type=node[propertyType]
+		switch (type){
+        case "bin": //	a Node.js Buffer
+        case "re": //	a Regular Expression
+        case "jsonata": //	a Jsonata Expression
+        case "cred": //	a secure credential
+        case "bool":
+        case "json":
+        case "num":
+        case "str":
+        case "date": //	the current timestamp
+        case "env":
+        case "global":
+            const value=RED.util.evaluateNodeProperty(property, type, node)
+            return eval("()=>value")
+        case "flow":
+            const flow = node.context().flow;
+			if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+			return eval("()=>flow.get("+property+")");
+        case "msg":
+			return eval("(msg)=>msg."+property);
+        case "node":
+            const nodeContext = node.context();
+            return eval("()=>nodeContext.get("+property+")");
+        default:
+			throw Error("unknown type "+node[propertyType])
+		}
+	} catch(ex) {
+		throw Error(propertyName+" "+ex.message);
+	}
+    
+}
+const setFunction=(RED,node,name)=>{
+    if(!name) 
+    if(!node.hasOwnProperty(name)) throw Error("name is null")
+    if(!node.hasOwnProperty(name+"-type")) {
+        node.set[name]=eval("data=>msg.payload['"+name+"']=data)")
+        return
+    }
+    const type=node[name+"t-type"]
+    switch(type){
+        case "node":
+        node.set[name]=eval("data=>node.context().set("+node[name]+",data)")
+            break
+        case "flow":
+            const flow=node.context().flow
+            if(flow) throw Error("context store may be memory only so flow doesn't work")
+            node.set[name]=eval("data=>flow.set("+node[name]+",data)")
+            break
+        case "global":
+            node.set[name]=eval("data=>nodeContext.global.set("+node[name]+",data)")
+            break
+        case "msg":
+            node.set[name]=eval("(data,msg)=>{msg."+node[name]+"=data;}")
+            break
+        default:
+            throw Error("setData unknown type "+type)
+    }
+}
+
+const getValue=(RED,node,propertyName,defaultValue)=>propertyName in node?getFunction(RED,node,propertyName)():defaultValue
+
+module.exports={
+    getFunction:getFunction,
+    setFunction:setFunction,
+    setGetFunction:setGetFunction,
+    getValue:getValue
+}

package/matrix/matrixNode.html

@@ -146,7 +146,8 @@
 
 			defineProperty({name:"dataType",label:"number Type"	,icon:"tag"},[
 				{ value: "Float32Array", label: "float32	-3.4e38 to 3.4e38" },
-				{ value: "Float64Array", label: "double/float64	-1.8e308 to 1.8e308" },				{ value: "Int8Array", label: "byte -128 to 122" },
+				{ value: "Float64Array", label: "double/float64	-1.8e308 to 1.8e308" },
+				{ value: "Int8Array", label: "byte -128 to 122" },
 				{ value: "Uint8Array", label: "octet 0 to 255" },
 				{ value: "Uint8ClampedArray", label: "octet clamped 0 to 255" },
 				{ value: "Int16Array", label: "short -32768 to 32767" },

package/package.json

@@ -1,26 +1,26 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.21.0",
+	"version": "0.23.2",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
 		"avsc": ">=5.7.7",
 		"compressiontool": "*",
-		"fast-xml-parser": "^4.2.5",
-		"node": ">=0.6.13",
+		"fast-xml-parser": "^5.2.1",
+		"node": ">=22.15.0",
 		"node-red-contrib-logger": "latest",
 		"node-red-contrib-noderedbase": ">=0.0.16",
 		"node-red-contrib-prib-functions": "file:",
-		"npm": "^10.9.0",
+		"npm": "^11.3.0",
 		"xlsx": "*"
 	},
 	"devDependencies": {
-		"@node-red/runtime": ">=1.2.8",
-		"axios": ">=0.21.1",
-		"bcrypt": "^5.0.1",
-		"bl": "^5.0.0",
-		"mocha": "^9.2.2",
-		"node-red": "^3.0.2",
-		"node-red-node-test-helper": "^0.3.0"
+		"@node-red/runtime": ">=4.0.9",
+		"axios": ">=1.9.0",
+		"bcrypt": "^5.1.1",
+		"bl": "^6.1.0",
+		"mocha": "^11.2.2",
+		"node-red": ">=4.0.9",
+		"node-red-node-test-helper": ">=0.3.4"
 	},
 	"scripts": {
 		"test": "mocha \"test/dataAnalysisE*.js\"",
@@ -38,6 +38,8 @@
 		"adjoint",
 		"append",
 		"analysis",
+		"autocorrelation",
+		"autocovariance",
 		"average",
 		"avg",
 		"AVRO",
@@ -115,6 +117,7 @@
 		"system",
 		"testing",
 		"test",
+		"tensor",
 		"translate",
 		"transform",
 		"transpose",

package/test/00-objectExtensions.js

@@ -1,6 +1,6 @@
 const assert=require('assert');
 const should=require("should");
-require("../lib/objectExtensions");
+const {coalesce,nullif}=require("../lib/objectExtensions");
 
 describe('/lib/objectExtensions array ', function() {
 	it("array find sorted empty set", function(done) {
@@ -92,3 +92,194 @@ describe('/lib/objectExtensions csvLine', function() {
         done()
     })
 })
+describe('/lib/objectExtensions number', function() {
+	it("isBetween", function(done) {
+        assert.deepStrictEqual(Number(1).isBetween(0,1),true)
+        assert.deepStrictEqual(Number(0).isBetween(0,1),true)
+        assert.deepStrictEqual(Number(-1).isBetween(0,1),false)
+        assert.deepStrictEqual(Number(2).isBetween(0,1),false)
+        done()
+    })
+	it("toSimpleArray", function(done) {
+        assert.deepStrictEqual({}.toSimpleArray(),[])
+        assert.deepStrictEqual({a:1,b:"2"}.toSimpleArray(),[["a",1,"number"],["b","2","string"]])
+        done()
+    })
+	it("toSimpleArrayIgnoreNulls", function(done) {
+        assert.deepStrictEqual({}.toSimpleArrayIgnoreNulls(),[])
+        assert.deepStrictEqual({a:1,b:"2"}.toSimpleArrayIgnoreNulls(),[["a",1,"number"],["b","2","string"]])
+        assert.deepStrictEqual({a:1,b:"2",c:null}.toSimpleArrayIgnoreNulls(),[["a",1,"number"],["b","2","string"]])
+        done()
+    })
+    it("in", function(done) {
+        assert.deepStrictEqual("abc".in(),false)
+        assert.deepStrictEqual("abc".in("abc"),true)
+        assert.deepStrictEqual("abc".in("abc","c"),true)
+        assert.deepStrictEqual("abc".in("a","abc","c"),true)
+        assert.deepStrictEqual("abc".in("a","no","c"),false)
+        done()
+    })
+    it("startsWithList", function(done) {
+        assert.deepStrictEqual("abc".startsWithList("a"),true)
+        assert.deepStrictEqual("Abc".startsWithList("a"),false)
+        assert.deepStrictEqual("abc".startsWithList("b","ab"),true)
+        assert.deepStrictEqual("abc".startsWithList("c"),false)
+        done()
+    })
+    it("startsWithListAnyCase", function(done) {
+        assert.deepStrictEqual("abc".startsWithListAnyCase("a"),true)
+        assert.deepStrictEqual("Abc".startsWithListAnyCase("a"),true)
+        assert.deepStrictEqual("aBc".startsWithListAnyCase("b","ab"),true)
+        assert.deepStrictEqual("abc".startsWithListAnyCase("c"),false)
+        done()
+    })
+    it("toAbbreviated", function(done) {
+        const test=(n,a)=>{
+            const t=n.toAbbreviated()
+            console.log(n+" => "+t+" s/be "+a)
+            assert.deepStrictEqual(t,a)
+        }
+        test(0,"0.00")
+        test(1,"1.00")
+        test(-1,"-1.00")
+        test(0.1,"0.10")
+        test(1.1234567,"1.12")
+        test(1001.0,"1.00K")
+        test(-1001.0,"-1.00K")
+        test(1011.0,"1.01K")
+        test(-1011.0,"-1.01K")
+        test(2011000.1,"2.01M")
+        test(2011002003,"2.01G")
+        test(2011002003004,"2.01T")
+        test(2011002003004005,"2.01P")
+        done()
+    })
+    it("xmlStringEncode", function(done) {
+        assert.deepStrictEqual("a&c".xmlStringEncode("a"),"a&c")
+        assert.deepStrictEqual("a\"c".xmlStringEncode("a"),"a"c")
+        assert.deepStrictEqual("a<>c".xmlStringEncode("a"),"a&lt;&gt;c")
+        done()
+    })
+    it("getWord", function(done) {
+        assert.deepStrictEqual("".getWord(1),"")
+        assert.deepStrictEqual("one two three".getWord(1),"one")
+        assert.deepStrictEqual("one two three".getWord(2),"two")
+        assert.deepStrictEqual("one two three".getWord(3),"three")
+        assert.deepStrictEqual("one two three".getWord(4),"")
+        done()
+    })
+    it("coalesce", function(done) {
+        const anull=null,notanull="notnull"
+        assert.deepStrictEqual(coalesce(anull,"test"),"test")
+        assert.deepStrictEqual(coalesce(notanull,"test"),"notnull")
+        done()
+    })
+    it("nullif", function(done) {
+        const anull="test",notanull="notnull"
+        assert.deepStrictEqual(nullif(anull,"test"),null)
+        assert.deepStrictEqual(nullif(notanull,"test"),"notnull")
+        done()
+    })
+    it("deepClone", function(done) {
+        const n=new Number(1)
+        const s=new String("astring")
+        const a=[s,n,[,s,n]]
+        assert.deepStrictEqual({}.deepClone(),{})
+        assert.deepStrictEqual([].deepClone(),[])
+        assert.deepStrictEqual(n.deepClone(),n)
+        assert.deepStrictEqual(s.deepClone(),s)
+        assert.deepStrictEqual(a.deepClone(),a)
+        done()
+    })
+    it("rangeLimit", function(done) {
+        const test=(type,min,max,value,result)=>{
+            const typedValue=new type(value)
+            assert.deepStrictEqual(typedValue.rangeLimit(new type(min),new type(max)),new type(result))
+        }
+        test(Number,2,4,1,2)
+        test(Number,2,4,2,2)
+        test(Number,2,4,3,3)
+        test(Number,2,4,4,4)
+        test(Number,2,4,5,4)
+
+        const test2=(type,min,max,value,result)=>{
+            const typedValue=type(value)
+            const typedResult=type(result)
+            const typedMin=type(min)
+            const typeMax=type(max)
+            assert.equal(typedValue.rangeLimit(typedMin,typeMax),typedResult)
+        }
+
+        test2(BigInt,2,4,1,2)
+        test2(BigInt,2,4,2,2)
+        test2(BigInt,2,4,3,3)
+        test2(BigInt,2,4,4,4)
+
+        test2(Date,"2/2/2022","4/2/2022","1/2/2022","2/2/2022")
+        test2(Date,"2/2/2022","4/2/2022","2/2/2022","2/2/2022")
+        test2(Date,"2/2/2022","4/2/2022","3/2/2022","3/2/2022")
+        test2(Date,"2/2/2022","4/2/2022","4/2/2022","4/2/2022")
+        test2(Date,"2/2/2022","4/2/2022","5/2/2022","4/2/2022")
+
+        test2(String,"bb","bcd","aa","bb")
+        test2(String,"bb","bcd","bb","bb")
+        test2(String,"bb","bcd","bc","bc")
+        test2(String,"bb","bcd","bcd","bcd")
+        test2(String,"bb","bcd","bce","bcd")
+        done()
+    })
+    it("capitalize", function(done) {
+        assert.equal("".capitalize(),"")
+        assert.equal("abc".capitalize(),"Abc")
+        assert.equal("aBcd".capitalize(),"ABcd")
+        done()
+    })
+    it("toTitle", function(done) {
+        assert.equal("".toTitle(),"")
+        assert.equal("abc".toTitle(),"Abc")
+        assert.equal("aBcd".toTitle(),"ABcd")
+        assert.equal("aBcd def".toTitle(),"ABcd Def")
+        done()
+    })
+    it("toTitleGrammatical", function(done) {
+        assert.equal("to be or not to be".toTitleGrammatical(),"To Be or Not to Be")
+        assert.equal("a small dog".toTitleGrammatical(),"A Small Dog")
+        done()
+    })
+    it("deunderscore", function(done) {
+        assert.equal("abc_def_".deunderscore(),"abc def ")
+        done()
+    })
+    it("deunderscoreCapitilize", function(done) {
+        assert.equal(" abc_def_".deunderscoreCapitilize()," Abc Def ")
+        done()
+    })
+    it("dropSquareBracketPrefix", function(done) {
+        assert.equal("[abc] def".dropSquareBracketPrefix(),"def")
+        done()
+    })
+})
+describe('/lib/objectExtensions string', function() {
+	it("isBetween", function(done) {
+        assert.deepStrictEqual("a".isBetween("b","de"),false)
+        assert.deepStrictEqual("f".isBetween("b","de"),false)
+        assert.deepStrictEqual("b".isBetween("b","de"),true)
+        assert.deepStrictEqual("c".isBetween("b","de"),true)
+        assert.deepStrictEqual("d".isBetween("b","de"),true)
+        assert.deepStrictEqual("de".isBetween("b","de"),true)
+        assert.deepStrictEqual("df".isBetween("b","de"),false)
+        done()
+    })
+})
+describe('/lib/objectExtensions Date', function() {
+	it("isBetween", function(done) {
+        const aDate=new Date("2025/05/02")
+        assert.deepStrictEqual(aDate.isBetween("2025/05/01","2025/05/03"),true)
+        assert.deepStrictEqual(aDate.isBetween(new Date("2025/05/01"),new Date("2025/05/03")),true)
+        assert.deepStrictEqual(aDate.isBetween("2025/05/02","2025/05/03"),true)
+        assert.deepStrictEqual(aDate.isBetween("2025/05/01","2025/05/02"),true)
+        assert.deepStrictEqual(aDate.isBetween("2025/04/01","2025/05/01"),false)
+        assert.deepStrictEqual(aDate.isBetween("2025/05/03","2025/06/01"),false)
+        done()
+    })
+})