@sswroom/sswr 1.6.2 → 1.6.3

package/Changelog

@@ -1,3 +1,10 @@
+1.6.3
+-Added hash.MD5
+-Support web.Dialog in frameset
+-Added data.objectParseTS
+-web.propertiesToHTML support nameMap and timeFormat
+-text.isHKID fixed wrong validation
+
 1.6.2
 -Fixed data.DateTimeUtil.totalDays2DateValue bigint problem
 

package/data.d.ts

@@ -17,6 +17,7 @@ export function ror32(v: number, n: number): number;
 export function shl32(v: number, n: number): number;
 export function sar32(v: number, n: number): number;
 export function shr32(v: number, n: number): number;
+export function objectParseTS(o: object, items: string[]): void;
 
 export class DateValue
 {

package/data.js

@@ -328,6 +328,18 @@ export function shr32(v, n)
 	return ((v >> 1) & 0x7fffffff) >> (n - 1);
 }
 
+export function objectParseTS(o, items)
+{
+	let item;
+	for (item in items)
+	{
+		if (o[items[item]] && typeof o[items[item]] == "string")
+		{
+			o[items[item]] = Timestamp.fromStr(o[items[item]]);
+		}
+	}
+}
+
 export class DateValue
 {
 	constructor()

package/hash.d.ts

@@ -54,4 +54,22 @@ export class SHA1 extends Hash
 	getBlockSize(): number;
 
 	static calcBlock(intermediateHash: number[], messageBlock: ArrayBuffer): void;
+}
+
+export class MD5 extends Hash
+{
+	messageLength: number;
+	h: number[];
+	buff: number[];
+	buffSize: number;
+
+	constructor();
+	getName(): string;
+	clone(): Hash;
+	clear(): void;
+	calc(buff: ArrayBuffer): void;
+	getValue(): ArrayBuffer;
+	getBlockSize(): number;
+
+	static calcBlock(hVals: number[], block: DataView): void;
 }

package/hash.js

@@ -267,3 +267,281 @@ export class SHA1 extends Hash
 		intermediateHash[4] = (intermediateHash[4] + e) & 0xffffffff;
 	}
 }
