Add TypeScript configuration and convert initial library files

- Add tsconfig.json with strict TypeScript settings
- Convert 6 utility library files to TypeScript:
  - AtobBtoa.ts: Base64 encoding/decoding utilities
  - globalObject.ts: Global object detection for cross-platform support
  - console.ts: Console logging wrapper with proper typing
  - pdfname.ts: PDF name object conversion with type safety
  - rc4.ts: RC4 encryption algorithm with typed parameters
  - md5.ts: MD5 hashing implementation with number array types

All conversions maintain original functionality while adding proper
TypeScript types, replacing var with const/let, and using modern
array parameter syntax.

Author: claude

src/libs/AtobBtoa.ts

@@ -0,0 +1,6 @@
+import { globalObject } from "./globalObject.js";
+
+const atob = globalObject.atob.bind(globalObject);
+const btoa = globalObject.btoa.bind(globalObject);
+
+export { atob, btoa };

src/libs/console.ts

@@ -0,0 +1,33 @@
+import { globalObject } from "./globalObject.js";
+
+function consoleLog(...args: any[]): void {
+  if (globalObject.console && typeof globalObject.console.log === "function") {
+    globalObject.console.log.apply(globalObject.console, args);
+  }
+}
+
+function consoleWarn(...args: any[]): void {
+  if (globalObject.console) {
+    if (typeof globalObject.console.warn === "function") {
+      globalObject.console.warn.apply(globalObject.console, args);
+    } else {
+      consoleLog.call(null, ...args);
+    }
+  }
+}
+
+function consoleError(...args: any[]): void {
+  if (globalObject.console) {
+    if (typeof globalObject.console.error === "function") {
+      globalObject.console.error.apply(globalObject.console, args);
+    } else {
+      consoleLog(...args);
+    }
+  }
+}
+
+export const console = {
+  log: consoleLog,
+  warn: consoleWarn,
+  error: consoleError
+};

src/libs/globalObject.ts

@@ -0,0 +1,9 @@
+export const globalObject: any = (function(): any {
+  return typeof window !== "undefined"
+    ? window
+    : typeof global !== "undefined"
+    ? global
+    : typeof self !== "undefined"
+    ? self
+    : this;
+})();

src/libs/md5.ts

