@sswroom/sswr 1.6.12 → 1.6.14

package/hash.d.ts

@@ -72,4 +72,29 @@ export class MD5 extends Hash
 	getBlockSize(): number;
 
 	static calcBlock(hVals: number[], block: DataView): void;
+}
+
+export class CRC32
+{
+	static getPolynormialIEEE(): number;
+	static getPolynormialCastagnoli(): number;
+}
+
+export class CRC32R extends Hash
+{
+	crctab: number[];
+	currVal: number;
+
+	initTable(polynomial: number): void;
+
+	constructor(param: CRC32R|number|null|undefined);
+
+	getName(): string;
+	clone(): Hash;
+	clear(): void;
+	calc(buff: ArrayBuffer): void;
+	getValue(): ArrayBuffer;
+	getBlockSize(): number;
+
+	calcDirect(buff: ArrayBuffer): number;
 }

package/hash.js

@@ -80,6 +80,9 @@ export class SHA1 extends Hash
 		this.messageBlock = new Array(64);
 	}
 
+	/**
+	 * @param {ArrayBuffer | ArrayLike<number>} buff
+	 */
 	calc(buff)
 	{
 		if (!(buff instanceof ArrayBuffer))
@@ -167,7 +170,7 @@ export class SHA1 extends Hash
 				calBuff[i] = 0;
 				i++;
 			}
-			SHA1.calcBlock(intHash, calBuff);
+			SHA1.calcBlock(intHash, new Uint8Array(calBuff));
 			i = 0;
 			while (i < 56)
 			{
@@ -193,6 +196,10 @@ export class SHA1 extends Hash
 		return 64;
 	}
 
+	/**
+	 * @param {number[]} intermediateHash
+	 * @param {ArrayBuffer} messageBlock
+	 */
 	static calcBlock(intermediateHash, messageBlock)
 	{
 		let w = new Array(80);
@@ -306,6 +313,9 @@ export class MD5 extends Hash
 		this.buffSize = 0;
 	}
 