+
+export class MD5 extends Hash
+{
+	constructor()
+	{
+		super();
+		this.buff = new Array(64);
+		this.clear();
+	}
+
+	getName()
+	{
+		return "MD5";
+	}
+
+	clone()
+	{
+		let md5 = new MD5();
+		md5.msgLeng = this.msgLeng;
+		md5.h[0] = this.h[0];
+		md5.h[1] = this.h[1];
+		md5.h[2] = this.h[2];
+		md5.h[3] = this.h[3];
+		md5.buffSize = this.buffSize;
+		return md5;
+	}
+
+	clear()
+	{
+		this.msgLeng = 0n;
+		this.h = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476];
+		this.buffSize = 0;
+	}
+
+	calc(buff)
+	{
+		if (!(buff instanceof ArrayBuffer))
+			return;
+		let i = 0;
+		let arr;
+		this.msgLeng += BigInt(buff.byteLength << 3);
+		if ((buff.byteLength + this.buffSize) < 64)
+		{
+			arr = new Uint8Array(buff);
+			while (i < buff.byteLength)
+			{
+				this.buff[this.buffSize + i] = arr[i];
+				i++;
+			}
+			this.buffSize += buff.byteLength;
+			return;
+		}
+	
+		if (this.buffSize > 0)
+		{
+			arr = new Uint8Array(buff);
+			while (this.buffSize < 64)
+			{
+				this.buff[this.buffSize] = arr[i];
+				this.buffSize++;
+				i++;
+			}
+			MD5.calcBlock(this.h, new Uint8Array(this.buff).buffer);
+			this.buffSize = 0;
+		}
+		while (i + 64 <= buff.byteLength)
+		{
+			MD5.calcBlock(this.h, buff.slice(i, i + 64));
+			i += 64;
+		}
+		if (i < buff.byteLength)
+		{
+			arr = new Uint8Array(buff);
+			while (i < buff.byteLength)
+			{
+				this.buff[this.buffSize] = arr[i];
+				this.buffSize++;
+				i++;
+			}
+		}	
+	}
+
+	getValue()
+	{
+		let calBuff = new Array(64);
+		let intHash = [
+			this.h[0],
+			this.h[1],
+			this.h[2],
+			this.h[3]];
+		let i;
+		i = 0;
+		while (i < this.buffSize)
+		{
+			calBuff[i] = this.buff[i];
+			i++;
+		}
+		if (this.buffSize < 56)
+		{
+			i = this.buffSize;
+			calBuff[i++] = 0x80;
+			while (i < 56)
+			{
+				calBuff[i] = 0;
+				i++;
+			}
+	
+		}
+		else
+		{
+			i = this.buffSize;
+			calBuff[i++] = 0x80;
+			while (i < 64)
+			{
+				calBuff[i] = 0;
+				i++;
+			}
+			MD5.calcBlock(intHash, calBuff);
+			i = 0;
+			while (i < 56)
+			{
+				calBuff[i] = 0;
+				i++;
+			}
+		}
+		let view = new DataView(new Uint8Array(calBuff).buffer);
+		view.setBigUint64(56, this.msgLeng, true);
+		MD5.calcBlock(intHash, view.buffer);
+		view = new DataView(new ArrayBuffer(16));
+		i = 16;
+		while (i > 0)
+		{
+			i -= 4;
+			view.setUint32(i, intHash[i >> 2], true);
+		}
+		return view.buffer;
+	}
+
+	getBlockSize()
+	{
+		return 64;
+	}
+
+	static step1(vals, w, x, y, z, dataNum, s)
+	{
+		vals[w] += vals[z] ^ (vals[x] & (vals[y] ^ vals[z]));
+		vals[w] += dataNum;
+		vals[w] = data.rol32(vals[w], s);
+		vals[w] += vals[x];
+	}
+	
+	static step2(vals, w, x, y, z, dataNum, s)
+	{
+		vals[w] += vals[y] ^ (vals[z] & (vals[x] ^ vals[y]));
+		vals[w] += dataNum;
+		vals[w] = data.rol32(vals[w], s);
+		vals[w] += vals[x];
+	}
+
+	static step3(vals, w, x, y, z, dataNum, s)
+	{
+		vals[w] += vals[z] ^ vals[y] ^ vals[x];
+		vals[w] += dataNum;
+		vals[w] = data.rol32(vals[w], s);
+		vals[w] += vals[x];
+	}
+	
+	static step4(vals, w, x, y, z, dataNum, s)
+	{
+		vals[w] += vals[y] ^ (vals[x] | ~vals[z]);
+		vals[w] += dataNum;
+		vals[w] = data.rol32(vals[w], s);
+		vals[w] += vals[x];
+	}
+
+	static calcBlock(hVals, block)
+	{
+		let view = new DataView(block);
+		let blk = [view.getUint32(0, true),
+			view.getUint32(4, true),
+			view.getUint32(8, true),
+			view.getUint32(12, true),
+			view.getUint32(16, true),
+			view.getUint32(20, true),
+			view.getUint32(24, true),
+			view.getUint32(28, true),
+			view.getUint32(32, true),
+			view.getUint32(36, true),
+			view.getUint32(40, true),
+			view.getUint32(44, true),
+			view.getUint32(48, true),
+			view.getUint32(52, true),
+			view.getUint32(56, true),
+			view.getUint32(60, true)];
+		let vals = [hVals[0], hVals[1], hVals[2], hVals[3]];
+		let a = 0;
+		let b = 1;
+		let c = 2;
+		let d = 3;
+	
+		MD5.step1(vals, a, b, c, d, blk[0] + 0xd76aa478, 7);
+		MD5.step1(vals, d, a, b, c, blk[1] + 0xe8c7b756, 12);
+		MD5.step1(vals, c, d, a, b, blk[2] + 0x242070db, 17);
+		MD5.step1(vals, b, c, d, a, blk[3] + 0xc1bdceee, 22);
+		MD5.step1(vals, a, b, c, d, blk[4] + 0xf57c0faf, 7);
+		MD5.step1(vals, d, a, b, c, blk[5] + 0x4787c62a, 12);
+		MD5.step1(vals, c, d, a, b, blk[6] + 0xa8304613, 17);
+		MD5.step1(vals, b, c, d, a, blk[7] + 0xfd469501, 22);
+		MD5.step1(vals, a, b, c, d, blk[8] + 0x698098d8, 7);
+		MD5.step1(vals, d, a, b, c, blk[9] + 0x8b44f7af, 12);
+		MD5.step1(vals, c, d, a, b, blk[10] + 0xffff5bb1, 17);
+		MD5.step1(vals, b, c, d, a, blk[11] + 0x895cd7be, 22);
+		MD5.step1(vals, a, b, c, d, blk[12] + 0x6b901122, 7);
+		MD5.step1(vals, d, a, b, c, blk[13] + 0xfd987193, 12);
+		MD5.step1(vals, c, d, a, b, blk[14] + 0xa679438e, 17);
+		MD5.step1(vals, b, c, d, a, blk[15] + 0x49b40821, 22);
+
+		MD5.step2(vals, a, b, c, d, blk[1] + 0xf61e2562, 5);
+		MD5.step2(vals, d, a, b, c, blk[6] + 0xc040b340, 9);
+		MD5.step2(vals, c, d, a, b, blk[11] + 0x265e5a51, 14);
+		MD5.step2(vals, b, c, d, a, blk[0] + 0xe9b6c7aa, 20);
+		MD5.step2(vals, a, b, c, d, blk[5] + 0xd62f105d, 5);
+		MD5.step2(vals, d, a, b, c, blk[10] + 0x02441453, 9);
+		MD5.step2(vals, c, d, a, b, blk[15] + 0xd8a1e681, 14);
+		MD5.step2(vals, b, c, d, a, blk[4] + 0xe7d3fbc8, 20);
+		MD5.step2(vals, a, b, c, d, blk[9] + 0x21e1cde6, 5);
+		MD5.step2(vals, d, a, b, c, blk[14] + 0xc33707d6, 9);
+		MD5.step2(vals, c, d, a, b, blk[3] + 0xf4d50d87, 14);
+		MD5.step2(vals, b, c, d, a, blk[8] + 0x455a14ed, 20);
+		MD5.step2(vals, a, b, c, d, blk[13] + 0xa9e3e905, 5);
+		MD5.step2(vals, d, a, b, c, blk[2] + 0xfcefa3f8, 9);
+		MD5.step2(vals, c, d, a, b, blk[7] + 0x676f02d9, 14);
+		MD5.step2(vals, b, c, d, a, blk[12] + 0x8d2a4c8a, 20);
+
+		MD5.step3(vals, a, b, c, d, blk[5] + 0xfffa3942, 4);
+		MD5.step3(vals, d, a, b, c, blk[8] + 0x8771f681, 11);
+		MD5.step3(vals, c, d, a, b, blk[11] + 0x6d9d6122, 16);
+		MD5.step3(vals, b, c, d, a, blk[14] + 0xfde5380c, 23);
+		MD5.step3(vals, a, b, c, d, blk[1] + 0xa4beea44, 4);
+		MD5.step3(vals, d, a, b, c, blk[4] + 0x4bdecfa9, 11);
+		MD5.step3(vals, c, d, a, b, blk[7] + 0xf6bb4b60, 16);
+		MD5.step3(vals, b, c, d, a, blk[10] + 0xbebfbc70, 23);
+		MD5.step3(vals, a, b, c, d, blk[13] + 0x289b7ec6, 4);
+		MD5.step3(vals, d, a, b, c, blk[0] + 0xeaa127fa, 11);
+		MD5.step3(vals, c, d, a, b, blk[3] + 0xd4ef3085, 16);
+		MD5.step3(vals, b, c, d, a, blk[6] + 0x04881d05, 23);
+		MD5.step3(vals, a, b, c, d, blk[9] + 0xd9d4d039, 4);
+		MD5.step3(vals, d, a, b, c, blk[12] + 0xe6db99e5, 11);
+		MD5.step3(vals, c, d, a, b, blk[15] + 0x1fa27cf8, 16);
+		MD5.step3(vals, b, c, d, a, blk[2] + 0xc4ac5665, 23);
+
+		MD5.step4(vals, a, b, c, d, blk[0] + 0xf4292244, 6);
+		MD5.step4(vals, d, a, b, c, blk[7] + 0x432aff97, 10);
+		MD5.step4(vals, c, d, a, b, blk[14] + 0xab9423a7, 15);
+		MD5.step4(vals, b, c, d, a, blk[5] + 0xfc93a039, 21);
+		MD5.step4(vals, a, b, c, d, blk[12] + 0x655b59c3, 6);
+		MD5.step4(vals, d, a, b, c, blk[3] + 0x8f0ccc92, 10);
+		MD5.step4(vals, c, d, a, b, blk[10] + 0xffeff47d, 15);
+		MD5.step4(vals, b, c, d, a, blk[1] + 0x85845dd1, 21);
+		MD5.step4(vals, a, b, c, d, blk[8] + 0x6fa87e4f, 6);
+		MD5.step4(vals, d, a, b, c, blk[15] + 0xfe2ce6e0, 10);
+		MD5.step4(vals, c, d, a, b, blk[6] + 0xa3014314, 15);
+		MD5.step4(vals, b, c, d, a, blk[13] + 0x4e0811a1, 21);
+		MD5.step4(vals, a, b, c, d, blk[4] + 0xf7537e82, 6);
+		MD5.step4(vals, d, a, b, c, blk[11] + 0xbd3af235, 10);
+		MD5.step4(vals, c, d, a, b, blk[2] + 0x2ad7d2bb, 15);
+		MD5.step4(vals, b, c, d, a, blk[9] + 0xeb86d391, 21);
+
+		vals[a] += hVals[0];
+		vals[b] += hVals[1];
+		vals[c] += hVals[2];
+		vals[d] += hVals[3];
+		hVals[0] = vals[a];
+		hVals[1] = vals[b];
+		hVals[2] = vals[c];
+		hVals[3] = vals[d];
+	}
+}