@@ -0,0 +1,224 @@
+/**
+ * @license
+ * Joseph Myers does not specify a particular license for his work.
+ *
+ * Author: Joseph Myers
+ * Accessed from: http://www.myersdaily.org/joseph/javascript/md5.js
+ *
+ * Modified by: Owen Leong
+ */
+
+function md5cycle(x: number[], k: number[]): void {
+  let a = x[0],
+    b = x[1],
+    c = x[2],
+    d = x[3];
+
+  a = ff(a, b, c, d, k[0], 7, -680876936);
+  d = ff(d, a, b, c, k[1], 12, -389564586);
+  c = ff(c, d, a, b, k[2], 17, 606105819);
+  b = ff(b, c, d, a, k[3], 22, -1044525330);
+  a = ff(a, b, c, d, k[4], 7, -176418897);
+  d = ff(d, a, b, c, k[5], 12, 1200080426);
+  c = ff(c, d, a, b, k[6], 17, -1473231341);
+  b = ff(b, c, d, a, k[7], 22, -45705983);
+  a = ff(a, b, c, d, k[8], 7, 1770035416);
+  d = ff(d, a, b, c, k[9], 12, -1958414417);
+  c = ff(c, d, a, b, k[10], 17, -42063);
+  b = ff(b, c, d, a, k[11], 22, -1990404162);
+  a = ff(a, b, c, d, k[12], 7, 1804603682);
+  d = ff(d, a, b, c, k[13], 12, -40341101);
+  c = ff(c, d, a, b, k[14], 17, -1502002290);
+  b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+  a = gg(a, b, c, d, k[1], 5, -165796510);
+  d = gg(d, a, b, c, k[6], 9, -1069501632);
+  c = gg(c, d, a, b, k[11], 14, 643717713);
+  b = gg(b, c, d, a, k[0], 20, -373897302);
+  a = gg(a, b, c, d, k[5], 5, -701558691);
+  d = gg(d, a, b, c, k[10], 9, 38016083);
+  c = gg(c, d, a, b, k[15], 14, -660478335);
+  b = gg(b, c, d, a, k[4], 20, -405537848);
+  a = gg(a, b, c, d, k[9], 5, 568446438);
+  d = gg(d, a, b, c, k[14], 9, -1019803690);
+  c = gg(c, d, a, b, k[3], 14, -187363961);
+  b = gg(b, c, d, a, k[8], 20, 1163531501);
+  a = gg(a, b, c, d, k[13], 5, -1444681467);
+  d = gg(d, a, b, c, k[2], 9, -51403784);
+  c = gg(c, d, a, b, k[7], 14, 1735328473);
+  b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+  a = hh(a, b, c, d, k[5], 4, -378558);
+  d = hh(d, a, b, c, k[8], 11, -2022574463);
+  c = hh(c, d, a, b, k[11], 16, 1839030562);
+  b = hh(b, c, d, a, k[14], 23, -35309556);
+  a = hh(a, b, c, d, k[1], 4, -1530992060);
+  d = hh(d, a, b, c, k[4], 11, 1272893353);
+  c = hh(c, d, a, b, k[7], 16, -155497632);
+  b = hh(b, c, d, a, k[10], 23, -1094730640);
+  a = hh(a, b, c, d, k[13], 4, 681279174);
+  d = hh(d, a, b, c, k[0], 11, -358537222);
+  c = hh(c, d, a, b, k[3], 16, -722521979);
+  b = hh(b, c, d, a, k[6], 23, 76029189);
+  a = hh(a, b, c, d, k[9], 4, -640364487);
+  d = hh(d, a, b, c, k[12], 11, -421815835);
+  c = hh(c, d, a, b, k[15], 16, 530742520);
+  b = hh(b, c, d, a, k[2], 23, -995338651);
+
+  a = ii(a, b, c, d, k[0], 6, -198630844);
+  d = ii(d, a, b, c, k[7], 10, 1126891415);
+  c = ii(c, d, a, b, k[14], 15, -1416354905);
+  b = ii(b, c, d, a, k[5], 21, -57434055);
+  a = ii(a, b, c, d, k[12], 6, 1700485571);
+  d = ii(d, a, b, c, k[3], 10, -1894986606);
+  c = ii(c, d, a, b, k[10], 15, -1051523);
+  b = ii(b, c, d, a, k[1], 21, -2054922799);
+  a = ii(a, b, c, d, k[8], 6, 1873313359);
+  d = ii(d, a, b, c, k[15], 10, -30611744);
+  c = ii(c, d, a, b, k[6], 15, -1560198380);
+  b = ii(b, c, d, a, k[13], 21, 1309151649);
+  a = ii(a, b, c, d, k[4], 6, -145523070);
+  d = ii(d, a, b, c, k[11], 10, -1120210379);
+  c = ii(c, d, a, b, k[2], 15, 718787259);
+  b = ii(b, c, d, a, k[9], 21, -343485551);
+
+  x[0] = add32(a, x[0]);
+  x[1] = add32(b, x[1]);
+  x[2] = add32(c, x[2]);
+  x[3] = add32(d, x[3]);
+}
+
+function cmn(q: number, a: number, b: number, x: number, s: number, t: number): number {
+  a = add32(add32(a, q), add32(x, t));
+  return add32((a << s) | (a >>> (32 - s)), b);
+}
+
+function ff(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+  return cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+
+function gg(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+  return cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+
+function hh(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+  return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+  return cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+function md51(s: string): number[] {
+  // txt = '';
+  const n = s.length;
+  const state: number[] = [1732584193, -271733879, -1732584194, 271733878];
+  let i: number;
+  for (i = 64; i <= s.length; i += 64) {
+    md5cycle(state, md5blk(s.substring(i - 64, i)));
+  }
+  s = s.substring(i - 64);
+  const tail: number[] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  for (i = 0; i < s.length; i++)
+    tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+  tail[i >> 2] |= 0x80 << (i % 4 << 3);
+  if (i > 55) {
+    md5cycle(state, tail);
+    for (i = 0; i < 16; i++) tail[i] = 0;
+  }
+  tail[14] = n * 8;
+  md5cycle(state, tail);
+  return state;
+}
+
+/* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+function md5blk(s: string): number[] {
+  /* I figured global was faster.   */
+  const md5blks: number[] = [];
+  let i: number; /* Andy King said do it this way. */
+  for (i = 0; i < 64; i += 4) {
+    md5blks[i >> 2] =
+      s.charCodeAt(i) +
+      (s.charCodeAt(i + 1) << 8) +
+      (s.charCodeAt(i + 2) << 16) +
+      (s.charCodeAt(i + 3) << 24);
+  }
+  return md5blks;
+}
+
+const hex_chr = "0123456789abcdef".split("");
+
+function rhex(n: number): string {
+  let s = "";
+  let j = 0;
+  for (; j < 4; j++)
+    s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
+  return s;
+}
+
+function hex(x: number[]): string {
+  for (let i = 0; i < x.length; i++) x[i] = rhex(x[i]) as any;
+  return x.join("");
+}
+
+// Converts a 4-byte number to byte string
+function singleToByteString(n: number): string {
+  return String.fromCharCode(
+    (n & 0xff) >> 0,
+    (n & 0xff00) >> 8,
+    (n & 0xff0000) >> 16,
+    (n & 0xff000000) >> 24
+  );
+}
+
+// Converts an array of numbers to a byte string
+function toByteString(x: number[]): string {
+  return x.map(singleToByteString).join("");
+}
+
+// Returns the MD5 hash as a byte string
+function md5Bin(s: string): string {
+  return toByteString(md51(s));
+}
+
+// Returns MD5 hash as a hex string
+function md5(s: string): string {
+  return hex(md51(s));
+}
+
+const md5Check = md5("hello") != "5d41402abc4b2a76b9719d911017c592";
+
+function add32(a: number, b: number): number {
+  if (md5Check) {
+    /* if the md5Check does not match
+     the expected value, we're dealing
+     with an old browser and need
+     this function. */
+    const lsw = (a & 0xffff) + (b & 0xffff);
+    const msw = (a >> 16) + (b >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xffff);
+  } else {
+    /* this function is much faster,
+    so if possible we use it. Some IEs
+    are the only ones I know of that
+    need the idiotic second function,
+    generated by an if clause.  */
+    return (a + b) & 0xffffffff;
+  }
+}
+
+export { md5, md5Bin };

src/libs/pdfname.ts

@@ -0,0 +1,49 @@
+/**
+ * Convert string to `PDF Name Object`.
+ * Detail: PDF Reference 1.3 - Chapter 3.2.4 Name Object
+ * @param str
+ */
+function toPDFName(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  if (/[^\u0000-\u00ff]/.test(str)) {
+    // non ascii string
+    throw new Error(
+      "Invalid PDF Name Object: " + str + ", Only accept ASCII characters."
+    );
+  }
+  let result = "";
+  const strLength = str.length;
+  for (let i = 0; i < strLength; i++) {
+    const charCode = str.charCodeAt(i);
+    if (
+      charCode < 0x21 ||
+      charCode === 0x23 /* # */ ||
+      charCode === 0x25 /* % */ ||
+      charCode === 0x28 /* ( */ ||
+      charCode === 0x29 /* ) */ ||
+      charCode === 0x2f /* / */ ||
+      charCode === 0x3c /* < */ ||
+      charCode === 0x3e /* > */ ||
+      charCode === 0x5b /* [ */ ||
+      charCode === 0x5d /* ] */ ||
+      charCode === 0x7b /* { */ ||
+      charCode === 0x7d /* } */ ||
+      charCode > 0x7e
+    ) {
+      // Char    CharCode    hexStr   paddingHexStr    Result
+      // "\t"    9           9        09               #09
+      // " "     32          20       20               #20
+      // "©"     169         a9       a9               #a9
+      const hexStr = charCode.toString(16);
+      const paddingHexStr = ("0" + hexStr).slice(-2);
+
+      result += "#" + paddingHexStr;
+    } else {
+      // Other ASCII printable characters between 0x21 <= X <= 0x7e
+      result += str[i];
+    }
+  }
+  return result;
+}
+
+export { toPDFName };

src/libs/rc4.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * FPDF is released under a permissive license: there is no usage restriction.
+ * You may embed it freely in your application (commercial or not), with or
+ * without modifications.
+ *
+ * Reference: http://www.fpdf.org/en/script/script37.php
+ */
+
+function repeat(str: string, num: number): string {
+  return new Array(num + 1).join(str);
+}
+
+let lastKey: string | undefined;
+let lastState: number[] | undefined;
+
+/**
+ * Converts a byte string to a hex string
+ *
+ * @name rc4
+ * @function
+ * @param {string} key Byte string of encryption key
+ * @param {string} data Byte string of data to be encrypted
+ * @returns {string} Encrypted string
+ */
+function rc4(key: string, data: string): string {
+  let state: number[];
+  if (key !== lastKey) {
+    const k = repeat(key, ((256 / key.length) >> 0) + 1);
+    state = [];
+    for (let i = 0; i < 256; i++) {
+      state[i] = i;
+    }
+    let j = 0;
+    for (let i = 0; i < 256; i++) {
+      const t = state[i];
+      j = (j + t + k.charCodeAt(i)) % 256;
+      state[i] = state[j];
+      state[j] = t;
+    }
+    lastKey = key;
+    lastState = state;
+  } else {
+    state = lastState!;
+  }
+  const length = data.length;
+  let a = 0;
+  let b = 0;
+  let out = "";
+  for (let i = 0; i < length; i++) {
+    a = (a + 1) % 256;
+    const t = state[a];
+    b = (b + t) % 256;
+    state[a] = state[b];
+    state[b] = t;
+    const k = state[(state[a] + state[b]) % 256];
+    out += String.fromCharCode(data.charCodeAt(i) ^ k);
+  }
+  return out;
+}
+
+export { rc4 };