@sswroom/sswr 1.5.4 → 1.6.0

package/net.d.ts

@@ -1,2 +1,3 @@
 export function oidText2PDU(txt: string): Uint8Array;
 export function oidToString(oid: ArrayBuffer): string;
+export function getIPv4Name(ip: number): string;

package/net.js

@@ -74,3 +74,8 @@ export function oidToString(oid)
 	}
 	return ret.join(".");
 }
+
+export function getIPv4Name(ip)
+{
+	return ((ip >> 24) & 0xff).toString() + "." + ((ip >> 16) & 0xff).toString() + "." + ((ip >> 8) & 0xff).toString() + "." + (ip & 0xff).toString()
+}

package/olayer2.d.ts

@@ -11,7 +11,7 @@ declare class Olayer2Options
 };
 
 export function toPointArray(numArr: number[][], options: Olayer2Options): OpenLayers.Geometry.Point[];
-export function createFromKMLFeature(feature: kml.Feature, options: Olayer2Options): Promise<OpenLayers.Feature.Vector | OpenLayers.Marker | any[] | null>;
+export function createFromKML(feature: kml.Feature | kml.KMLFile, options: Olayer2Options): Promise<OpenLayers.Feature.Vector | OpenLayers.Marker | any[] | null>;
 export function createFromGeometry(geom: geometry, options: Olayer2Options): Promise<OpenLayers.Marker | OpenLayers.Geometry | null>;
 
 export class Olayer2Map extends map.MapControl
@@ -33,7 +33,7 @@ export class Olayer2Map extends map.MapControl
 	createMarkerLayer(name: string, options?: LayerOptions): any;
 	createGeometryLayer(name: string, options?: LayerOptions): any;
 	addLayer(layer: any): void;
-	addKMLFeature(feature: kml.Feature): void;
+	addKML(feature: kml.Feature | kml.KMLFile): void;
 	uninit(): void;
 	zoomIn(): void;
 	zoomOut(): void;

package/olayer2.js

@@ -19,8 +19,12 @@ export function toPointArray(numArr, options)
 	return ret;
 }
 