package/package.json

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

package/text.js

@@ -464,7 +464,8 @@ export function isHKID(s)
 		thisChk += (hkid.charCodeAt(5) - 0x30) * 4;
 		thisChk += (hkid.charCodeAt(6) - 0x30) * 3;
 		thisChk += (hkid.charCodeAt(7) - 0x30) * 2;
-		if (ichk != (thisChk % 11))
+		thisChk += ichk;
+		if ((thisChk % 11) != 0)
 			return false;
 		return true;
 	}
@@ -487,7 +488,8 @@ export function isHKID(s)
 		thisChk += (hkid.charCodeAt(4) - 0x30) * 4;
 		thisChk += (hkid.charCodeAt(5) - 0x30) * 3;
 		thisChk += (hkid.charCodeAt(6) - 0x30) * 2;
-		if (ichk != (thisChk % 11))
+		thisChk += ichk;
+		if ((thisChk % 11) != 0)
 			return false;
 		return true;
 	}

package/web.d.ts

@@ -23,7 +23,7 @@ export function appendUrl(targetUrl: string, docUrl: string): string;
 export function mimeFromFileName(fileName: string): string;
 export function mimeFromExt(ext: string): string;
 export function getImageInfo(url: string): Promise<ImageInfo|null>;
-export function propertiesToHTML(prop: object): string;
+export function propertiesToHTML(prop: object, nameMap?: object, timeFormat?: string): string;
 export function getCacheSize(name: string): Promise<number>;
 
 declare class DialogButton

