typepki-strconv 0.1.0

package/src/conv_ucs2.mts

@@ -0,0 +1,47 @@
+import { hextoutf8 } from "./conv.mts";
+
+/**
+ * convert UCS-2 hexadecimal stirng to UTF-8 string
+ * @param s - hexadecimal string of UCS-2 string (ex. "0066")
+ * @return UTF-8 string
+ *
+ * @description
+ * This function converts hexadecimal value of UCS-2 string to
+ * UTF-8 string.
+ *
+ * @example
+ * ucs2hextoutf8("006600fc0072") -> "für"
+ */
+/*
+See: http://nomenclator.la.coocan.jp/unicode/ucs_utf.htm
+UCS-2 to UTF-8
+UCS-2 code point | UCS-2 bytes       | UTF-8 bytes
+U+0000 .. U+007F | 00000000-0xxxxxxx | 0xxxxxxx (1 byte)
+U+0080 .. U+07FF | 00000xxx-xxyyyyyy | 110xxxxx 10yyyyyy (2 byte)
+U+0800 .. U+FFFF | xxxxyyyy-yyzzzzzz | 1110xxxx 10yyyyyy 10zzzzzz (3 byte)
+ */
+export function ucs2hextoutf8(s: string): string {
+  function _conv(s: string): string {
+    const i1: number = parseInt(s.substr(0, 2), 16);
+    const i2: number = parseInt(s.substr(2), 16);
+    if (i1 === 0 && i2 < 0x80) {
+      // 1 byte
+      return String.fromCharCode(i2);
+    }
+    if (i1 < 8) {
+      // 2 bytes
+      const u1 = 0xc0 | ((i1 & 0x07) << 3) | ((i2 & 0xc0) >> 6);
+      const u2 = 0x80 | (i2 & 0x3f);
+      return hextoutf8(u1.toString(16) + u2.toString(16));
+    }
+    // 3 bytes
+    const u1 = 0xe0 | ((i1 & 0xf0) >> 4);
+    const u2 = 0x80 | ((i1 & 0x0f) << 2) | ((i2 & 0xc0) >> 6);
+    const u3 = 0x80 | (i2 & 0x3f);
+    return hextoutf8(u1.toString(16) + u2.toString(16) + u3.toString(16));
+  }
+  const a: string[] | null = s.match(/.{4}/g);
+  if (a == null) return "";
+  const a2: string[] | null = a.map(_conv);
+  return a2.join("");
+}

package/src/conv_uricmp.mts

@@ -0,0 +1,48 @@
+import { stohex } from "./conv_ba.mts";
+
+/**
+ * convert a URLComponent string such like "%67%68" to a hexadecimal string.
+ * @param s - URIComponent string such like "%67%68"
+ * @return hexadecimal string
+ * @example
+ * uricmptohex("%67%68") -> "6768"
+ */
+export function uricmptohex(s: string): string {
+  return s.replace(/%/g, "");
+}
+
+/**
+ * convert a hexadecimal string to a URLComponent string such like "%67%68".
+ * @param s - hexadecimal string
+ * @return URIComponent string such like "%67%68"
+ * @example
+ * hextouricmp("6768") -> "%67%68"
+ */
+export function hextouricmp(s: string): string {
+  return s.replace(/(..)/g, "%$1");
+}
+
+/**
+ * convert UTF8 hexadecimal string to a URLComponent string such like "%67%68".
+ * @param u8 - UTF8 hexadecimal string
+ * @return URIComponent string such like "%67%68"
+ *
+ * @description
+ * Note that these "<code>0-9A-Za-z!'()*-._~</code>" characters will not
+ * converted to "%xx" format by builtin 'encodeURIComponent()' function.
+ * However this 'encodeURIComponentAll()' function will convert
+ * all of characters into "%xx" format.
+ */
+export function encodeURIComponentAll(u8: string): string {
+  const s = encodeURIComponent(u8);
+  let s2 = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "%") {
+      s2 = s2 + s.substr(i, 3);
+      i = i + 2;
+    } else {
+      s2 = `${s2}%${stohex(s[i])}`;
+    }
+  }
+  return s2;
+}

