node-red-contrib-prib-functions 0.14.2 → 0.17.0

package/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '35 18 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

package/.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+    "recommendations": [
+        "bibhasdn.git-easy",
+        "github.vscode-pull-request-github"
+    ]
+}

package/README.md

@@ -50,6 +50,11 @@ Array metrics:
 * Normalise
 * Standardization (Z-score Normalization)
 
+Array data
+* distances 
+* minimum distance(s) between points
+* maximum distance(s) between points
+
 ![Data Analysis](documentation/DataAnalysis.JPG "Data Analysis")
 
 example:
@@ -154,7 +159,7 @@ Test example:
 
 The levenshtein distance between two character strings.
 
-![Levenshtein Distance](documentation/levenshteinDistance.JPG "Levenshtein Distance")
+![Levenshtein Distance](documentation/levenshteinDistance.jpg "Levenshtein Distance")
 
 ------------------------------------------------------------
 
@@ -242,6 +247,12 @@ Test/example flow in test/generalTest.json
 
 # Version
 
+0.17.0 Add finished wire to load injector
+
+0.16.10 data analysis add eulcidean distance functions. Add array pairs
+
+0.16.0 fix data analysis variance and stddev, add sample, add tests
+
 0.14.2 fix general test flows. Add icon for data analysis
 
 0.14.1 fix capitalization issue with levenshtein Distance
@@ -256,40 +267,6 @@ Test/example flow in test/generalTest.json
 
 0.11.0 Transform for AVRO and snappy.  Add JSON to CSV 
 
-0.10.2 Transform validate for array source, bug fixes on transform and add improvements to array to messages. Added node for levenshtein distance.
-
-0.10.1 Real time weighted moving average, levenshtein Distance, for test allow testing of "infinity","-infinity" and "NaN" in JSON.
-
-0.10.0 Many fixes to transform.  Array and csv to various forms work.  Added test to validate.
-Improved test to allow for escape to put special characters into a string.
-
-0.9.6 Enhance transform with csv ignore lead or trailing lines.
-Add Array and CSV to Messages. Add in topic override
-
-0.9.5 Enhance transform with path and setting source and target.
-Outlier allowed to set number of deviations if median and reset or set stats
-Add outlier detection and Pearson R realtime metrics.
-
-0.8.1 Add realtime metrics to data analysis. 
-
-0.7.1
-* fix json to table html and minor code improvements.
-turn off debug mode on spawn process.
-clear down timer on close for host available
-* add Host Available
-
-0.6.0
-* add Spawn Process
-* improve experimental transform with json to table html
-
-0.5.0
-* test node add select property tested for result
-* dataAnalysis add property analysed 
-* add experimental transform
-
-0.4.0 Add test, monitor flow, data analysis
-
-0.0.1 base
 
 # Author
 

package/dataAnalysis/arrayLast.js

@@ -0,0 +1,8 @@
+if(Array.prototype.last==null)
+	Object.defineProperty(Array.prototype, "last", {
+		value() {
+			return this[this.length-1];
+		},
+		writable: true,
+		configurable: true
+	});

package/dataAnalysis/arrayPairs.js

@@ -0,0 +1,15 @@
+if(Array.prototype.pairs==null)
+	Array.prototype.pairs=function (func) {
+		const l=this.length,li=l-1;
+		if(func) {
+			for (let i=0; i<li ; i++) {
+				for (let j =i+1; j<l; j++) {
+					func(this[i], this[j],i,j,this);
+				}
+			}
+		} else {
+			const r=[];
+			this.pairs(func===null? (p1,p2,i1,i2)=>r.push([p1,p2,i1,i2]) : (p1,p2)=>r.push([p1,p2]) )
+			return r;
+		}
+	}

package/dataAnalysis/dataAnalysis.html