package/web.js

@@ -721,22 +721,52 @@ export function getImageInfo(url)
     });
 }
 
-export function propertiesToHTML(prop)
+export function propertiesToHTML(prop, nameMap, timeFormat)
 {
 	let ret = ["<ul>"];
 	let i;
-	for (i in prop)
+	if (nameMap)
 	{
-		ret.push("<li><b>"+text.toHTMLText(i)+": </b>");
-		if (typeof prop[i] == "object")
+		for (i in prop)
 		{
-			ret.push(propertiesToHTML(prop[i]));
+			if (nameMap[i])
+			{
+				ret.push("<li><b>"+nameMap[i]+": </b>");
+				if (prop[i] instanceof data.Timestamp)
+				{
+					ret.push(text.toHTMLText(prop[i].toString(timeFormat)));
+				}
+				else if (typeof prop[i] == "object")
+				{
+					ret.push(propertiesToHTML(prop[i], null, timeFormat));
+				}
+				else
+				{
+					ret.push(text.toHTMLText(""+prop[i]));
+				}
+				ret.push("</li>");
+			}
 		}
-		else
+	}
+	else
+	{
+		for (i in prop)
 		{
-			ret.push(text.toHTMLText(""+prop[i]));
+			ret.push("<li><b>"+text.toHTMLText(i)+": </b>");
+			if (prop[i] instanceof data.Timestamp)
+			{
+				ret.push(text.toHTMLText(prop[i].toString(timeFormat)));
+			}
+			else if (typeof prop[i] == "object")
+			{
+				ret.push(propertiesToHTML(prop[i], null, timeFormat));
+			}
+			else
+			{
+				ret.push(text.toHTMLText(""+prop[i]));
+			}
+			ret.push("</li>");
 		}
-		ret.push("</li>");
 	}
 	ret.push("</ul>");
 	return ret.join("");
@@ -776,6 +806,23 @@ export class Dialog
 		this.darkColor = null;
 	}
 
+	getDocBody()
+	{
+		if (top.document.body.nodeName.toLowerCase() == "frameset")
+		{
+			let w = window;
+			while (w.parent && w.parent.document.body.nodeName.toLowerCase() != "frameset")
+			{
+				w = w.parent;
+			}
+			return w.document.body;
+		}
+		else
+		{
+			return top.document.body;
+		}
+	}
+
 	show()
 	{
 		if (this.darkColor)
@@ -789,10 +836,11 @@ export class Dialog
 		darkColor.style.display = "flex";
 		darkColor.style.alignItems = "center";
 		darkColor.style.justifyContent = "center";
-		if (top.document.body.children.length > 0)
-			top.document.body.insertBefore(darkColor, top.document.body.children[0]);
+		let docBody = this.getDocBody();
+		if (docBody.children.length > 0)
+			docBody.insertBefore(darkColor, docBody.children[0]);
 		else
-			top.document.body.appendChild(darkColor);
+			docBody.appendChild(darkColor);
 		this.darkColor = darkColor;
 		let dialog = document.createElement("div");
 		dialog.style.backgroundColor = "#ffffff";
@@ -868,7 +916,7 @@ export class Dialog
 	{
 		if (this.darkColor)
 		{
-			top.document.body.removeChild(this.darkColor);
+			this.getDocBody().removeChild(this.darkColor);
 			this.darkColor = null;
 		}
 	}