-export async function createFromKMLFeature(feature, options)
+export async function createFromKML(feature, options)
 {
+	if (feature instanceof kml.KMLFile)
+	{
+		return await createFromKML(feature.root, options);
+	}
 	options = data.mergeOptions(options, {noPopup: false});
 	if (feature instanceof kml.Container)
 	{
@@ -29,7 +33,7 @@ export async function createFromKMLFeature(feature, options)
 		let layer;
 		for (i in feature.features)
 		{
-			layer = await createFromKMLFeature(feature.features[i], options);
+			layer = await createFromKML(feature.features[i], options);
 			if (layer instanceof OpenLayers.Marker)
 			{
 				layers.push(layer);
@@ -348,9 +352,9 @@ export class Olayer2Map extends map.MapControl
 		}
 	}
 
-	addKMLFeature(feature)
+	addKML(feature)
 	{
-		createFromKMLFeature(feature, {map: this.map, objProjection: this.mapProjection, mapProjection: this.map.getProjectionObject()}).then((layer)=>{this.addLayer(layer);});
+		createFromKML(feature, {map: this.map, objProjection: this.mapProjection, mapProjection: this.map.getProjectionObject()}).then((layer)=>{this.addLayer(layer);});
 	}
 
 	uninit()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sswroom/sswr",
-  "version": "1.5.4",
+  "version": "1.6.0",
   "description": "Libraries made by sswroom",
   "main": "sswr.js",
   "scripts": {

package/parser.d.ts

@@ -1,4 +1,10 @@
+import * as data from "./data";
 import * as kml from "./kml";
 
-export function parseXML(txt: string): kml.Feature | kml.NetworkLinkControl | null;
-export function parseFile(file: File): Promise<kml.Feature | kml.NetworkLinkControl | null>;
+export function parseXML(txt: string): kml.KMLFile | null;
+/**
+ * Parse file into data.ParsedObject
+ * @param file file to be parsed
+ * @returns can be kml.KMLFile, media.StaticImage, cert.ASN1Data, null if failed
+ */
+export function parseFile(file: File | Response): Promise<data.ParsedObject | null>;

package/parser.js

@@ -1,5 +1,9 @@
+import * as cert from "./cert.js";
+import { ASN1Util } from "./certutil.js";
+import * as data from "./data.js";
 import * as geometry from "./geometry.js";
 import * as kml from "./kml.js";
+import * as media from "./media.js";
 import * as text from "./text.js";
 import * as web from "./web.js";
 
@@ -275,6 +279,46 @@ function parseKMLContainer(container, kmlNode, doc)
 		case "visibility":
 			container.setVisibility(node.textContent == "1");
 			break;
+		case "atom:author":
+			for (subNode of node.childNodes)
+			{
+				switch (subNode.nodeName)
+				{
+				case "#text":
+					{
+						let txt = subNode.textContent.trim();
+						if (txt.length > 0)
+						{
+							if (container.author)
+								container.setAuthor(container.author + " " + txt);
+							else
+								container.setAuthor(txt);
+						}						
+					}
+					break;
+				case "atom:name":
+					container.setAuthorName(subNode.textContent);
+					break;
+				default:
+					console.log("Unknown node in kml atom:author: "+subNode.nodeName, subNode);
+					break;
+				}
+			}
+			break;
+		case "atom:link":
+			for (subNode of node.attributes)
+			{
+				switch (subNode.name)
+				{
+				case "href":
+					container.setLink(subNode.value);
+					break;
+				default:
+					console.log("Unknown attribute in kml atom:link: "+subNode.nodeName, subNode);
+					break;
+				}
+			}
+			break;
 		case "Style":
 			break;
 		case "StyleMap":
@@ -285,6 +329,11 @@ function parseKMLContainer(container, kmlNode, doc)
 			if (feature)
 				container.addFeature(feature);
 			break;
+		case "NetworkLink":
+			feature = parseKMLNetworkLink(node, doc || container);
+			if (feature)
+				container.addFeature(feature);
+			break;
 		case "LookAt":
 			container.setLookAt(parseKMLLookAt(node));
 			break;
@@ -574,6 +623,98 @@ function parseKMLGeometry(kmlNode)
 	return null;
 }
 
+function parseKMLNetworkLink(kmlNode, doc)
+{
+	let name;
+	let description;
+	let open;
+	let refreshVisibility;
+	let flyToView;
+	let linkHref;
+	let refreshMode;
+	let refreshInterval;
+	let viewRefreshMode;
+
+	let feature;
+	let node;
+	let subNode;
+	for (node of kmlNode.childNodes)
+	{
+		switch (node.nodeName)
+		{
+		case "#text":
+			break;
+		case "name":
+			name = node.textContent;
+			break;
+		case "description":
+			description = node.textContent.trim();
+			break;
+		case "open":
+			open = (node.textContent == "1");
+			break;
+		case "refreshVisibility":
+			refreshVisibility = (node.textContent == "1");
+			break;
+		case "flyToView":
+			flyToView = (node.textContent == "1");
+			break;
+		case "Link":
+			for (subNode of node.childNodes)
+			{
+				switch (subNode.nodeName)
+				{
+				case "#comment":
+					break;
+				case "#text":
+					break;
+				case "href":
+					linkHref = subNode.textContent;
+					break;
+				case "refreshMode":
+					refreshMode = subNode.textContent;
+					break;
+				case "refreshInterval":
+					refreshInterval = subNode.textContent;
+					break;
+				case "viewRefreshMode":
+					viewRefreshMode = subNode.textContent;
+					break;
+				default:
+					console.log("Unknown node in kml NetworkLink.Link", subNode);
+					break;
+				}
+			}
+			break;
+		default:
+			console.log("Unknown node in kml NetworkLink", node);
+			break;
+		}
+	}
+	if (linkHref)
+	{
+		feature = new kml.NetworkLink(linkHref);
+		if (name)
+			feature.setName(name);
+		if (description)
+			feature.setDescription(description);
+		if (open != null)
+			feature.setOpen(open);
+		if (refreshVisibility != null)
+			feature.setRefreshVisibility(refreshVisibility);
+		if (flyToView != null)
+			feature.setFlyToView(flyToView);
+		if (refreshMode)
+			feature.setRefreshMode(refreshMode);
+		if (refreshInterval)
+			feature.setRefreshInterval(Number.parseFloat(refreshInterval));
+		if (viewRefreshMode)
+			feature.setViewRefreshMode(viewRefreshMode);
+		return feature;
+	}
+	return null;
+}
+
 function parseKMLLookAt(kmlNode)
 {
 	let longitude;
@@ -654,7 +795,387 @@ function parseKMLNode(kmlNode, doc)
 	}
 }
 
-export function parseXML(txt)
+async function parseJpg(reader)
+{
+	if (!(reader instanceof data.ByteReader))
+		return null;
+	if (reader.getLength() < 2)
+		return null;
+	if (reader.readUInt8(0) != 0xff || reader.readUInt8(1) != 0xd8)
+		return null;
+	let ofst = 2;
+	let ret = false;
+	let j;
+	let exif;
+	while (true)
+	{
+		if (ofst + 4 > reader.getLength())
+		{
+			ret = false;
+			break;
+		}
+		if (reader.readUInt8(ofst + 0) != 0xff)
+		{
+			ret = false;
+			break;
+		}
+		if (reader.readUInt8(ofst + 1) == 0xdb)
+		{
+			ret = true;
+			break;
+		}
+
+		j = ((reader.readUInt8(ofst + 2) << 8) | reader.readUInt8(ofst + 3)) - 2;
+		if (reader.readUInt8(ofst + 1) == 0xe1)
+		{
+			let t = reader.readUTF8Z(ofst + 4, 14);
+			if (t == "Exif")
+			{
+				let lsb;
+				if (reader.readUTF8(ofst + 10, 2) == "II")
+				{
+					lsb = true;
+				}
+				else if (reader.readUTF8(ofst + 10, 2) == "MM")
+				{
+					lsb = false;
+				}
+				else
+				{
+					console.log("JPG Exif unknown byte order", reader.readUTF8(ofst + 10, 2));
+					ret = false;
+					break;
+				}
+				if (reader.readUInt16(ofst + 12, lsb) != 42)
+				{
+					console.log("JPG Exif not 42", reader.readUInt16(ofst + 12, lsb));
+					ret = false;
+					break;
+				}
+				if (reader.readUInt32(ofst + 14, lsb) != 8)
+				{
+					console.log("JPG Exif not 8", reader.readUInt32(ofst + 14, lsb));
+					ret = false;
+					break;
+				}
+				exif = media.EXIFData.parseIFD(reader, ofst + 18, lsb, null, ofst + 10);
+				if (exif == null)
+				{
+					console.log("Error in parsing EXIF");
+				}
+				ofst += j + 4;
+			}
+			else if (t == "FLIR")
+			{
+/*				if (buff[4] == 0 && buff[5] == 1)
+				{
+					if (flirMstm == 0 && buff[6] == 0)
+					{
+						flirMaxSegm = buff[7];
+						NEW_CLASS(flirMstm, IO::MemoryStream());
+						flirCurrSegm = buff[6];
+						Data::ByteBuffer tagBuff(j);
+						fd->GetRealData(ofst + 4, j, tagBuff);
+						flirMstm->Write(&tagBuff[8], j - 8);
+					}
+					else if (flirMstm && buff[6] == (flirCurrSegm + 1))
+					{
+						flirCurrSegm = (UInt8)(flirCurrSegm + 1);
+						Data::ByteBuffer tagBuff(j);
+						fd->GetRealData(ofst + 4, j, tagBuff);
+						flirMstm->Write(&tagBuff[8], j - 8);
+					}
+				}*/
+				ofst += j + 4;
+			}
+			else
+			{
+				console.log("Unknown type for e1", t);
+				ofst += j + 4;
+			}
+		}
+		else if (reader.readUInt8(ofst + 1) == 0xe2)
+		{
+			let t = reader.readUTF8Z(ofst + 4);
+			if (t == "ICC_PROFILE")
+			{
+				let iccBuff = reader.getArrayBuffer(ofst + 4 + 14, j - 14);
+				/*
+				NotNullPtr<Media::ICCProfile> icc;
+				if (Media::ICCProfile::Parse(tagBuff.SubArray(14, j - 14)).SetTo(icc))
+				{
+					icc->SetToColorProfile(img->info.color);
+					icc.Delete();
+				}*/
+				console.log("ICC Profile found");
+			}
+			else
+			{
+				console.log("Unknown type for e2", t);
+			}
+			ofst += j + 4;
+		}
+		else
+		{
+			ofst += j + 4;
+		}
+	}
+	if (ret)
+	{
+		let buff = reader.getArrayBuffer();
+		let b = new Blob([buff], {type: "image/jpeg"});
+		let img = await media.loadImageFromBlob(b);
+		let simg = new media.StaticImage(img, sourceName, "image/jpeg");
+		if (exif)
+			simg.setExif(exif);
+		return simg;
+	}
+	return null;
+}
+
+async function parseWebp(reader)
+{
+	if (!(reader instanceof data.ByteReader))
+		return null;
+	if (reader.getLength() < 20)
+		return null;
+	if (reader.readUInt32(0, true) != 0x46464952 || reader.readUInt32(8, true) != 0x50424557 || reader.readUInt32(4, true) + 8 != reader.getLength())
+		return null;
+	let buff = reader.getArrayBuffer();
+	let b = new Blob([buff], {type: "image/webp"});
+	let img = await media.loadImageFromBlob(b);
+	let simg = new media.StaticImage(img, sourceName, "image/webp");
+	return simg;
+}
+
+function parseX509(reader, fileName, mime)
+{
+	if (!(reader instanceof data.ByteReader))
+		return null;
+	let initTxt;
+	let initOfst = 0;
+	if (reader.readUInt8(0) == 0xef && reader.readUInt8(1) == 0xbb && reader.readUInt8(2) == 0xbf)
+	{
+		initOfst = 3;
+	}
+	initTxt = reader.readUTF8(initOfst, 5);
+	if (initTxt == "-----")
+	{
+		let files = [];
+		let lines = text.splitLines(reader.readUTF8(initOfst, reader.getLength() - initOfst));
+		let i = 0;
+		let j = lines.length;
+		while (i < j)
+		{
+			if (lines[i] == "-----BEGIN CERTIFICATE-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END CERTIFICATE-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509Cert(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer));
+			}
+			else if (lines[i] == "-----BEGIN RSA PRIVATE KEY-----")
+			{
+				let b64 = [];
+				let enc = false;
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END RSA PRIVATE KEY-----")
+					{
+						break;
+					}
+					else if (lines[i].startsWith("Proc-Type:"))
+					{
+						enc = true;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509Key(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer, cert.KeyType.RSA));
+			}
+			else if (lines[i] == "-----BEGIN DSA PRIVATE KEY-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END DSA PRIVATE KEY-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509Key(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer, cert.KeyType.DSA));
+			}
+			else if (lines[i] == "-----BEGIN EC PRIVATE KEY-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END EC PRIVATE KEY-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509Key(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer, cert.KeyType.ECDSA));
+			}
+			else if (lines[i] == "-----BEGIN PRIVATE KEY-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END PRIVATE KEY-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509PrivKey(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer));
+			}
+			else if (lines[i] == "-----BEGIN PUBLIC KEY-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END PUBLIC KEY-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509PubKey(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer));
+			}
+			else if (lines[i] == "-----BEGIN CERTIFICATE REQUEST-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END CERTIFICATE REQUEST-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509CertReq(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer));
+			}
+			else if (lines[i] == "-----BEGIN NEW CERTIFICATE REQUEST-----")
+			{
+				let b64 = [];
+				i++;
+				while (true)
+				{
+					if (i >= j)
+						return null;
+					if (lines[i] == "-----END NEW CERTIFICATE REQUEST-----")
+					{
+						break;
+					}
+					else
+					{
+						b64.push(lines[i]);
+					}
+					i++;
+				}
+				files.push(new cert.X509CertReq(fileName, new text.Base64Enc().decodeBin(b64.join("")).buffer));
+			}
+			i++;
+		}
+		if (files.length == 1)
+		{
+			return files[0];
+		}
+		else if (files.length > 1)
+		{
+			let fileList = new cert.X509FileList(fileName, files[0]);
+			let i = 1;
+			while (i < files.length)
+			{
+				fileList.addFile(files[i]);
+				i++;
+			}
+			return fileList;
+		}
+		console.log("Unsupported file", fileName, mime);
+	}
+	else if (reader.readUInt8(0) == 0x30 && ASN1Util.pduIsValid(reader, 0, reader.getLength()))
+	{
+		fileName = fileName.toUpperCase();
+		console.log(mime);
+		if (mime == "application/x-pkcs12" || fileName.endsWith(".P12") || fileName.endsWith(".PFX"))
+		{
+			return new cert.X509PKCS12(fileName, reader.getArrayBuffer());
+		}
+		else if (mime == "application/x-x509-ca-cert" || mime == "application/x-x509-user-cert" || mime == "application/pkix-cert" || fileName.endsWith(".DER") || fileName.endsWith(".CER") || fileName.endsWith(".CRT"))
+		{
+			return new cert.X509Cert(fileName, reader.getArrayBuffer());
+		}
+		else if (mime == "application/x-pkcs7-certificates" || fileName.endsWith(".P7B") || fileName.endsWith(".P7S"))
+		{
+			return new cert.X509PKCS7(fileName, reader.getArrayBuffer());
+		}
+		else if (mime == "application/pkix-crl" || fileName.endsWith(".CRL"))
+		{
+			return new cert.X509CRL(fileName, reader.getArrayBuffer());
+		}
+	}
+	return null;
+}
+
+export function parseXML(txt, sourceName)
 {
 	let parser = new DOMParser();
 	let xmlDoc = parser.parseFromString(txt, "application/xml");
@@ -672,7 +1193,17 @@ export function parseXML(txt)
 				for (kmlNode of xmlRoot.childNodes)
 				{
 					if (kmlNode.nodeName != "#text")
-						return parseKMLNode(kmlNode);
+					{
+						let feature = parseKMLNode(kmlNode);
+						if (feature)
+						{
+							return new kml.KMLFile(feature, sourceName);
+						}
+						else
+						{
+							return null;
+						}
+					}
 				}
 			}
 			else
@@ -696,10 +1227,15 @@ export async function parseFile(file)
 
 	if (t == "application/vnd.google-earth.kml+xml")
 	{
-		return parseXML(await file.text());
+		return parseXML(await file.text(), file.name);
 	}
 	else
 	{
+		let view = new data.ByteReader(await file.arrayBuffer());
+		let obj;
+		if (obj = await parseJpg(view, file.name)) return obj;
+		if (obj = await parseWebp(view, file.name)) return obj;
+		if (obj = parseX509(view, file.name, t)) return obj;
 		console.log("Unsupported file type", t);
 		return null;
 	}

package/text.d.ts

@@ -10,7 +10,7 @@ export enum LineBreakType
 	CR,
 	LF,
 	CRLF
-};
+}
 
 export function zeroPad(val: string | number, ndigits: number): string;
 export function isInteger(s: string): boolean;
@@ -23,6 +23,8 @@ export function arrayToNumbers(arr: string[]): number[];
 export function toHex8(v: number): string;
 export function toHex16(v: number): string;
 export function toHex32(v: number): string;
+export function u8Arr2Hex(buff: Uint8Array, byteSep: string, rowSep: string): string;
+export function splitLines(txt: string): string[];
 export function getEncList(): TextBinEnc[];
 
 export class TextBinEnc