@@ -6,6 +6,7 @@
         defaults: {
             name: {value:"",required:false},
 		    action: {value:"avg",required:true},
+		    columns:{value:"",required:false},
 		    outputs: {value:(["realtime","realtimePredict"].includes(this.action)?3:2),required:true},
 		    outliersBase: {value:"avg",required:false},
 		    outliersStdDevs: {value:"3",required:false},
@@ -44,6 +45,11 @@
         		}
            	});
 	       	$("#node-input-action").change(function() {
+        		 if(["distances","distancesMax","distancesMin"].includes( $(this).val() )) {
+        			$(".form-row-http-in-columns").show(); 
+        		 } else {
+        			$(".form-row-http-in-columns").hide();
+        		 }
         		 if(["movingAvgSimple","movingAvgWeighted","movingAvgExponential","realtime","realtimePredict"].includes( $(this).val() )) {
         			$(".form-row-http-in-term").show(); 
         		 } else {
@@ -142,6 +148,9 @@
             <option value="corelationship">Corelationship</option>
             <option value="deltas">Deltas</option>
             <option value="deltaNormalised">Deltas Normalised</option>
+            <option value="distances">Euclidean Distances</option>
+            <option value="distancesMax">Euclidean Distances Max</option>
+            <option value="distancesMin">Euclidean Distances Min</option>
             <option value="pearsonR">Linear Correlation Coefficient</option>
             <option value="max">Maximum</option>
             <option value="avg">Mean</option>
@@ -158,12 +167,19 @@
             <option value="realtimePredict">RealTime Metrics + predicts</option>
             <option value="standardize">Standardization (Z-score Normalization)</option>
             <option value="stdDev">Standard Deviation</option>
+            <option value="sampleStdDev">Standard Deviation (Sample)</option>
             <option value="skew">Skewness</option>
             <option value="sum">Sum</option>
             <option value="variance">Variance</option>
+            <option value="sampleVariance">Variance (Sample)</option>
         </select>
     </div>
 
+    <div class="form-row form-row-http-in-columns hide">
+        <label for="node-input-columns"><i class="icon-bookmark"></i> Columns</label>
+        <input type="text" id="node-input-columns" placeholder="columns">
+    </div>
+
     <div class="form-row form-row-http-in-term hide">
         <label for="node-input-term"><i class="icon-bookmark"></i> Term</label>
         <input type="number" id="node-input-term" placeholder="term" min="2" max="100" step="1">
@@ -229,4 +245,8 @@ If real-time stats then a message can send directive instruction in topic:
 			<li>3 standard deviations of the mean (or median), around 99.7%
 		</ul>	
 	</p>
+	<p>
+	Distance functions take in an array of points in an array and calculates the euclidean distance.
+	e.g. max input [ [1,1],[2,2],[3,3],[4,5]]), has output [{distance:5,points:[[1,1],[4,5]],index:[0,3]}]
+	</p>
 </script>

package/dataAnalysis/dataAnalysis.js

@@ -1,13 +1,9 @@
 const logger = new (require("node-red-contrib-logger"))("Data Analysis");
 logger.sendInfo("Copyright 2020 Jaroslav Peter Prib");
 
-Object.defineProperty(Array.prototype, "last", {
-	value() {
-		return this[this.length-1];
-	},
-	writable: true,
-	configurable: true
-});
+require("./arrayLast");
+const ed=require("./euclideanDistance.js");
+require("./forNestedEach");
 
 function crossNormalisedDeltas() {
 	const dataPoints=this.dataPoint;
@@ -120,8 +116,18 @@ function setDataPoint(value,term,node,dp) {
 	dp.weightedMovingAvg=(dp.weightedMovingAvg*2/count)/(count+1);
 	dp.exponentialWeightedMoving.forEach(c=>c.sample(value));
 }
+function getColumns(node) {
+	if(node.columns) {
+		if(node.columns instanceof Array) return node.columns
+		return eval("["+node.columns+"]");
+	}
+}
 functions={
 	avg:(d)=>functions.sum(d)/d.length,
+	arrayMax:(d)=>{  // not tested
+		let max=[],indices
+		a.forNestedEach((e,f,l)=>{const i=l[l.length-1];if(max[l]<e) {max=e,indices=l}})
+	},
 	covariance: (d)=>{
 		const means=[],covars=[],dl=d.length,dlminus1=dl-1,N=d[0].length;
 		d.forEach((e,i)=>{
@@ -141,11 +147,16 @@ functions={
 	corelationship:(d)=>{
 		const covars=functions.covariance(d);
 		const stdDev=d.map(c=>functions.stdDev(c));
-		logger.send({label:"test",d:d,covars:covars,stdDev:stdDev});
-		return 1//covars.map((a)=>a.map((c,i)=>c==null?null:c/(stdDev[i+1]*stdDev[i])));
+		return covars.map((a)=>a.map((c,i)=>c==null?null:c/(stdDev[i+1]*stdDev[i])));
 	},
 	deltas :(d)=>d.map( (c,i)=>c-(d[i-1]||0) ),
 	deltaNormalised :(d)=>d.map( (c,i)=>(c-(d[i-1]||0)) / (d[i-1]||0) ),
+	distances: (d,term,node)=>{
+		if(node.columns) return ed.distances(d,getColumns(node))
+		return ed.distances(d);
+	},
+	distancesMin: (d,term,node)=>ed.minDistances(d,getColumns(node)),
+	distancesMax: (d,term,node)=>ed.maxDistances(d,getColumns(node)),
 	max: (d)=> Math.max(...d),
 	median:(d)=>{
 		const i=Math.floor(d.length/2);
@@ -266,11 +277,23 @@ functions={
 		}
 		return dp;
 	},
+	sampleVariance:(d)=>{
+		const mean=functions.avg(d);
+		const sum=functions.sumWithFunction(d,(v)=>v-mean)
+		return sum/(d.length-1)
+	},
 	sum:(d)=>d.reduce((p,c)=>p+c),
 	sumWithFunction:(d,f)=>d.reduce((p,c)=>p+f.apply(this,[c]),0),
 	variance:(d)=>{  //Var(X) = E (X − E(X))2 = E(X2) − (E(X))2
-		return functions.sumWithFunction(d,(v)=>Math.pow(v,2))
-			- Math.pow(functions.avg(d),2);
+		const n=d.length;
+		return functions.sumWithFunction(d,(v)=>Math.pow(v,2))/n - Math.pow(functions.avg(d),2);
+	},
+	sampleStdDev:(d)=>Math.sqrt(functions.sampleVariance(d)),
+	sampleVariance:(d)=>{
+		if(d.length<2)return 0
+		const mean=functions.avg(d);
+		const sum=d.reduce((a,e)=>a+Math.pow(e-mean,2),0);
+		return sum/(d.length-1)
 	}
 }
 functions.mean=functions.avg;
@@ -361,7 +384,8 @@ module.exports = function (RED) {
 	 			return;
 			} 
 			try{
-				msg.result=node.actionfunction.apply(node,[node.getData(msg,node),node.term,node]);
+				const data=node.getData(msg,node);
+				if(data) msg.result=node.actionfunction.apply(node,[data,node.term,node]);
 				switch(node.action) {
 				case "realtime":
 					if(msg.result.outlier) {
@@ -371,6 +395,7 @@ module.exports = function (RED) {
 					break;
 				}
 			} catch(ex) {
+				if(logger.active) logger.send({label:"error input",action:node.action,message:ex.message,stack:ex.stack});
 				msg.error=ex.message;
 				if(node.maxErrorDisplay) {
 					--node.maxErrorDisplay;

package/dataAnalysis/euclideanDistance.js

@@ -0,0 +1,54 @@
+require("./arrayPairs");
+function distance(point1,point2) {
+	try{
+		if(point1==null  | point2==null | point2.length==0 ) return NaN;
+		if(point1.length!==point2.length) throw Error("argument 1 array size not equal argument 2 array size") ;
+		const sum=point1.reduce((s,c,i)=>{
+			const d=c-point2[i];
+			return s+d*d;
+		},0);
+		return Math.sqrt(sum);
+	} catch(ex){
+		if(!(point1 instanceof Array)) throw Error("argument 1 not array") ;
+		if(!(point2 instanceof Array)) throw Error("argument 2 not array") ;
+		throw ex;
+	}
+}
+
+function distanceColumns(point1,point2,columns=[]) {
+	const sum=columns.reduce((s,c)=>{
+		const d=point1[c]-point2[c];
+		return s+d*d;
+	},0);
+	return Math.sqrt(sum)
+}
+function arrayPairs(points,f=distance,args) {
+	if(!(points instanceof Array)) throw Error("argument 1 not array") ;
+	const r=[];
+	points.pairs((p1,p2,i1,i2)=>{
+		r.push([ f(p1,p2,args), i1, i2])
+	});
+	return r;
+}
+function arrayPairsSet(points,f=distance,args,sf=(a,b)=>a>b,maxSetSize) {
+	let m,r=[],pi1,pi2;
+	points.pairs((p1,p2,i1,i2)=>{
+		const d=f(p1,p2,args);
+		if(m===d) {
+			r.push({points:[p1,p2],index:[i1,i2],distance:d});
+			if(maxSetSize && maxSetSize>r.length) r.shift
+		} else if(m==null | sf(m,d)==true) {
+			m=d;
+			r=[{points:[p1,p2],index:[i1,i2],distance:d}];
+		}
+	});
+	return r;
+}
+module.exports={
+		distance:distance,
+		distanceColumns:distanceColumns,
+		distances:arrayPairs,
+		distancesColumns:(a,columns)=>arrayPairs(a,distanceColumns,columns),
+		minDistances:(a,columns)=>arrayPairsSet(a,	columns?distanceColumns:distance,	columns,	(a,b)=>a>b),
+		maxDistances:(a,columns)=>arrayPairsSet(a,	columns?distanceColumns:distance,	columns,	(a,b)=>a<b)
+};

package/dataAnalysis/forNestedEach.js

@@ -0,0 +1,24 @@
+if(Array.prototype.forNestedEach==null)
+	Array.prototype.forNestedEach=function (func,filter,level=[]) {
+		const l=level.length;
+		if(filter.hasOwnProperty(l)) {
+			const e=filter[l];
+			const callFilter=(v)=>!e.includes(v);
+			this.forEach((element, index, array) => {
+				if(callFilter(index)) return;
+				if(element instanceof Array) {
+					element.forNestedEach(func,filter,level.push(index))
+				} else {
+					func(element,index,array,level)
+				}
+			} )
+			return
+		}
+		this.forEach((element, index, array) => {
+			if(element instanceof Array) {
+				element.forNestedEach(func,filter,level.push(index))
+			} else {
+				func(element,index,array,level)
+			}
+		} )
+	}

package/package.json

@@ -1,31 +1,24 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.14.2",
+	"version": "0.17.0",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
-		"node-red-contrib-logger": "0.0.4",
-		"avsc": "*",
-		"fast-xml-parser": "*",
-		"xlsx": "*"
+		"avsc": "^5.6.1",
+		"fast-xml-parser": "^3.19.0",
+		"node-red-contrib-logger": "^0.0.6",
+		"xlsx": "^0.17.0"
 	},
 	"devDependencies": {
-		"bl": ">=1.2.3",
-		"bcrypt": ">=5.0.0",
-		"eslint": "^6.8.0",
-		"eslint-config-standard": "^14.1.0",
-		"eslint-plugin-import": "^2.19.1",
-		"eslint-plugin-mocha": "^8.0.0",
-		"eslint-plugin-node": "^11.0.0",
-		"eslint-plugin-promise": "^4.2.1",
-		"eslint-plugin-standard": "^4.0.1",
-		"mocha": "^8.1.3",
-		"node-red": "^1.1.3",
-		"node-red-node-test-helper": "*"
+		"@node-red/runtime": ">=1.2.8",
+		"axios": ">=0.21.1",
+		"bcrypt": "^5.0.1",
+		"bl": "^5.0.0",
+		"mocha": "^9.2.2",
+		"node-red": "^2.2.2",
+		"node-red-node-test-helper": "^0.2.7"
 	},
 	"scripts": {
-		"test": "mocha \"test/**/*.js\"",
-		"lint": "eslint --ext .js ./",
-		"lint-fix": "eslint --fix --ext .js ./"
+		"test": "mocha \"test/**/e*.js\""
 	},
 	"repository": {
 		"type": "git",
@@ -46,6 +39,8 @@
 		"data",
 		"data analysis",
 		"delta",
+		"distance",
+		"euclidian distance",
 		"EMA",
 		"EWMA",
 		"Exponential Moving Average",
@@ -61,6 +56,7 @@
 		"mean",
 		"median",
 		"minimun",
+		"model",
 		"monitor",
 		"moving",
 		"Moving Average",
@@ -70,6 +66,8 @@
 		"Process",
 		"range",
 		"realtime",
+		"sample variance",
+		"sample stddev",
 		"Simple Moving Average",
 		"skew",
 		"SMA",

package/test/asn1Test.jsBypass

@@ -0,0 +1,226 @@
+const assert=require("assert");
+const should=require("should");
+const asn1=require("../transform/asn1.js"); 
+const request=require('request');
+/*
+ function stringFromArrayBuffer (arrayBuffer, onSuccess, onFail) {
+  const reader = new FileReader();
+  reader.onload = function (event) {
+    onSuccess(event.target.result);
+  };
+  reader.onerror = function (event) {
+    onFail(event.target.error);
+  };
+  reader.readAsBinaryString(new Blob([ arrayBuffer ],
+    { type: 'application/octet-stream' }));
+}
+
+ */
+/*
+ * as per https://www.w3.org/Protocols/HTTP-NG/asn1.html
+ *
+*/
+ const asn1eg = new Uint8Array([
+0x60, // [0110|0000], [APPLICATION 0, Compound] - GetRequest
+0x80, // [1000|0000], Indefinite length
+
+0x01, // [0000|0001], [BOOLEAN] GetRequest.headerOnly
+0x01, // [0000|0001], length 1
+0x01, // [0000|0001], value TRUE
+
+0x01, // [0000|0001], [BOOLEAN] GetRequest.lock
+0x01, // [0000|0001], length 1
+0x00, // [0000|0000] value FALSE
+
+0x61, // [0110|0001], [APPLICATION 1, Compound] - GetRequest.types
+0x80, // indefinite length
+
+0xa0, // [1010|0000], [CONTEXT 0, Compound] types.standardTypes
+0x80, // indefinite length
+
+0x03, // [0000|0011] [BIT STRING]
+0x02, // length 2
+0x04, // Four bits unused
+0x80, //[1000|0000] {html}
+
+0x03, // [0000|0011] [BIT STRING]
+0x02, // length 2
+0x04, // Four bits unused
+0x40, //  [0100|0000] {plain-text}
+
+0x00,
+0x00, // End of list of standard Types
+0x00,
+0x00, // End of Accept Types
+0x04, // [0000|0100], [OCTET STRING] GetRequest.url
+0x16, // [0001|0110], length 22
+"/ses/magic/moxen.html",  // value
+0x00, 
+0x00 // End of get request
+]);
+
+describe('asn1', function() {
+	it("decode ans1 eg.",(done)=>{
+		const result=asn1.decodeBER(asn1eg);
+		console.log({label:"asn1eg",data:asn1eg,result:result.toString()});
+		done();
+	});
+	
+	it("decode",(done)=>{
+		const certB64 = "MIIDLjCCAhagAwIBAgIBATANBgkqhkiG9w0BAQsFADA6MRkwFwYDVQQDExBUZXN0IGNlcnRpZmljYXRlMR0wGwYJKoZIhvcNAQkBFg5zb21lQGVtYWlsLm5ldDAeFw0yMTAzMTYwMDAwMDBaFw0yMTA0MTYwMDAwMDBaMDoxGTAXBgNVBAMTEFRlc3QgY2VydGlmaWNhdGUxHTAbBgkqhkiG9w0BCQEWDnNvbWVAZW1haWwubmV0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3N6J0GUJ8URj2fduC26mjCzWf75jM3QSLQYiXSTAMqJA9apf09GMmT+UC6jq2J1U49mXGezE64uXv2tyys9S07xgRkNAWPJXz0opKYud4XPEpdxKfQkD2XklK+8R3BPhAOOxSpfR+SFkLxTMiDHsOt+Xbb98DZ8F3QkzHLvX42jEfAR0StIRLgFYEtf4vX9q4OsYTeJ4xk61lTJc3d0ep/JTp55fxWRaQdzhg+fkv9XwJxxhW9pJRekZORnRb4Q1Zyw+uecuIffsmhLzang45npfzAKXuPaE6lnRMHauLQ1rGGqYA/Vaq4UU6yZUTVLpsKON7b1xogMQrqIkbqtTuQIDAQABoz8wPTAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIEkDAdBgNVHQ4EFgQUl4hohjz9Xxb4lYhsOiq9wVqKv8YwDQYJKoZIhvcNAQELBQADggEBAIKH86qkFJV3FZyblAMWDSEbEi4MV2Epb5ty7wpSatHvz8NKtmB/hVFGwWFBj5OfS9wfaX6Uw24DyBSBOOqEzonUeqFTDo54zqQ4fQ+UlC/79aq7awGpEuXFnUF3xiLFqHNz5zUeKEYY0W5XKFg/TiW6hAmxlDg5ybAoHDROpwT4u6TuOK6OxMneQRBESmZlO43DYwCG950fXEDJT2gXVLbbSSTln8JBHfTAwOgmsDtaZOCieTS6KYwscWy3u/8xxMyX8NS3A1Zeh0jtk/irKzfsNAdcl8aQwdckGAkPWT/9EqawC33Ep3+2br41+K1jjGT8LeYDlMYSJycWo9tltKc=";
+//		const result=asn1.decodeBER(new Uint8Array(Buffer.from(certB64, "base64")).buffer);
+		const data=asn1.base64(certB64);
+		const result=asn1.decodeBER(data);
+		console.log({label:"certB64",data:data,result:result.toString()});
+		done();
+	});
+
+	it("encode",(done)=>{
+		const value=new Uint8Array([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]);
+		console.log({hex:asn1.hex(value)})
+		const berData = new asn1.encode({
+			value: (value.buffer),
+			identifier: {
+				"class": 1,
+				tag: 1,
+				iconstructed: false
+			},
+			length: {
+				indefiniteForm: false,
+				longForm: false,
+				length: 10
+			}
+		});
+		assert.equal(berData.length, 10, "Incorrect value for blockLength");
+		done();
+	});
+	
+	const wikiExample=new Uint8Array([0x30,0x13,0x02,0x01,0x05,0x16,0x0e,0x41,0x6e,0x79,0x62,0x6f,0x64,0x79,0x20,0x74,0x68,0x65,0x72,0x65,0x3f]);
+	const wikiDecoded=asn1.decode(wikiExample);
+/*
+ 30 — type tag indicating SEQUENCE
+13 — length in octets of value that follows
+  02 — type tag indicating INTEGER
+  01 — length in octets of value that follows
+    05 — value (5)
+  16 — type tag indicating IA5String 
+     (IA5 means the full 7-bit ISO 646 set, including variants, 
+      but is generally US-ASCII)
+  0e — length in octets of value that follows
+    41 6e 79 62 6f 64 79 20 74 68 65 72 65 3f — value ("Anybody there?")
+ */
+	console.log(wikiDecoded.toString())
+});
+
+describe("ASN.1:2008",()=> {
+	function getCase(content,callback){
+		const testURL="https://raw.githubusercontent.com/YuryStrozhevsky/ASN1-2008-free-test-suite/master/suite/"+content;
+		request(testURL, function (error, response, body) {
+//			console.log({url:testURL,error:error,response:response,body:body}); 
+			callback(body)
+		});
+		
+	}
+	function caseDecodeThrowsError(testCase,error,errorType='TypeError'){
+		it(testCase,(done)=>{
+			assert.throws(()=>{
+				getCase(testCase,(data)=>{
+					try{
+						const dataArray=new TextEncoder().encode(data);
+						const results=asn1.decode(dataArray).toString();
+						console.log("caseDecodeThrowsError no error for "+testCase+" results: "+results)
+						done()
+					} catch(ex){
+						console.log("caseDecodeThrowsError error:"+ex.message)
+						throw ex;
+					}
+				})
+			},
+			{name: errorType ,message:error}
+			);
+		});
+	}
+	function caseDecodeOK(testCase,result){
+		it(testCase,(done)=>{
+			getCase(testCase,(data)=>{
+				console.log()
+				const result=asn1.decode(data);
+				done();
+			});
+		});
+	}
+	caseDecodeThrowsError("tc1.ber","tag > 0x24");
+/*	caseDecodeThrowsError("tc2.ber","???");
+	caseDecodeThrowsError("tc3.ber","???");
+	caseDecodeThrowsError("tc4.ber","???");
+	caseDecodeOK("tc5.ber");
+	caseDecodeOK("tc6.ber");
+	caseDecodeOK("tc7.ber");
+	caseDecodeOK("tc8.ber");
+	caseDecodeOK("tc9.ber");
+	caseDecodeOK("tc10.ber");
+	caseDecodeOK("tc11.ber");
+	caseDecodeOK("tc12.ber");
+	caseDecodeOK("tc13.ber");
+	caseDecodeOK("tc14.ber");
+	caseDecodeOK("tc15.ber");
+	caseDecodeOK("tc16.ber");
+	caseDecodeOK("tc17.ber");
+	caseDecodeThrowsError("tc18.ber","Value block value must be equal to -4095");
+	caseDecodeThrowsError("tc19.ber","End of input reached before message was fully decoded (inconsistent offset and length values)", "Error message inside value block does not match");
+	caseDecodeThrowsError("tc20.ber","Value block value must be equal to -4095");
+	caseDecodeThrowsError("tc21.ber","Value block value must be equal to -4095");
+	caseDecodeThrowsError("tc22.ber","Value block value must be equal to -4095");
+	caseDecodeOK("tc23.ber");
+	caseDecodeOK("tc24.ber");
+	caseDecodeOK("tc25.ber");
+	caseDecodeOK("tc26.ber");
+	caseDecodeOK("tc27.ber");
+	caseDecodeOK("tc28.ber");
+	caseDecodeOK("tc29.ber");
+	caseDecodeOK("tc30.ber");
+	caseDecodeOK("tc31.ber");
+	caseDecodeOK("tc32.ber");
+	caseDecodeOK("tc33.ber");
+	caseDecodeOK("tc34.ber");
+	caseDecodeOK("tc35.ber");
+	caseDecodeOK("tc36.ber");
+	caseDecodeOK("tc37.ber");
+	caseDecodeOK("tc38.ber");
+	caseDecodeOK("tc39.ber");
+	caseDecodeOK("tc40.ber");
+	caseDecodeOK("tc41.ber");
+	caseDecodeOK("tc42.ber");
+	caseDecodeOK("tc43.ber");
+	caseDecodeOK("tc44.ber");
+	caseDecodeOK("tc45.ber");
+	caseDecodeOK("tc46.ber");
+	caseDecodeOK("tc47.ber");
+	caseDecodeOK("tc48.ber");
+*/
+});
+
+/*
+
+ECN -  Encoding Control Notation (ECN)
+
+FooProtocol DEFINITIONS ::= BEGIN
+
+    FooQuestion ::= SEQUENCE {
+        trackingNumber INTEGER(0..199),
+        question       IA5String
+    }
+
+    FooAnswer ::= SEQUENCE {
+        questionNumber INTEGER(10..20),
+        answer         BOOLEAN
+    }
+
+    FooHistory ::= SEQUENCE {
+        questions SEQUENCE(SIZE(0..10)) OF FooQuestion,
+        answers   SEQUENCE(SIZE(1..10)) OF FooAnswer,
+        anArray   SEQUENCE(SIZE(100))  OF INTEGER(0..1000),
+        ...
+    }
+END
+*/

package/test/dataAnalysis.js

@@ -0,0 +1,112 @@
+const assert=require('assert');
+const should=require("should");
+const dataAnalysis=require("../dataAnalysis/dataAnalysis.js");
+const helper=require("node-red-node-test-helper");
+helper.init(require.resolve('node-red'));
+const helperNodeResults={id :"helperNodeResults",	type : "helper"}
+const helperNodeDetails={id :"helperNodeDetails",	type : "helper"}
+const helperNodeOutliers={id :"helperNodeOutliers",	type : "helper"}
+
+const base =  {
+		id : "n1",
+		type:"Data Analysis",
+//	    action: "avg",
+//	    outputs: {value:(["realtime","realtimePredict"].includes(this.action)?3:2),required:true},
+//	    outliersBase: "sum",
+//	    outliersStdDevs: 3,
+//	    term:10,
+//	    keyProperty:"msg.topic",
+	    dataProperty: "msg.payload",
+//	    dataProperties: ["msg.payload[0]","msg.payload[1]"],
+	    wires : [[helperNodeResults.id],[helperNodeDetails.id],[helperNodeOutliers.id]]
+} ;
+function getNode(node) {
+	const n=helper.getNode(node.id);
+	if(n) return n; 
+	throw Error("node id: "+node.id+"  not found, node: "+JSON.stringify(node))
+} ;
+function test(label,action,data,expected) {
+	it(label+" "+action, function(done) {
+		if(data.length==0) {
+			done("no data")
+			return
+		}
+		let errors=[];
+		const newBase=Object.assign({},base,{action:action});
+		const flow=[helperNodeResults,helperNodeDetails,helperNodeOutliers,newBase];
+		let count=data.length;
+		helper.load(dataAnalysis,flow, function() {
+			try{
+				const resultsNode=getNode(helperNodeResults);
+				const detailsNode=getNode(helperNodeDetails);
+				const outliersNode=getNode(helperNodeOutliers);
+				const n1=getNode(newBase);
+				n1.should.have.property("action", action);
+				resultsNode.on("input", function(msg) {
+					try{
+						if(msg.error) throw Error(msg.error);
+						assert.strictEqual(msg.result,expected[msg._i]);
+					}  catch(ex) {
+						console.log(JSON.stringify({label:"**** error ",test:label,error:ex.message,count:count,action:action,msg:msg,expected:expected[msg._i]}))
+						errors.push(ex.message)
+					}
+					if(--count) return;
+					if(errors.length) done(errors)
+					else done();
+				});
+				detailsNode.on("input", function(msg) {
+					console.log(JSON.stringify({label:"***** details ",action:action,msg:msg}))
+				});
+				outliersNode.on("input", function(msg) {
+					console.log(JSON.stringify({label:"***** outliers ",action:action,msg:msg}))
+				});
+				data.forEach((e,i)=>{
+					n1.receive({payload:e,_i :i});
+				})
+			} catch(ex) {
+				console.log(ex.stack)
+				done(ex);
+			}
+		});
+	}).timeout(4000);
+}
+
+describe('Data Anaysis', function() {
+	beforeEach(function(done) {
+		helper.startServer(done);
+	});
+	afterEach(function(done) {
+		helper.unload();
+		helper.stopServer(done);
+	});
+	const zeros=[undefined,[0],[0,0],[0,0,0]];
+	test("test zeros","sum",zeros,[undefined,0,0,0]);
+	test("test zeros","avg",zeros,[undefined,0,0,0]);
+	test("test zeros","max",zeros,[undefined,0,0,0]);
+	test("test zeros","min",zeros,[undefined,0,0,0]);
+	test("test zeros","stdDev",zeros,[undefined,0,0,0]);
+	const ones=[[1],[1,1],[1,1,1]];
+	test("test ones","sum",ones,[1,2,3]);
+	test("test ones","avg",ones,[1,1,1]);
+	test("test ones","max",ones,[1,1,1]);
+	test("test ones","min",ones,[1,1,1]);
+	test("test ones","stdDev",ones,[0,0,0]);
+	const minus=[[-1],[-1,1],[-1,1,-1]];
+	test("test minus","sum",minus,[-1,0,-1]);
+	test("test minus","avg",minus,[-1,0,-1/3]);
+	test("test minus","max",minus,[-1,1,1]);
+	test("test minus","min",minus,[-1,-1,-1]);
+	test("test minus","stdDev",minus,[0,1,0.9428090415820634]);
+
+	const twos=[[2],[2,2],[2,2,2],[2,2,2,2]];
+	test("test twos","sum",twos,[2,4,6,8]);
+	test("test twos","avg",twos,[2,2,2,2]);
+	test("test twos","stdDev",twos,[0,0,0,0]);
+
+	const c1234=[[1],[1,2],[1,2,3],[1,2,3,4]];
+	test("test c1234","sum",c1234,[1,3,6,10]);
+	test("test c1234","avg",c1234,[1,1.5,2,10/4]);
+	test("test c1234","stdDev",c1234,[0,0.5,0.8164965809277263,1.118033988749895]);
+	test("test c1234","sampleStdDev",c1234,[0,0.7071067811865476,1,1.2909944487358056]);
+});	
+	

package/test/euclideanDistance.js

@@ -0,0 +1,99 @@
+const assert=require('assert');
+const should=require("should");
+const ed=require("../dataAnalysis/euclideanDistance.js");
+require("../dataAnalysis/forNestedEach");
+
+describe('euclideanDistance', function() { 
+	it("array forNestedEach", function(done) {
+		const atest=[1,2,3,4];
+		atest.forNestedEach((e,i,a,l)=>e="a",{0:[2]})
+		assert.deepEqual(atest,[ 1, 2, 3, 4 ])
+		atest.forNestedEach((e,i,a,l)=>a[i]="a",{0:[2]})
+		assert.deepEqual(atest,[ 1, 2, 'a', 4 ]);
+		const atest1=[[11,12],[21,22],[31,32],[41,42]];
+		atest1.forNestedEach((e,i,a,l)=>a[i]="a",{0:[0,4]})
+		assert.deepEqual(atest1 ,[ [ 'a', 'a' ], [ 21, 22 ], [ 31, 32 ], [ 41, 42 ] ])
+		done()
+	});
+	it("array pairs", function(done) {
+		assert.strictEqual([].pairs().length,0)
+		assert.strictEqual([1].pairs().length,0)
+		assert.deepEqual([1,2].pairs(null),[[1,2,0,1]])
+		assert.deepEqual([1,2,3].pairs(null),[[1,2,0,1],[1,3,0,2],[2,3,1,2]])
+		assert.deepEqual([1,2,3,4].pairs(null),[[1,2,0,1],[1,3,0,2],[1,4,0,3],[2,3,1,2],[2,4,1,3],[3,4,2,3]])
+		assert.deepEqual([1,2,3,4].pairs(),[[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]])
+		assert.deepEqual([[1,2],[3,4]].pairs(),[[[1,2],[3,4]]])
+		done()
+	});
+	it("distance 1d", function(done) {
+		assert.strictEqual(ed.distance([],[]),			NaN);
+		assert.strictEqual(ed.distance([0],[0]),		0);
+		assert.strictEqual(ed.distance([0],[1]),		1);
+		assert.strictEqual(ed.distance([0],[-1]),		1);
+		assert.strictEqual(ed.distance([1],[0]),		1);
+		assert.strictEqual(ed.distance([-1],[0]),		1);
+		assert.strictEqual(ed.distance([1],[2]),		1);
+		assert.strictEqual(ed.distance([2],[1]),		1);
+		assert.strictEqual(ed.distance([2],[4]),		2);
+		done()
+	});
+	it("distance 2d", function(done) {
+		assert.strictEqual(ed.distance([0,0],[0,0])	,0);
+		assert.strictEqual(ed.distance([0,0],[1,0])	,1);
+		assert.strictEqual(ed.distance([0,0],[0,1])	,1);
+		assert.strictEqual(ed.distance([0,0],[1,1])	,Math.sqrt(1+1));
+		assert.strictEqual(ed.distance([1,0],[0,0])	,1);
+		assert.strictEqual(ed.distance([0,1],[0,0])	,1);
+		assert.strictEqual(ed.distance([1,1],[0,0])	,Math.sqrt(1+1));
+		assert.strictEqual(ed.distance([-1,1],[0,0])	,Math.sqrt(1+1));
+		assert.strictEqual(ed.distance([-1,-1],[0,0])	,Math.sqrt(1+1));
+		assert.strictEqual(ed.distance([1,1],[2,2]),	Math.sqrt(1+1));
+		assert.strictEqual(ed.distance([0,1],[2,2]),	Math.sqrt(2*2+1));
+		assert.strictEqual(ed.distance([0,0],[2,3]),	Math.sqrt(2*2+3*3));
+		done()
+	});
+	it("distance 3d", function(done) {
+		assert.strictEqual(ed.distance([0,0],[0,0]),	0);
+		assert.strictEqual(ed.distance([1,1,1],[2,2,2]), Math.sqrt(1+1+1));
+		assert.strictEqual(ed.distance([1,1,2],[2,0,4]), Math.sqrt(1+1+2*2));
+		assert.strictEqual(ed.distance([0,-1,-2],[0,1,2]), Math.sqrt(0+2*2+4*4));
+		done()
+	});
+	it("distanceColumns 1d", function(done) {
+		assert.strictEqual(ed.distanceColumns(),	0);
+		assert.strictEqual(ed.distanceColumns([1,2,3],[1,2,3]),	0);
+		assert.strictEqual(ed.distanceColumns([1,2,3],[1,2,3],[]),	0);
+		assert.strictEqual(ed.distanceColumns([0,0,0],[1,2,3],[0]),	1);
+		assert.strictEqual(ed.distanceColumns([0,0,0],[1,2,3],[0,1]),	Math.sqrt(1+2*2));
+		assert.strictEqual(ed.distanceColumns([0,0,0],[1,2,3],[0,1,2]),	Math.sqrt(1+2*2+3*3));
+		done()
+	});
+	it("distances 1d", function(done) {
+		assert.deepEqual(ed.distances([[1],[2],[3],[4]]),  [[1,0,1],[2,0,2],[3,0,3],[1,1,2],[2,1,3],[1,2,3]]  );
+		assert.deepEqual(ed.distances([ [1,2,3,4],	[11,12,13,14],	[111,112,113,114]	]), 	[[20,0,1],[220,0,2],[200,1,2]]);
+		done()
+	});
+	it("distancesColumns 1d", function(done) {
+		assert.deepEqual(ed.distancesColumns([["d",1],["d",2],["d",3],["d",4]],[1]),  [[1,0,1],[2,0,2],[3,0,3],[1,1,2],[2,1,3],[1,2,3]]  );
+		assert.deepEqual(ed.distancesColumns([	["d",1,2,3,4],	["d",11,12,13,14],	["d",111,112,113,114]	], [1,2,3,4]), [[20,0,1],[220,0,2],[200,1,2]]);
+		done()
+	}); 
+	it("minDistance 1d", function(done) {
+		assert.deepEqual(ed.minDistances([ [1],	[2],[3],[4]	]), [{distance:1,points:[[1],[2]],index:[0,1]},{distance:1,points:[[2],[3]],index:[1,2]},{distance:1,points:[[3],[4]],index:[2,3]}]);
+		assert.deepEqual(ed.minDistances([ [4],	[3],[2],[1]	]), [{distance:1,points:[[4],[3]],index:[0,1]},{distance:1,points:[[3],[2]],index:[1,2]},{distance:1,points:[[2],[1]],index:[2,3]}]);
+		done()
+	});
+	it("maxDistance 1d", function(done) {
+		assert.deepEqual(ed.maxDistances([ [1],[2],[3],	[4]]),  [{distance:3,points:[[1],[4]],index:[0,3]}]);
+		done()
+	});
+	it("maxDistance 2d", function(done) {
+		assert.deepEqual(ed.maxDistances([ [1,1],[2,2],[3,3],[4,5]]),  [{distance:5,points:[[1,1],[4,5]],index:[0,3]}]);
+		done()
+	});
+	it("maxDistance Columns", function(done) {
+		assert.deepEqual(ed.maxDistances([ [1,1,"d"],[2,2,"d"],[3,3,"d"],[4,5,"d"]],[0,1]),  [{distance:5,points:[[1,1,"d"],[4,5,"d"]],index:[0,3]}]);
+		done()
+	});
+
+});	

package/testing/load-injector.html

@@ -14,8 +14,8 @@
         },
 	    inputs:1,
         inputLabels: "",
-        outputs:1,
-        outputLabels: ["admin"],
+        outputs:2,
+        outputLabels: ["Messages","Finished"],
         icon: "inject.png",
         label: function() {
             return this.name||this._("Load Injector");

package/testing/load-injector.js

@@ -8,8 +8,9 @@ function thinkTimeTime() {
 }
 function nextMessageInjection() {
 	if (this.runtimeTimer) {
+		this.count++;
 		this.receive();
-		var node=this;
+		const node=this;
 		this.nextMessageInjectTimer=setTimeout(function(node){nextMessageInjection.apply(node);},thinkTimeTime.apply(node),node);
 	}
 }
@@ -22,11 +23,15 @@ function runtimeStop() {
 		clearTimeout(this.nextMessageInjectTimer);
 		this.nextMessageInjectTimer=null;
 	}
+	this.stopped=Date.now();
+	this.send([null,{payload:{count:this.count,started:this.started,stopped:this.stopped}}])
     this.status({fill:"red",shape:"ring",text:"Stopped"});
 	this.error("Stopped injector");
 }
 function runtimeStart() {
-	var node=this;
+	const node=this;
+	this.started=Date.now();
+	this.count=0;
 	this.runtimeTimer=true;
 	this.runtimeTimer=setTimeout(function(){runtimeStop.apply(node);},this.runtime*1000);
 	this.status({fill:"green",shape:"ring",text:"Started"});
@@ -37,7 +42,7 @@ function runtimeStart() {
 module.exports = function (RED) {
     function LoadInjectorNode(n) {
         RED.nodes.createNode(this, n);
-        var node=Object.assign(this,n);
+        const node=Object.assign(this,n);
         this.thinktimemin=Number(this.thinktimemin);
         this.thinktimemax=Number(this.thinktimemax);
         if(this.thinktimemax<this.thinktimemin) { 
@@ -96,7 +101,7 @@ module.exports = function (RED) {
 
 //  RED.httpAdmin.post("/loadinjector/:id", RED.auth.needsPermission("inject.write"), function(req,res) {
     RED.httpAdmin.get("/loadinjector/:id",  function(req,res) {
-    	var node = RED.nodes.getNode(req.params.id);
+    	const node = RED.nodes.getNode(req.params.id);
     	if (node && node.type==="Load Injector") {
     	    try {
     	    	node.warn("Request to "+(node.runtimeTimer?"stop":"start")+" injector");

package/testing/test.html

@@ -6,9 +6,13 @@
 		Can select location of property for result on return message.
 		For json test positive infinity by property value "Infinity",negative infinity by "-Infinity" and not a number by "NaN".
 	</p>
+	Error factor allows for numbers to be out by being less than factor abs(expected-result)/expected 
 	<p>
 	A message sent on first port should go thru other nodes and return to test is payload 
 	is has the expected results.  Several test can be arranged. 
+	</p>
+	<p>
+	
 	</p>
 	<h3>Inputs</h3>
 	If message genrated by this node, then payload checked against expected result 
@@ -37,6 +41,17 @@
 		</label>
 	</div>
 
+	<div class="form-row form-row-http-in-errorFactor show">
+		<label for="node-input-errorFactor" style="white-space: nowrap"><i class="icon-bookmark"></i> Error factor</label>
+		<input type="number" id="node-input-errorFactor" list="defaultErrorFactors" >
+		<datalist id="defaultErrorFactors">
+			<option value="0">
+			<option value="0.001">
+			<option value="0.000001">
+			<option value="0.000000001">
+		</datalist>
+	</div>
+
 	<div class="form-row form-row-http-in-resultProperty show">
 		<label for="node-input-resultProperty" style="white-space: nowrap"><i class="icon-bookmark"></i> Property </label>
 		<input type="text" id="node-input-resultProperty" placeholder="msg.payload">
@@ -61,6 +76,7 @@
 		color:"#a6bbcf",
 		defaults: {
 			name: {value:""},
+			errorFactor: {value:0,required:false},
 			escapeString: {value:false,required:false},
 			infiniteIsNull: {value:false,required:false},
 			payload: {value:"", validate: RED.validators.typedInput("payloadType")},

package/testing/test.js

@@ -29,17 +29,19 @@ function setError(msg,node,err) {
 	node.send([null,msg]);
 }
 
-function equalObjects(obj1,obj2) {
+function equalObjects(obj1,obj2,errorFactor) {
 	if( obj1 === obj2 ) return true;
 	if( obj1 === Number.POSITIVE_INFINITY && obj2==="Infinity") return true;
 	if( obj1 === Number.NEGATIVE_INFINITY && obj2==="-Infinity") return true;
 	if( Number.isNaN(obj1) && obj2==="NaN") return true;
-	if( typeof obj1 != typeof obj2 ) return false;
+	const obj1type=typeof obj1;
+	if(  obj1type != typeof obj2 ) return false;
+	if(errorFactor &&  obj1type=="number") return (Math.abs(obj2-obj1)/obj2)<errorFactor; 
 	if( !(obj1 instanceof Object) ) return false; 
 	if( Object.keys(obj1).length !== Object.keys(obj2).length ) return false;
 	try{
 		for(let key in obj1) {
-			if( !equalObjects(obj1[key],obj2[key]) ) return false;
+			if( !equalObjects(obj1[key],obj2[key],errorFactor) ) return false;
 		}
 	} catch(e) {
 		return false;
@@ -69,7 +71,7 @@ module.exports = function(RED) {
 				try{
 					if(msg._test.id!==node.id) {
 						setError(msg,node,"Sent by another test "+msg._test.id);
-					} else if(!equalObjects(node.getData(msg,node),msg._test.result)) {
+					} else if(!equalObjects(node.getData(msg,node),msg._test.result,node.errorFactor)) {
 						msg._test.testedValue=node.getData(msg,node);
 						setError(msg,node,"Test failed");
 					} else {

package/transform/asn1.js

@@ -0,0 +1,237 @@
+const throwError=(msg,p)=>{throw Object.assign(new Error(msg),p)}
+const Uint8ArrayFromBase64=(b64)=>new Uint8Array(Buffer.from(b64, "base64"))
+const base64FromUint8Array=(a)=>Buffer.toString(a, "base64")
+const hexFromArray=(a)=>Buffer.from(a).toString('hex')
+const UInt8ToBinary=(a)=> {
+	const buf = Buffer.allocUnsafe(a.length);
+	a.forEach((c,i)=>buf.writeUInt8(c,i))
+	return buf
+};
+
+const test={
+		PrintableString:(s)=>{if(s.test(/^[a-z0-9  '()+,-./:=?]*$/i)) return; throw Error("invalid PrintableString")}
+}
+
+function Classes() {}
+Classes.prototype.UNIVERSAL=0b00000000; 
+Classes.prototype.APPLICATION=0b01000000;
+Classes.prototype.CONTEXTSPECIFIC=0b10000000;
+Classes.prototype.PRIVATE=0b11000000;
+Classes.prototype.values={1:Classes.prototype.UNIVERSAL,2:Classes.prototype.APPLICATION,3:Classes.prototype.CONTEXTSPECIFIC,4:Classes.prototype.PRIVATE};
+Classes.prototype.names={1:"UNIVERSAL",2:"APPLICATION",3:"CONTEXT-SPECIFIC",4:"PRIVATE"};
+Classes.prototype.setOctet=(octet,tag)=>octet|=(Classes.prototype.values[tag]);	
+Classes.prototype.setOctetName=(octet,tagName)=>octet|=(Classes.prototype[tagName]);	
+Classes.prototype.getOctetValue=(octet)=>octet>>6+1;
+//Classes.prototype.getOctetTag=(octet)=>octet|=Classes.prototype[tag];	
+//Classes.prototype.toString=(octet)=>classes.names[Classes.getOctetTag(octet)];	
+const classes=new Classes()
+
+function PC() {}
+PC.prototype.P=0b0000; 
+PC.prototype.Primitive=0b00000000; 
+PC.prototype.C=0b00100000; 
+PC.prototype.Constructed =0b00100000; 
+PC.prototype.isPrimitive =(octet)=>octet&0b00000000; 
+PC.prototype.isConstructed =(octet)=>octet&0b00100000; 
+PC.prototype.setOctet=(octet)=>octet|=(classes[tag]);
+PC.prototype.toString=(octet)=>pc.isPrimitive(octet)?"Primitive":"Constructed";
+PC.prototype.set=(octet,action)=>octet=(octet^0b00100000)&pc[action];
+const pc=new PC();
+
+function Octet1(v) {
+	this.value=v
+}
+Octet1.prototype.getClass=()=>Classes.getOctetValue(this.value);
+Octet1.prototype.getTag=()=>this.value&0b00011111;
+Octet1.prototype.isLongForm=()=>(this.value^0b10000000) & (this.value^0b01111111);
+Octet1.prototype.toJSON=()=>{return {"class":this.getClass(this.value), tag:this.getTag(this.value), longForm:this.isLongForm(this.value)};};
+Octet1.prototype.toString=function(){const r=this.toJSON();r.className=classes.names(r.classID) ;return JSON.stringify(r)};
+Octet1.prototype.isConstructed=()=>pc.isConstructed(this.value);
+
+function IdentifierOctets(dataArray,i){
+	if(dataArray) this.decode(dataArray,i)
+}
+IdentifierOctets.prototype.decode=function (dataArray,i){
+	this.tags=[];
+	if(!dataArray.length) return;
+	const octet1=new Octet1(dataArray[i++]);
+	this.tagClass=octet1.getClass();
+	this.isConstructed=octet1.isConstructed();
+	if(octet1.isLongForm())  //isLongForm
+		this.tags.push(octet1.getTag());
+	else {
+		let more=true
+		while (more) {
+			const octet=dataArray[i++];
+			const tag=octet&0b01111111;
+			if(tag>0x24) throw Error("tag = 0x00")
+			if(tag>0x24) throw Error("tag > 0x24")
+			this.tags.push(tag);  
+			more=octet&0b1000000;;
+		}
+	}
+};
+IdentifierOctets.prototype.toJSON=function (){
+	return {"class":this.tagClass,constructed:this.isConstructed,tags:this.tags}
+}
+IdentifierOctets.prototype.toJSONExtended=function (){
+	const r=this.toJSON();
+	r.tags=r.tags.map(c=>({id:c,name:tags[c].name}));
+	return r
+};
+IdentifierOctets.prototype.toString==function (){
+	return JSON.stringify(this.toJSONExtended())
+};
+
+//Basic Encoding Rules (BER)
+function BERencoding(dataArray,i=0) {
+	//Identifier octets	Type  i++
+	//	if(!(dataArray  instanceof Uint8Array) ) throw Error("data not Uint8Array  but "+dataArray.constructor.name)
+	this.decodeBER(dataArray,i);
+}
+BERencoding.prototype.encode=function(v){
+	for(const p in v) {
+		switch (p) {
+		case "Identifier":
+			this.setIdentifier(v[p])
+			next;
+		default:
+			throw Error("unknown base property "+p)
+		}
+	}
+}
+BERencoding.prototype.setIdentifier=function(v){
+	for(const p in v) {
+		switch (p) {
+		case "class":
+			this.tagClass=v[p]
+			next;
+		case "tag":
+			this.tags=[v[p]]
+			next;
+		case "constructed":
+			this.isConstructed=v[p]
+			next;
+		default:
+			throw Error("unknown identifier property "+p)
+		}
+	}
+}
+BERencoding.prototype.setSchema=function(schema){
+}
+
+BERencoding.prototype.decodeBER=function(dataArray,i){
+	if(dataArray.constructor.name!=="Uint8Array") throw Error("data not Uint8Array but "+dataArray.constructor.name)
+	this.identifier=new IdentifierOctets(dataArray,i);
+	if(dataArray[i]===0xFF) { //isIndefinite
+		const eocIndex=dataArray.indexOf(0x00,i) 
+		this.data=dataArray.slice(i,eocIndex-1);
+		i=eocIndex+1;
+	} else {
+		const endPosition=i+LengthOctet.prototype.getLength(dataArray,i);
+		this.data=dataArray.slice(i,endPosition);
+		i=endPosition+1;
+	}
+}
+BERencoding.prototype.decode=BERencoding.prototype.decodeBER;
+BERencoding.prototype.toJSON= function(){
+	return {identifier:this.identifier.toJSONExtended(),data:this.data,dataHex:this.data2Hex()};
+}
+BERencoding.prototype.toString= function(){
+	return JSON.stringify(this.toJSON());
+}
+BERencoding.prototype.data2Hex= function(){
+	const r=[];
+	this.data.forEach(c=>r.push("0x"+c.toString(16)))
+	return r;
+}
+const constructPrimitive=null;
+const constructConstructed=false
+const constructBoth=true;
+const constructReserved=undefined;
+const PrintableString2Value=(a,i,l)=>{
+	const s=i;
+	i=i+l;
+	return a.slice(s,i)
+};
+const Value2PrintableString=(v)=>{
+	test.PrintableString(v);
+	return v;
+}
+
+const tags=[
+	{name:"End-of-Content (EOC)",permittedConstruction:constructPrimitive},
+	{name:"BOOLEAN",permittedConstruction:constructPrimitive,translatedTo:(v)=>v?0x01:0x00,translatedFrom:(a,i)=>a[i++]==0x01},
+	{name:"INTEGER",permittedConstruction:constructPrimitive},
+	{name:"BIT STRING",permittedConstruction:constructBoth},
+	{name:"OCTET STRING",permittedConstruction:constructBoth},
+	{name:"NULL",permittedConstruction:constructPrimitive},
+	{name:"OBJECT IDENTIFIER",permittedConstruction:constructPrimitive},
+	{name:"Object Descriptor",permittedConstruction:constructBoth},
+	{name:"EXTERNAL",permittedConstruction:constructConstructed},
+	{name:"REAL (float)",permittedConstruction:constructPrimitive},
+	{name:"ENUMERATED",permittedConstruction:constructPrimitive},
+	{name:"EMBEDDED PDV",permittedConstruction:constructConstructed},
+	{name:"UTF8String",permittedConstruction:constructBoth},
+	{name:"RELATIVE-OID",permittedConstruction:constructPrimitive},
+	{name:"TIME",permittedConstruction:constructPrimitive},
+	{name:"Reserved",permittedConstruction:constructReserved},
+	{name:"SEQUENCE and SEQUENCE OF",permittedConstruction:constructConstructed},
+	{name:"SET and SET OF",permittedConstruction:constructConstructed},
+	{name:"NumericString",permittedConstruction:constructBoth},
+	{name:"PrintableString",permittedConstruction:constructBoth,translatedTo:Value2PrintableString,translatedFrom:PrintableString2Value},
+	{name:"T61String",permittedConstruction:constructBoth},
+	{name:"VideotexString",permittedConstruction:constructBoth},
+	{name:"IA5String",permittedConstruction:constructBoth},
+	{name:"UTCTime",permittedConstruction:constructBoth},
+	{name:"GeneralizedTime",permittedConstruction:constructBoth},
+	{name:"GraphicString",permittedConstruction:constructBoth},
+	{name:"VisibleString",permittedConstruction:constructBoth},
+	{name:"GeneralString",permittedConstruction:constructBoth},
+	{name:"UniversalString",permittedConstruction:constructBoth},
+	{name:"CHARACTER STRING",permittedConstruction:constructConstructed},
+	{name:"BMPString",permittedConstruction:constructBoth},
+	{name:"DATE",permittedConstruction:constructPrimitive},
+	{name:"TIME-OF-DAY",permittedConstruction:constructPrimitive},
+	{name:"DATE-TIME",permittedConstruction:constructPrimitive},
+	{name:"DURATION",permittedConstruction:constructPrimitive},
+	{name:"OID-IRI",permittedConstruction:constructPrimitive},
+	{name:"RELATIVE-OID-IRI",permittedConstruction:constructPrimitive},
+];
+
+function LengthOctet() {}
+LengthOctet.prototype.definiteShort=0x00;
+LengthOctet.prototype.definiteLong=0xC0;
+LengthOctet.prototype.indefinite= 0xC0;
+LengthOctet.prototype.reserved=0xFF;
+LengthOctet.prototype.isIndefinite= (o)=>o&0xC0;
+LengthOctet.prototype.octets=(o)=>o^0b01111111;
+LengthOctet.prototype.getLength=(octets,i)=>{
+	const octet=octets[i++];
+	if(octet===0xC0) return  undefined; 
+	if(octet&0xC0) return octet; //isDefiniteShort
+	if(octet===0xFF) return NaN; //isReserved
+	let l=octet&0b01111111;  // length
+	let length=octets[i++];
+	while (l--) length=length*256+octets[i++]
+	 if(length < 0) throw new Error('Negative length: ' + length);
+	return length;
+}
+
+// Canonical Encoding Rules (CER)
+function CERencoding(dataArray,i=0) {
+	throw Error("to be done")
+}
+//Distinguished Encoding Rules (DER)
+function DERencoding(dataArray,i=0) {
+	throw Error("to be done")
+}
+
+module.exports={
+		base64:Uint8ArrayFromBase64,
+		hex:hexFromArray,
+		decode:(dataArray,i)=>new BERencoding(dataArray,i),
+		decodeBER:(dataArray,i)=>new BERencoding(dataArray,i),
+		decodeBase64:(v)=>BERencoding(arrayFromBase46(v)),
+		encode:BERencoding
+}