package/src/conv_uricmp.test.mts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+
+import { encodeURIComponentAll, hextouricmp, uricmptohex } from "./index.mts";
+
+test("uricmptohex", () => {
+  expect(uricmptohex("%67%68")).toBe("6768");
+});
+
+test("hextouricmp", () => {
+  expect(hextouricmp("6768")).toBe("%67%68");
+});
+
+test("encodeURIComponentAll", () => {
+  expect(encodeURIComponentAll("test")).toBe("%74%65%73%74");
+  expect(encodeURIComponentAll("aあa")).toBe("%61%E3%81%82%61");
+});

package/src/conv_zulu.mts

@@ -0,0 +1,208 @@
+/**
+ * GeneralizedTime or UTCTime string to milliseconds from Unix origin
+ * @param sZulu - GeneralizedTime or UTCTime string (ex. 20170412235959.384Z)
+ * @return milliseconds from Unix origin time (i.e. Jan 1, 1970 0:00:00 UTC)
+ *
+ * @description
+ * This function converts from GeneralizedTime string (i.e. YYYYMMDDHHmmSSZ) or
+ * UTCTime string (i.e. YYMMDDHHmmSSZ) to milliseconds from Unix origin time
+ * (i.e. Jan 1 1970 0:00:00 UTC).
+ * Argument string may have fraction of seconds and
+ * its length is one or more digits such as "20170410235959.1234567Z".
+ * As for UTCTime, if year "YY" is equal or less than 49 then it is 20YY.
+ * If year "YY" is equal or greater than 50 then it is 19YY.
+ *
+ * @example
+ * zulutomsec(  "071231235959Z")       -> 1199145599000 #Mon, 31 Dec 2007 23:59:59 GMT
+ * zulutomsec(  "071231235959.1Z")     -> 1199145599100 #Mon, 31 Dec 2007 23:59:59 GMT
+ * zulutomsec(  "071231235959.12345Z") -> 1199145599123 #Mon, 31 Dec 2007 23:59:59 GMT
+ * zulutomsec("20071231235959Z")       -> 1199145599000 #Mon, 31 Dec 2007 23:59:59 GMT
+ * zulutomsec(  "931231235959Z")       -> -410227201000 #Mon, 31 Dec 1956 23:59:59 GMT
+ */
+export function zulutomsec(sZulu: string): number {
+  let s: string = sZulu;
+  let year: number;
+  let month: number;
+  let day: number;
+  let hour: number;
+  let min: number;
+  let sec: number;
+  let msec: number;
+  let sFrac: string;
+  let sMsec: string;
+
+  s = timetogen(s);
+  const matchResult = s.match(
+    /^(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(|\.\d+)Z$/,
+  );
+
+  if (matchResult) {
+    year = parseInt(matchResult[1]);
+    month = parseInt(matchResult[2]) - 1;
+    day = parseInt(matchResult[3]);
+    hour = parseInt(matchResult[4]);
+    min = parseInt(matchResult[5]);
+    sec = parseInt(matchResult[6]);
+    msec = 0;
+
+    sFrac = matchResult[7];
+    if (sFrac !== "") {
+      sMsec = `${sFrac.substr(1)}00`.substr(0, 3); // .12 -> 012
+      msec = parseInt(sMsec);
+    }
+    return Date.UTC(year, month, day, hour, min, sec, msec);
+  }
+  throw new Error(`unsupported zulu format: ${s}`);
+}
+
+/**
+ * Unix origin milliseconds GeneralizedTime string
+ * @param n - milliseconds from Unix origin time (i.e. Jan 1, 1970 0:00:00 UTC)
+ * @return GeneralizedTime string (ex. 20170412235959.384Z)
+ *
+ * @description
+ * This function converts from milliseconds of Unix origin time (ex. 1199145599000
+ * for 31 Dec 2007 23:59:59 GMT) to GeneralizedTime string (i.e. YYYYMMDDHHmmSSZ).
+ * The result string may have a fraction of second.
+ *
+ * @example
+ * msectozulu(1199145599000) -> "20071231235959Z"       #Mon, 31 Dec 2007 23:59:59     GMT
+ * msectozulu(1199145599100) -> "20071231235959.1Z"     #Mon, 31 Dec 2007 23:59:59.1   GMT
+ * msectozulu(1199145599123) -> "20071231235959.123Z"   #Mon, 31 Dec 2007 23:59:59.123 GMT
+ */
+export function msectozulu(n: number): string {
+  const d = new Date(n);
+  const year = `0000${d.getUTCFullYear()}`.slice(-4);
+  const mon = `00${d.getUTCMonth() + 1}`.slice(-2);
+  const day = `00${d.getUTCDate()}`.slice(-2);
+  const hour = `00${d.getUTCHours()}`.slice(-2);
+  const min = `00${d.getUTCMinutes()}`.slice(-2);
+  const sec = `00${d.getUTCSeconds()}`.slice(-2);
+  let msec = `000${d.getUTCMilliseconds()}`.slice(-3);
+  msec = msec.replace(/0+$/, "");
+  msec = msec !== "" ? `.${msec}` : msec;
+  return `${year + mon + day + hour + min + sec + msec}Z`;
+}
+
+/**
+ * GeneralizedTime or UTCTime string to seconds from Unix origin
+ * @param s - GeneralizedTime or UTCTime string (ex. 20170412235959.384Z)
+ * @return seconds from Unix origin time (i.e. Jan 1, 1970 0:00:00 UTC)
+ *
+ * @description
+ * This function converts from GeneralizedTime string (i.e. YYYYMMDDHHmmSSZ) or
+ * UTCTime string (i.e. YYMMDDHHmmSSZ) to seconds from Unix origin time
+ * (i.e. Jan 1 1970 0:00:00 UTC). Argument string may have fraction of seconds
+ * however result value will be omitted.
+ * As for UTCTime, if year "YY" is equal or less than 49 then it is 20YY.
+ * If year "YY" is equal or greater than 50 then it is 19YY.
+ *
+ * @example
+ * zulutosec(  "071231235959Z")       -> 1199145599 #Mon, 31 Dec 2007 23:59:59 GMT
+ * zulutosec(  "071231235959.1Z")     -> 1199145599 #Mon, 31 Dec 2007 23:59:59 GMT
+ * zulutosec("20071231235959Z")       -> 1199145599 #Mon, 31 Dec 2007 23:59:59 GMT
+ */
+export function zulutosec(s: string): number {
+  return Math.round(zulutomsec(s) / 1000.0);
+}
+
+/**
+ * GeneralizedTime or UTCTime string to Date object
+ * @param s - GeneralizedTime or UTCTime string (ex. 20170412235959.384Z)
+ * @return Date object for specified time
+ *
+ * @description
+ * This function converts from GeneralizedTime string (i.e. YYYYMMDDHHmmSSZ) or
+ * UTCTime string (i.e. YYMMDDHHmmSSZ) to Date object.
+ * Argument string may have fraction of seconds and
+ * its length is one or more digits such as "20170410235959.1234567Z".
+ * As for UTCTime, if year "YY" is equal or less than 49 then it is 20YY.
+ * If year "YY" is equal or greater than 50 then it is 19YY.
+ *
+ * @example
+ * zulutodate(  "071231235959Z").toUTCString()   -> "Mon, 31 Dec 2007 23:59:59 GMT"
+ * zulutodate(  "071231235959.1Z").toUTCString() -> "Mon, 31 Dec 2007 23:59:59 GMT"
+ * zulutodate("20071231235959Z").toUTCString()   -> "Mon, 31 Dec 2007 23:59:59 GMT"
+ * zulutodate(  "071231235959.34Z").getMilliseconds() -> 340
+ */
+export function zulutodate(s: string): Date {
+  return new Date(zulutomsec(s));
+}
+
+/**
+ * Date object to zulu time string
+ * @param d - Date object for specified time
+ * @param flagUTCTime - if this is true year will be YY otherwise YYYY
+ * @param flagMilli - if this is true result concludes milliseconds
+ * @return GeneralizedTime or UTCTime string (ex. 20170412235959.384Z)
+ *
+ * @description
+ * This function converts from Date object to GeneralizedTime string (i.e. YYYYMMDDHHmmSSZ) or
+ * UTCTime string (i.e. YYMMDDHHmmSSZ).
+ * As for UTCTime, if year "YY" is equal or less than 49 then it is 20YY.
+ * If year "YY" is equal or greater than 50 then it is 19YY.
+ * If flagMilli is true its result concludes milliseconds such like
+ * "20170520235959.42Z".
+ *
+ * @example
+ * d = new Date(Date.UTC(2017,4,20,23,59,59,670));
+ * datetozulu(d) -> "20170520235959Z"
+ * datetozulu(d, true) -> "170520235959Z"
+ * datetozulu(d, false, true) -> "20170520235959.67Z"
+ */
+export function datetozulu(
+  d: Date,
+  flagUTCTime = false,
+  flagMilli = false,
+): string {
+  let s: string;
+  const year = d.getUTCFullYear();
+  if (flagUTCTime) {
+    if (year < 1950 || 2049 < year)
+      throw new Error(`not proper year for UTCTime: ${year}`);
+    s = `${year}`.slice(-2);
+  } else {
+    s = `000${year}`.slice(-4);
+  }
+  s += `0${d.getUTCMonth() + 1}`.slice(-2);
+  s += `0${d.getUTCDate()}`.slice(-2);
+  s += `0${d.getUTCHours()}`.slice(-2);
+  s += `0${d.getUTCMinutes()}`.slice(-2);
+  s += `0${d.getUTCSeconds()}`.slice(-2);
+  if (flagMilli) {
+    const milli = d.getUTCMilliseconds();
+    if (milli !== 0) {
+      let sMilli = `00${milli}`.slice(-3);
+      sMilli = sMilli.replace(/0+$/g, "");
+      s += `.${sMilli}`;
+    }
+  }
+  s += "Z";
+  return s;
+}
+
+/**
+ * GeneralizedTime or UTCTime string to GeneralizedTime
+ * @param s - GeneralizedTime or UTCTime string (ex. 20170412235959.384Z)
+ * @return GeneralizedTime
+ *
+ * @description
+ * This function converts UTCTime string (i.e. YYMMDDHHmmSSZ ) to
+ * GeneralizedTime (YYYYMMDDHHmmSSZ) when the argument 's' is UTCTime.
+ * Argument string may have fraction of seconds and
+ * its length is one or more digits such as "170410235959.1234567Z".
+ * As for UTCTime, if year "YY" is equal or less than 49 then it is 20YY.
+ * If year "YY" is equal or greater than 50 then it is 19YY.
+ *
+ * @example
+ * timetogen(  "071231235959Z") -> "20071231235959Z"
+ * timetogen(  "971231235959Z") -> "19971231235959Z"
+ * timetogen("20071231235959Z") -> "20071231235959Z"
+ * timetogen(  "971231235959.123Z") -> "19971231235959.123Z"
+ */
+export function timetogen(s: string): string {
+  if (s.match(/^[0-9]{12}Z$/) || s.match(/^[0-9]{12}[.][0-9]*Z$/)) {
+    return s.match(/^[0-4]/) ? `20${s}` : `19${s}`;
+  }
+  return s;
+}

package/src/conv_zulu.test.mts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  datetozulu,
+  msectozulu,
+  zulutodate,
+  zulutomsec,
+  zulutosec,
+} from "./index.mts";
+
+test("zulutomsec", () => {
+  expect(zulutomsec("071231235959Z")).toBe(1199145599000); // Mon, 31 Dec 2007 23:59:59 GMT
+  expect(zulutomsec("071231235959.1Z")).toBe(1199145599100); // Mon, 31 Dec 2007 23:59:59 GMT
+  expect(zulutomsec("071231235959.12345Z")).toBe(1199145599123); // Mon, 31 Dec 2007 23:59:59 GMT
+  expect(zulutomsec("20071231235959Z")).toBe(1199145599000); // Mon, 31 Dec 2007 23:59:59 GMT
+  //expect(zulutomsec(  "931231235959Z"      )).toBe(-410227201000); // Mon, 31 Dec 1956 23:59:59 GMT
+});
+
+test("msectozulu", () => {
+  expect(msectozulu(1199145599000)).toBe("20071231235959Z"); // Mon, 31 Dec 2007 23:59:59     GMT
+  expect(msectozulu(1199145599100)).toBe("20071231235959.1Z"); // Mon, 31 Dec 2007 23:59:59.1   GMT
+  expect(msectozulu(1199145599123)).toBe("20071231235959.123Z"); // Mon, 31 Dec 2007 23:59:59.123 GMT
+});
+
+test("zulutosec", () => {
+  expect(zulutosec("071231235959Z")).toBe(1199145599); // Mon, 31 Dec 2007 23:59:59 GMT
+  expect(zulutosec("071231235959.1Z")).toBe(1199145599); // Mon, 31 Dec 2007 23:59:59 GMT
+  expect(zulutosec("20071231235959Z")).toBe(1199145599); // Mon, 31 Dec 2007 23:59:59 GMT
+});
+
+test("zulutodate", () => {
+  expect(zulutodate("071231235959Z").toUTCString()).toBe(
+    "Mon, 31 Dec 2007 23:59:59 GMT",
+  );
+  expect(zulutodate("071231235959.1Z").toUTCString()).toBe(
+    "Mon, 31 Dec 2007 23:59:59 GMT",
+  );
+  expect(zulutodate("20071231235959Z").toUTCString()).toBe(
+    "Mon, 31 Dec 2007 23:59:59 GMT",
+  );
+  expect(zulutodate("071231235959.34Z").getMilliseconds()).toBe(340);
+});
+
+test("datetozulu", () => {
+  const d = new Date(Date.UTC(2017, 4, 20, 23, 59, 59, 670));
+  expect(datetozulu(d)).toBe("20170520235959Z");
+  expect(datetozulu(d, true)).toBe("170520235959Z");
+  expect(datetozulu(d, false, true)).toBe("20170520235959.67Z");
+});

