@sswroom/sswr 1.6.2 → 1.6.4

package/Changelog

@@ -1,3 +1,23 @@
+1.6.4
+-Support geometry.Polyline
+-Fixed geometry.Polygon.insideOrTouch
+-Fixed geometry.MultiGeometry.insideOrTouch
+-leaflet.createFromKML support group in group
+-parser.parseKMLContainer hide Schema message
+-Added data.Timestamp.toDate()
+-Added data.Weekday enum
+-Added data.DateTimeUtil.ticks2Weekday()
+-Added data.LocalDate.getWeekday()
+-Added data.StringMap and data.NumberMap interface type
+-Fixed math.GeoJSON.parseGeometry
+
+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

@@ -1,3 +1,22 @@
+export enum Weekday
+{
+	Sunday,
+	Monday,
+	Tuesday,
+	Wednesday,
+	Thursday,
+	Friday,
+	Saturday
+}
+
+interface StringMap<Type> {
+	[key: string]: Type;
+}
+
+interface NumberMap<Type> {
+	[key: number]: Type;
+}
+
 export function isArray(o: any): boolean;
 export function isObject(o: any): boolean;
 export function toObjectString(o: any, lev: number): string;
@@ -17,6 +36,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
 {
@@ -52,6 +72,7 @@ export class DateTimeUtil
 	static secs2TimeValue(secs: bigint, tzQhr?: number): TimeValue;
 	static totalDays2DateValue(totalDays: number, d: DateValue): void;
 	static instant2TimeValue(secs: bigint, nanosec: number, tzQhr?: number): TimeValue;
+	static ticks2Weekday(ticks: number, tzQhr: number): Weekday;
 	static toString(tval: TimeValue, pattern: string): string;
 	static string2TimeValue(dateStr: string, tzQhr?: number): TimeValue;
 	static isYearLeap(year: number): boolean;
@@ -97,6 +118,7 @@ export class LocalDate
 	toString(pattern: string | null): string;
 	compareTo(obj: Date): number;
 	isNull(): boolean;
+	getWeekday(): Weekday;
 	static today(): LocalDate;
 	static fromStr(s: string): LocalDate | null;
 }