+	/**
+	 * @param {ArrayBuffer | ArrayLike<number>} buff
+	 */
 	calc(buff)
 	{
 		if (!(buff instanceof ArrayBuffer))
@@ -356,6 +366,7 @@ export class MD5 extends Hash
 
 	getValue()
 	{
+		/** @type {number[]} */
 		let calBuff = new Array(64);
 		let intHash = [
 			this.h[0],
@@ -389,7 +400,7 @@ export class MD5 extends Hash
 				calBuff[i] = 0;
 				i++;
 			}
-			MD5.calcBlock(intHash, calBuff);
+			MD5.calcBlock(intHash, new Uint8Array(calBuff));
 			i = 0;
 			while (i < 56)
 			{
@@ -415,6 +426,15 @@ export class MD5 extends Hash
 		return 64;
 	}
 
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step1(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[z] ^ (vals[x] & (vals[y] ^ vals[z]));
@@ -423,6 +443,15 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 	
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step2(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[y] ^ (vals[z] & (vals[x] ^ vals[y]));
@@ -431,6 +460,15 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step3(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[z] ^ vals[y] ^ vals[x];
@@ -439,6 +477,15 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 	
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step4(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[y] ^ (vals[x] | ~vals[z]);
@@ -447,6 +494,10 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 
+	/**
+	 * @param {number[]} hVals
+	 * @param {ArrayBuffer} block
+	 */
 	static calcBlock(hVals, block)
 	{
 		let view = new DataView(block);
@@ -550,3 +601,207 @@ export class MD5 extends Hash
 		hVals[3] = vals[d];
 	}
 }
+
+/**
+ * @param {number} polynomial
+ */
+function crc32rReverse(polynomial)
+{
+	let v = polynomial;
+	let v2 = 0;
+	let i = 32;
+	while (i-- > 0)
+	{
+		v2 = (v2 >>> 1) | (v & 0x80000000);
+		v <<= 1;
+	}
+	return v2;
+}
+
+/**
+ * @param {number[]} tab
+ * @param {number} rpn
+ */
+function crc32rInitTable(tab, rpn)
+{
+	let i = 256;
+	let j;
+	let v;
+	while (i-- > 0)
+	{
+		v = i;
+		j = 8;
+		while (j-- > 0)
+		{
+			if (v & 1)
+			{
+				v = (v >>> 1) ^ rpn;
+			}
+			else
+			{
+				v = (v >>> 1);
+			}
+		}
+		tab[i] = v;
+	}
+
+	i = 256;
+	while (i-- > 0)
+	{
+		tab[256  + i] = (tab[0    + i] >>> 8) ^ tab[tab[0    + i] & 0xff];
+		tab[512  + i] = (tab[256  + i] >>> 8) ^ tab[tab[256  + i] & 0xff];
+		tab[768  + i] = (tab[512  + i] >>> 8) ^ tab[tab[512  + i] & 0xff];
+		tab[1024 + i] = (tab[768  + i] >>> 8) ^ tab[tab[768  + i] & 0xff];
+		tab[1280 + i] = (tab[1024 + i] >>> 8) ^ tab[tab[1024 + i] & 0xff];
+		tab[1536 + i] = (tab[1280 + i] >>> 8) ^ tab[tab[1280 + i] & 0xff];
+		tab[1792 + i] = (tab[1536 + i] >>> 8) ^ tab[tab[1536 + i] & 0xff];
+		tab[2048 + i] = (tab[1792 + i] >>> 8) ^ tab[tab[1792 + i] & 0xff];
+		tab[2304 + i] = (tab[2048 + i] >>> 8) ^ tab[tab[2048 + i] & 0xff];
+		tab[2560 + i] = (tab[2304 + i] >>> 8) ^ tab[tab[2304 + i] & 0xff];
+		tab[2816 + i] = (tab[2560 + i] >>> 8) ^ tab[tab[2560 + i] & 0xff];
+		tab[3072 + i] = (tab[2816 + i] >>> 8) ^ tab[tab[2816 + i] & 0xff];
+		tab[3328 + i] = (tab[3072 + i] >>> 8) ^ tab[tab[3072 + i] & 0xff];
+		tab[3584 + i] = (tab[3328 + i] >>> 8) ^ tab[tab[3328 + i] & 0xff];
+		tab[3840 + i] = (tab[3584 + i] >>> 8) ^ tab[tab[3584 + i] & 0xff];
+	}
+}
+
+/**
+ * @param {ArrayBuffer} buff
+ * @param {number[]} tab
+ * @param {number} currVal
+ */
+function crc32rCalc(buff, tab, currVal)
+{
+	let reader = new data.ByteReader(buff);
+	let i = 0;
+	let length = reader.getLength();
+	while ((length - i) >= 16)
+	{
+		let currVal1 = reader.readUInt32(i, true) ^ currVal;
+		let currVal2 = reader.readUInt32(i + 4, true);
+		let currVal3 = reader.readUInt32(i + 8, true);
+		let currVal4 = reader.readUInt32(i + 12, true);
+		i += 16;
+		currVal  = tab[0    +  (currVal4 >>> 24)];
+		currVal ^= tab[256  + ((currVal4 >>> 16) & 0xff)];
+		currVal ^= tab[512  + ((currVal4 >>> 8) & 0xff)];
+		currVal ^= tab[768  +  (currVal4 & 0xff)];
+		currVal ^= tab[1024 +  (currVal3 >>> 24)];
+		currVal ^= tab[1280 + ((currVal3 >>> 16) & 0xff)];
+		currVal ^= tab[1536 + ((currVal3 >>> 8) & 0xff)];
+		currVal ^= tab[1792 +  (currVal3 & 0xff)];
+		currVal ^= tab[2048 +  (currVal2 >>> 24)];
+		currVal ^= tab[2304 + ((currVal2 >>> 16) & 0xff)];
+		currVal ^= tab[2560 + ((currVal2 >>> 8) & 0xff)];
+		currVal ^= tab[2816 +  (currVal2 & 0xff)];
+		currVal ^= tab[3072 +  (currVal1 >>> 24)];
+		currVal ^= tab[3328 + ((currVal1 >>> 16) & 0xff)];
+		currVal ^= tab[3584 + ((currVal1 >>> 8) & 0xff)];
+		currVal ^= tab[3840 +  (currVal1  & 0xff)];
+	}
+	while ((length - i) >= 4)
+	{
+		currVal ^= reader.readUInt32(i, true);
+		i += 4;
+		currVal = tab[768 + (currVal & 0xff)] ^ tab[512 + ((currVal >>> 8) & 0xff)] ^  tab[256 + ((currVal >>> 16) & 0xff)] ^ tab[0 + (currVal >>> 24)];
+	}
+	while ((length - i) > 0)
+	{
+		currVal = tab[(currVal & 0xff) ^ reader.readUInt8(i)] ^ (currVal >>> 8);
+		i++;
+	}
+	return currVal;
+}
+
+export class CRC32
+{
+	static getPolynormialIEEE()
+	{
+		return 0x04C11DB7;
+	}
+
+	static getPolynormialCastagnoli()
+	{
+		return 0x1EDC6F41;
+	}
+}
+
+export class CRC32R extends Hash
+{
+	/**
+	 * @param {number} polynomial
+	 */
+	initTable(polynomial)
+	{
+		this.currVal = 0xffffffff;
+		let rpn = crc32rReverse(polynomial);
+		this.crctab = new Array(256 * 16);
+		crc32rInitTable(this.crctab, rpn);
+	}
+
+	/**
+	 * @param {{ crctab: any; currVal: any; }} param
+	 */
+	constructor(param)
+	{
+		super();
+		if (param instanceof CRC32R)
+		{
+			this.crctab = param.crctab;
+			this.currVal = param.currVal;
+		}
+		else if (typeof param == "number")
+		{
+
+			this.initTable(param);
+		}
+		else
+		{
+			this.initTable(CRC32.getPolynormialIEEE());
+		}
+	}
+
+	getName()
+	{
+		return "CRC (32-bit Reversed)";
+	}
+
+	clone()
+	{
+		return new CRC32R(this);
+	}
+
+	clear()
+	{
+		this.currVal = 0xffffffff;
+	}
+
+	/**
+	 * @param {ArrayBuffer} buff
+	 */
+	calc(buff)
+	{
+		this.currVal = crc32rCalc(buff, this.crctab, this.currVal);
+	}
+
+	getValue()
+	{
+		let builder = new data.ByteBuilder();
+		builder.writeInt32(0, ~this.currVal, false);
+		return builder.build();
+	}
+
+	getBlockSize()
+	{
+		return 1;
+	}
+
+	/**
+	 * @param {ArrayBuffer} buff
+	 */
+	calcDirect(buff)
+	{
+		return ~crc32rCalc(buff, this.crctab, 0xffffffff);
+	}
+}

package/osm.js

@@ -1,24 +1,53 @@
+import * as math from "./math.js";
+
+/**
+ * @param {number} lon
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function lon2PixelX(lon, level, tileSize)
 {
 	return ((lon + 180.0) / 360.0 * (1 << level)) * tileSize;
 }
 
+/**
+ * @param {number} lat
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function lat2PixelY(lat, level, tileSize)
 {
 	return ((1.0 - Math.log(Math.tan(lat * Math.PI / 180.0) + 1.0 / Math.cos(lat * Math.PI / 180.0)) / Math.PI) / 2.0 * (1 << level)) * tileSize;
 }
 
+/**
+ * @param {number} x
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function pixelX2Lon(x, level, tileSize)
 {
 	return x / tileSize * 360.0 / (1 << level) - 180;
 }
 
+/**
+ * @param {number} y
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function pixelY2Lat(y, level, tileSize)
 {
 	let n = Math.PI - 2.0 * Math.PI * y / tileSize / (1 << level);
 	return 180.0 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
 }
 
+/**
+ * @param {string} osmUrl
+ * @param {math.Coord2D} minCoord
+ * @param {math.Coord2D} maxCoord
+ * @param {number} minLev
+ * @param {number} maxLev
+ */
 export function tileUrls(osmUrl, minCoord, maxCoord, minLev, maxLev)
 {
 	let tileSize = 256;
@@ -42,7 +71,7 @@ export function tileUrls(osmUrl, minCoord, maxCoord, minLev, maxLev)
 			i = minX;
 			while (i <= maxX)
 			{
-				url = osmUrl.replace("{x}", i).replace("{y}", j).replace("{z}", minLev);
+				url = osmUrl.replace("{x}", ""+i).replace("{y}", ""+j).replace("{z}", ""+minLev);
 				ret.push(url);
 				i++;
 			}
@@ -53,6 +82,13 @@ export function tileUrls(osmUrl, minCoord, maxCoord, minLev, maxLev)
 	return ret;
 }
 
+/**
+ * @param {string[]} urls
+ * @param {string} osmUrl
+ * @param {number} minLev
+ * @param {number} maxLev
+ * @param {math.RectArea[]| null} areaList
+ */
 export function removeTileUrls(urls, osmUrl, minLev, maxLev, areaList)
 {
 	if (areaList == null || areaList.length == 0)
@@ -88,7 +124,7 @@ export function removeTileUrls(urls, osmUrl, minLev, maxLev, areaList)
 				i = minX;
 				while (i <= maxX)
 				{
-					url = osmUrl.replace("{x}", i).replace("{y}", j).replace("{z}", minLev);
+					url = osmUrl.replace("{x}", ""+i).replace("{y}", ""+j).replace("{z}", ""+minLev);
 					delete urlMap[url];
 					i++;
 				}
@@ -104,6 +140,9 @@ export function removeTileUrls(urls, osmUrl, minLev, maxLev, areaList)
 	}
 }
 
+/**
+ * @param {number} scale
+ */
 export function scale2Level(scale)
 {
 	return Math.round(Math.log10(204094080000.0 / scale / 256) / Math.log10(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sswroom/sswr",
-  "version": "1.6.12",
+  "version": "1.6.14",
   "description": "Libraries made by sswroom",
   "main": "sswr.js",
   "scripts": {
@@ -11,5 +11,8 @@
   "devDependencies": {
     "cesium": "^1.113.0",
     "leaflet": "^1.9.4"
+  },
+  "dependencies": {
+    "pako": "^2.1.0"
   }
 }

package/parser.js

@@ -7,6 +7,9 @@ import * as media from "./media.js";
 import * as text from "./text.js";
 import * as web from "./web.js";
 
+/**
+ * @param {ChildNode} node
+ */
 function parseKMLStyle(node)
 {
 	let subNode;
@@ -180,6 +183,11 @@ function parseKMLStyle(node)
 	return style;
 }
 
+/**
+ * @param {kml.Document | kml.Folder} container
+ * @param {ChildNode} kmlNode
+ * @param {kml.Container|undefined} doc
+ */
 function parseKMLContainer(container, kmlNode, doc)
 {
 	doc = doc || container;
@@ -352,6 +360,10 @@ function parseKMLContainer(container, kmlNode, doc)
 	return container;
 }
 
+/**
+ * @param {ChildNode} kmlNode
+ * @param {kml.Container|undefined} doc
+ */
 function parseKMLPlacemark(kmlNode, doc)
 {
 	let node;
@@ -426,6 +438,9 @@ function parseKMLPlacemark(kmlNode, doc)
 	return null;
 }
 
+/**
+ * @param {{ nodeName: any; childNodes: any; }} kmlNode
+ */
 function parseKMLGeometry(kmlNode)
 {
 	let subNode;
@@ -640,6 +655,10 @@ function parseKMLGeometry(kmlNode)
 	return null;
 }
 
+/**
+ * @param {{ childNodes: any; }} kmlNode
+ * @param {any} doc
+ */
 function parseKMLNetworkLink(kmlNode, doc)
 {
 	let name;
@@ -732,6 +751,9 @@ function parseKMLNetworkLink(kmlNode, doc)
 	return null;
 }
 
+/**
+ * @param {{ childNodes: any; }} kmlNode
+ */
 function parseKMLLookAt(kmlNode)
 {
 	let longitude;
@@ -796,6 +818,10 @@ function parseKMLLookAt(kmlNode)
 	}
 }
 
+/**
+ * @param {ChildNode} kmlNode
+ * @param {kml.Container|undefined} [doc]
+ */
 function parseKMLNode(kmlNode, doc)
 {
 	switch (kmlNode.nodeName)
@@ -812,6 +838,10 @@ function parseKMLNode(kmlNode, doc)
 	}
 }
 
+/**
+ * @param {data.ByteReader} reader
+ * @param {string} sourceName
+ */
 async function parseJpg(reader, sourceName)
 {
 	if (!(reader instanceof data.ByteReader))
@@ -950,6 +980,10 @@ async function parseJpg(reader, sourceName)
 	return null;
 }
 
+/**
+ * @param {data.ByteReader} reader
+ * @param {string} sourceName
+ */
 async function parseWebp(reader, sourceName)
 {
 	if (!(reader instanceof data.ByteReader))
@@ -965,6 +999,11 @@ async function parseWebp(reader, sourceName)
 	return simg;
 }
 
+/**
+ * @param {data.ByteReader} reader
+ * @param {string} fileName
+ * @param {string} mime
+ */
 function parseX509(reader, fileName, mime)
 {
 	if (!(reader instanceof data.ByteReader))
@@ -1196,6 +1235,10 @@ function parseX509(reader, fileName, mime)
 	return null;
 }
 
+/**
+ * @param {string} txt
+ * @param {string} sourceName
+ */
 export function parseXML(txt, sourceName)
 {
 	let parser = new DOMParser();
@@ -1238,6 +1281,9 @@ export function parseXML(txt, sourceName)
 
 }
 
+/**
+ * @param {File | Response} file
+ */
 export async function parseFile(file)
 {
 	let t = file.type;