package/src/index.cts

@@ -0,0 +1 @@
+module.exports = require("./index.mts");

package/src/index.mts

@@ -0,0 +1,100 @@
+const VERSION: string = "typepki-strconv 0.1.0 kjur.github.io/typepki-strconv";
+export { VERSION };
+
+import { BAtohex, BAtos, stoBA, stohex } from "./conv_ba.mts";
+export { stohex, BAtohex, stoBA, BAtos };
+
+import {
+  Dictionary,
+  aryval,
+  b64tob64u,
+  b64tohex,
+  b64toutf8,
+  b64utob64,
+  b64utohex,
+  b64utoutf8,
+  binstrtobitstr,
+  bitstrtobinstr,
+  hextob64,
+  hextob64u,
+  hextorstr,
+  hextoutf8,
+  inttobitstr,
+  namearraytobinstr,
+  rstrtob64,
+  rstrtohex,
+  strpad,
+  utf8tob64,
+  utf8tob64u,
+  utf8tohex,
+} from "./conv.mts";
+export {
+  b64tohex,
+  hextob64,
+  b64toutf8,
+  utf8tob64,
+  b64utoutf8,
+  utf8tob64u,
+  hextoutf8,
+  utf8tohex,
+  b64utohex,
+  hextob64u,
+  b64tob64u,
+  b64utob64,
+  hextorstr,
+  rstrtohex,
+  binstrtobitstr,
+  bitstrtobinstr,
+  inttobitstr,
+  strpad,
+  namearraytobinstr,
+  aryval,
+  rstrtob64,
+};
+export type { Dictionary };
+
+import { iso88591hextoutf8, utf8toiso88591hex } from "./conv_iso88591.mts";
+export { iso88591hextoutf8, utf8toiso88591hex };
+
+import {
+  b64nltohex,
+  b64topem,
+  foldnl,
+  hextopem,
+  pemtob64,
+  pemtohex,
+} from "./conv_pem.mts";
+export { pemtohex, hextopem, pemtob64, b64topem, b64nltohex, foldnl };
+
+import { ArrayBuffertohex, hextoArrayBuffer } from "./conv_arybuf.mts";
+export { hextoArrayBuffer, ArrayBuffertohex };
+
+import {
+  datetozulu,
+  msectozulu,
+  timetogen,
+  zulutodate,
+  zulutomsec,
+  zulutosec,
+} from "./conv_zulu.mts";
+export { zulutomsec, msectozulu, zulutosec, zulutodate, datetozulu, timetogen };
+
+import {
+  encodeURIComponentAll,
+  hextouricmp,
+  uricmptohex,
+} from "./conv_uricmp.mts";
+export { encodeURIComponentAll, hextouricmp, uricmptohex };
+
+import {
+  hextoip,
+  hextoipv6,
+  ipnetmask,
+  ipprefixlen,
+  iptohex,
+  ipv6tohex,
+} from "./conv_ip.mts";
+export { ipv6tohex, hextoipv6, hextoip, iptohex, ipprefixlen, ipnetmask };
+
+import { ucs2hextoutf8 } from "./conv_ucs2.mts";
+export { ucs2hextoutf8 };

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "types": ["bun-types"],
+
+    "lib": ["esnext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+
+    "noEmit": true,
+
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  }
+}