@@ -133,6 +155,9 @@ export class TimeInstant
 }
 
 export class Timestamp {
+	inst: TimeInstant;
+	tzQhr: number;
+
 	constructor(inst: TimeInstant, tzQhr?: number);
 	static fromTicks(ticks: number | number, tzQhr?: number): Timestamp;
 	static fromStr(str: string, defTzQhr?: number): Timestamp | null;
@@ -166,6 +191,7 @@ export class Timestamp {
 	diffMS(ts: Timestamp): number;
 	diffSecDbl(ts: Timestamp): number;
 	diff(ts: Timestamp): number;
+	toDate(): LocalDate;
 	toTicks(): number;
 	toDotNetTicks(): number;
 	toUnixTimestamp(): number;

package/data.js

@@ -1,5 +1,15 @@
 import * as text from "./text.js";
 
+export const Weekday = {
+	Sunday: 0,
+	Monday: 1,
+	Tuesday: 2,
+	Wednesday: 3,
+	Thursday: 4,
+	Friday: 5,
+	Saturday: 6
+}
+
 export function isArray(o)
 {
 	return o != null && o.constructor === Array;
@@ -328,6 +338,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()
@@ -812,6 +834,19 @@ export class DateTimeUtil
 		return t;
 	}
 
+	static ticks2Weekday(ticks, tzQhr)
+	{
+		let days = ((ticks + tzQhr * 900000) / 86400000 + 4);
+		if (days >= 0)
+		{
+			return (days % 7);
+		}
+		else
+		{
+			return ((days % 7) + 7);
+		}
+	}
+
 	static toString(tval, pattern)
 	{
 		let output = new Array();
@@ -1786,6 +1821,11 @@ export class LocalDate
 		return this.dateVal == LocalDate.DATE_NULL;
 	}
 
+	getWeekday()
+	{
+		return DateTimeUtil.ticks2Weekday(this.dateVal * 86400000, 0);
+	}
+
 	static today()
 	{
 		let d = new Date();
@@ -2208,6 +2248,11 @@ export class Timestamp
 		return this.inst.diff(ts.inst);
 	}
 
+	toDate()
+	{
+		return new LocalDate(Math.floor(Number((this.inst.sec + BigInt(this.tzQhr * 900)) / 86400n)));
+	}
+
 	toTicks()
 	{
 		return this.inst.toTicks();

package/geometry.d.ts

@@ -85,11 +85,17 @@ export class MultiGeometry<VecType> extends Vector2D
 export class Polygon extends MultiGeometry<LinearRing>
 {
 	constructor(srid: number, coordinates: number[][][]);
+	insideOrTouch(coord: math.Coord2D): boolean;
 }
 
 export class MultiPolygon extends MultiGeometry<Polygon>
 {
-	constructor(srid: number, coordinates: number[][][][]);
+	constructor(srid: number, coordinates?: number[][][][]);
+}
+
+export class Polyline extends MultiGeometry<LineString>
+{
+	constructor(srid: number, coordinates?: number[][][]);
 }
 
 export class GeometryCollection extends MultiGeometry<Vector2D>

package/geometry.js

@@ -370,10 +370,10 @@ export class MultiGeometry extends Vector2D
 
 	insideOrTouch(coord)
 	{
-		let i = this.coordinates.length;
+		let i = this.geometries.length;
 		while (i-- > 0)
 		{
-			if (this.coordinates[i].insideOrTouch(coord))
+			if (this.geometries[i].insideOrTouch(coord))
 			{
 				return true;
 			}
@@ -420,11 +420,11 @@ export class Polygon extends MultiGeometry
 
 	insideOrTouch(coord)
 	{
-		let i = this.coordinates.length;
+		let i = this.geometries.length;
 		let inside = false;
 		while (i-- > 0)
 		{
-			if (this.coordinates[i].insideOrTouch(coord))
+			if (this.geometries[i].insideOrTouch(coord))
 			{
 				inside = !inside;
 			}
@@ -450,6 +450,23 @@ export class MultiPolygon extends MultiGeometry
 	}
 }
 
+export class Polyline extends MultiGeometry
+{
+	constructor(srid, coordinates)
+	{
+		super(srid);
+		this.type = VectorType.Polyline;
+		let i;
+		if (coordinates)
+		{
+			for (i in coordinates)
+			{
+				this.geometries.push(new LineString(srid, coordinates[i]));
+			}
+		}
+	}
+}
+
 export class GeometryCollection extends MultiGeometry
 {
 	constructor(srid)

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/leaflet.js

@@ -69,12 +69,27 @@ export function createFromKML(feature, options)
 	if (feature instanceof kml.Container)
 	{
 		let i;
-		let layers = L.featureGroup();
+		let layers = [];
+		let lyr;
+		let hasGroup = false;
+		let hasFeature = false;
 		for (i in feature.features)
 		{
-			createFromKML(feature.features[i], options).addTo(layers);
+			lyr = createFromKML(feature.features[i], options);
+			layers.push(lyr);
+			if ((lyr instanceof L.FeatureGroup) || (lyr instanceof L.LayerGroup))
+				hasGroup = true;
+			else
+				hasFeature = true;
+		}
+		if (hasGroup)
+		{
+			return L.layerGroup(layers);
+		}
+		else
+		{
+			return L.featureGroup(layers);
 		}
-		return layers;
 	}
 	else if (feature instanceof kml.Placemark)
 	{
@@ -162,7 +177,7 @@ export function createFromGeometry(geom, options)
 		{
 			if (options.name)
 				opt.title = options.name;
-			if (options.icon)
+			if (options.icon && options.icon.iconUrl)
 				opt.icon = options.icon;
 		}
 		return L.marker(L.latLng(geom.coordinates[1], geom.coordinates[0]), opt);
@@ -190,6 +205,35 @@ export function createFromGeometry(geom, options)
 		}
 		return L.polyline(pts, opt);
 	}
+	else if (geom instanceof geometry.Polyline)
+	{
+		let opt = {};
+		let i;
+		let j;
+		let ptsArr = [];
+		if (options.lineColor)
+			opt.color = options.lineColor;
+		if (options.lineWidth)
+			opt.weight = options.lineWidth;
+		for (i in geom.geometries)
+		{
+			let pts = [];
+			for (j in geom.geometries[i].coordinates)
+			{
+				let latLng = L.latLng(geom.geometries[i].coordinates[j][1], geom.geometries[i].coordinates[j][0]);
+				if (latLng)
+				{
+					pts.push(latLng);
+				}
+				else
+				{
+					console.log("Error in Polyline", geom.geometries[i].coordinates[j]);
+				}
+			}
+			ptsArr.push(pts);
+		}
+		return L.polyline(ptsArr, opt);
+	}
 	else if (geom instanceof geometry.LinearRing)
 	{
 		let opt = {};

package/math.d.ts

@@ -5,7 +5,7 @@ export function roundToFloat(n: number, decimalPoints: number): number;
 export function roundToStr(n: number, decimalPoints: number): string;
 export class GeoJSON
 {
-	static parseGeometry(srid: null, geom: object): geometry.Vector2D | null;
+	static parseGeometry(srid: number, geom: object): geometry.Vector2D | null;
 }
 
 export class Coord2D

package/math.js

@@ -1,3 +1,4 @@
+import * as geometry from "./geometry.js";
 import * as unit from "./unit.js";
 
 export function roundToFloat(n, decimalPoints)

package/package.json

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

package/parser.js

@@ -342,6 +342,8 @@ function parseKMLContainer(container, kmlNode, doc)
 			break;
 		case "#text":
 			break;
+		case "Schema":
+			break;
 		default:
 			console.log("Unknown node in kml container: "+node.nodeName, node);
 			break;
@@ -605,6 +607,15 @@ function parseKMLGeometry(kmlNode)
 				}
 				return geom; 
 			}
+			else if (geomList[0] instanceof geometry.LineString && (geomList.length == 1 || geomList[1] instanceof geometry.LineString))
+			{
+				geom = new geometry.Polyline(4326);
+				for (i in geomList)
+				{
+					geom.geometries.push(geomList[i]);
+				}
+				return geom; 
+			}
 			else
 			{
 				geom = new geometry.GeometryCollection(4326);

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;
 		}
 	}