@kkbt/kdl 0.1.0

package/.zed/settings.json

@@ -0,0 +1,5 @@
+{
+  "language_servers": [
+    "deno"
+  ]
+}

package/README.md

@@ -0,0 +1,6 @@
+# KDL
+
+kkbt Deno libs
+
+- Codeberg https://codeberg.org/kkbt/KDL
+- JSR https://jsr.io/@kkbt/kdl

package/deno.lock

@@ -0,0 +1,23 @@
+{
+  "version": "5",
+  "specifiers": {
+    "jsr:@std/assert@1": "1.0.19",
+    "jsr:@std/internal@^1.0.12": "1.0.14"
+  },
+  "jsr": {
+    "@std/assert@1.0.19": {
+      "integrity": "eaada96ee120cb980bc47e040f82814d786fe8162ecc53c91d8df60b8755991e",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@std/internal@1.0.14": {
+      "integrity": "291516b3d4c35024d6ffbc0a9df5bf4c64116e05b50012cf846710152d2ffdf7"
+    }
+  },
+  "workspace": {
+    "dependencies": [
+      "jsr:@std/assert@1"
+    ]
+  }
+}

package/hi.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 在控制台输出问候信息
+ *
+ * 这是一个简单的工具函数，用于在控制台打印 "Hello, World!"。
+ *
+ * @public
+ * @category Utilities
+ */ export declare function hello(): void;
+/**
+ * 加法运算函数
+ *
+ * 接受两个数字参数并返回它们的和。
+ *
+ * @param a - 第一个操作数，必须是数字类型
+ * @param b - 第二个操作数，必须是数字类型
+ * @returns 返回 a + b 的结果
+ * @throws {TypeError} 如果参数不是数字类型（TypeScript 编译时会检查）
+ *
+ * @example
+ * ```ts
+ * // 基本用法
+ * sum(10, 20); // 返回 30
+ *
+ * // 负数支持
+ * sum(-5, 3); // 返回 -2
+ *
+ * // 浮点数支持
+ * sum(2.5, 3.7); // 返回 6.2
+ * ```
+ *
+ * @public
+ * @category Math
+ */ export declare function sum(a: number, b: number): number;
+export declare class Hi {
+  hello(): void;
+  sum(a: number, b: number): number;
+}

package/hi.js

@@ -0,0 +1,46 @@
+/**
+ * 在控制台输出问候信息
+ *
+ * 这是一个简单的工具函数，用于在控制台打印 "Hello, World!"。
+ *
+ * @public
+ * @category Utilities
+ */ export function hello() {
+  console.log("Hello, World!");
+}
+/**
+ * 加法运算函数
+ *
+ * 接受两个数字参数并返回它们的和。
+ *
+ * @param a - 第一个操作数，必须是数字类型
+ * @param b - 第二个操作数，必须是数字类型
+ * @returns 返回 a + b 的结果
+ * @throws {TypeError} 如果参数不是数字类型（TypeScript 编译时会检查）
+ *
+ * @example
+ * ```ts
+ * // 基本用法
+ * sum(10, 20); // 返回 30
+ *
+ * // 负数支持
+ * sum(-5, 3); // 返回 -2
+ *
+ * // 浮点数支持
+ * sum(2.5, 3.7); // 返回 6.2
+ * ```
+ *
+ * @public
+ * @category Math
+ */ export function sum(a, b) {
+  return a + b;
+}
+export class Hi {
+  hello() {
+    console.log("Hello, World!");
+  }
+  sum(a, b) {
+    return a + b;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vQzovVXNlcnMvc25vd2EvRG9jdW1lbnRzL0NvZGUvS0RML2hpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog5Zyo5o6n5Yi25Y+w6L6T5Ye66Zeu5YCZ5L+h5oGvXG4gKlxuICog6L+Z5piv5LiA5Liq566A5Y2V55qE5bel5YW35Ye95pWw77yM55So5LqO5Zyo5o6n5Yi25Y+w5omT5Y2wIFwiSGVsbG8sIFdvcmxkIVwi44CCXG4gKlxuICogQHB1YmxpY1xuICogQGNhdGVnb3J5IFV0aWxpdGllc1xuICovXG5leHBvcnQgZnVuY3Rpb24gaGVsbG8oKSB7XG4gIGNvbnNvbGUubG9nKFwiSGVsbG8sIFdvcmxkIVwiKTtcbn1cblxuLyoqXG4gKiDliqDms5Xov5Dnrpflh73mlbBcbiAqXG4gKiDmjqXlj5fkuKTkuKrmlbDlrZflj4LmlbDlubbov5Tlm57lroPku6znmoTlkozjgIJcbiAqXG4gKiBAcGFyYW0gYSAtIOesrOS4gOS4quaTjeS9nOaVsO+8jOW/hemhu+aYr+aVsOWtl+exu+Wei1xuICogQHBhcmFtIGIgLSDnrKzkuozkuKrmk43kvZzmlbDvvIzlv4XpobvmmK/mlbDlrZfnsbvlnotcbiAqIEByZXR1cm5zIOi/lOWbniBhICsgYiDnmoTnu5PmnpxcbiAqIEB0aHJvd3Mge1R5cGVFcnJvcn0g5aaC5p6c5Y+C5pWw5LiN5piv5pWw5a2X57G75Z6L77yIVHlwZVNjcmlwdCDnvJbor5Hml7bkvJrmo4Dmn6XvvIlcbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIOWfuuacrOeUqOazlVxuICogc3VtKDEwLCAyMCk7IC8vIOi/lOWbniAzMFxuICpcbiAqIC8vIOi0n+aVsOaUr+aMgVxuICogc3VtKC01LCAzKTsgLy8g6L+U5ZueIC0yXG4gKlxuICogLy8g5rWu54K55pWw5pSv5oyBXG4gKiBzdW0oMi41LCAzLjcpOyAvLyDov5Tlm54gNi4yXG4gKiBgYGBcbiAqXG4gKiBAcHVibGljXG4gKiBAY2F0ZWdvcnkgTWF0aFxuICovXG5leHBvcnQgZnVuY3Rpb24gc3VtKGE6IG51bWJlciwgYjogbnVtYmVyKTogbnVtYmVyIHtcbiAgcmV0dXJuIGEgKyBiO1xufVxuXG5cbmV4cG9ydCBjbGFzcyBIaSB7XG4gIGhlbGxvKCkge1xuICAgIGNvbnNvbGUubG9nKFwiSGVsbG8sIFdvcmxkIVwiKTtcbiAgfVxuICBzdW0oYTogbnVtYmVyLCBiOiBudW1iZXIpOiBudW1iZXIge1xuICAgIHJldHVybiBhICsgYjtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0NBT0MsR0FDRCxPQUFPLFNBQVM7RUFDZCxRQUFRLEdBQUcsQ0FBQztBQUNkO0FBRUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQXdCQyxHQUNELE9BQU8sU0FBUyxJQUFJLENBQVMsRUFBRSxDQUFTO0VBQ3RDLE9BQU8sSUFBSTtBQUNiO0FBR0EsT0FBTyxNQUFNO0VBQ1gsUUFBUTtJQUNOLFFBQVEsR0FBRyxDQUFDO0VBQ2Q7RUFDQSxJQUFJLENBQVMsRUFBRSxDQUFTLEVBQVU7SUFDaEMsT0FBTyxJQUFJO0VBQ2I7QUFDRiJ9

package/libs/demo/main.ts

@@ -0,0 +1,18 @@
+export function handler(req: Request): Response {
+  const url = new URL(req.url);
+
+  if (url.pathname === "/api") {
+    return Response.json({
+      message: "Hello, world!",
+      time: new Date().toISOString(),
+    });
+  }
+
+  return new Response("<h1>Welcome to Deno!</h1>", {
+    headers: { "content-type": "text/html" },
+  });
+}
+
+if (import.meta.main) {
+  Deno.serve(handler);
+}

package/libs/demo/main_test.ts

@@ -0,0 +1,16 @@
+import { assertEquals } from "@std/assert";
+import { handler } from "./main.ts";
+
+Deno.test("returns html on /", async () => {
+  const res = handler(new Request("http://localhost/"));
+  assertEquals(res.headers.get("content-type"), "text/html");
+  const body = await res.text();
+  assertEquals(body.includes("Welcome to Deno"), true);
+});
+
+Deno.test("returns json on /api", async () => {
+  const res = handler(new Request("http://localhost/api"));
+  const data = await res.json();
+  assertEquals(data.message, "Hello, world!");
+  assertEquals(typeof data.time, "string");
+});

package/libs/xxtea/README.md

@@ -0,0 +1,39 @@
+# XXTEA for TypeScript
+
+
+## Introduction
+
+XXTEA is a fast and secure encryption algorithm. This is a XXTEA library for TypeScript.
+
+It is different from the original XXTEA encryption algorithm. It encrypts and decrypts String instead of uint32 Array, and the key is also String.
+
+
+## Usage
+
+```typescript
+
+import XXTEA from "./mod.ts";
+
+let str: string = "Hello World! 你好，中国🇨🇳！";
+let key: string = "1234567890";
+console.log("test str: " + str);
+
+let encrypt_data: any = XXTEA.encryptToBase64(str, key);
+//encryptToBase64: afecHTbSuY20uCrBxOb+joLzYPkIXQ7pF/YT7AmpYRI6ns4O
+console.log("encryptToBase64: " + encrypt_data);
+
+let decrypt_data: any = XXTEA.decryptFromBase64(encrypt_data, key);
+console.log("decryptFromBase64: " + decrypt_data);
+console.log("decryptFromBase64 success: " + (str === decrypt_data));
+
+encrypt_data = XXTEA.encrypt(str, key);
+console.log("encrypt to binary: " + encrypt_data);
+decrypt_data = XXTEA.decrypt(encrypt_data, key);
+console.log("decrypt from binary: " + decrypt_data);
+console.log("decrypt from binary success: " + (str === decrypt_data));
+
+```
+
+
+https://github.com/xxtea/xxtea-js MIT license  
+https://github.com/zhaidw/xxtea-ts MIT license

package/libs/xxtea/xxtea.d.ts

@@ -0,0 +1,37 @@
+/**********************************************************\
+|                                                          |
+| XXTEA.ts                                                 |
+|                                                          |
+| XXTEA encryption algorithm library for TypeScript.       |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Author: Ma Bingyao <mabingyao@gmail.com>            |
+| TS Code Translated by: zhaidw <zhaidw@jiucai.org>        |
+| LastModified: May 9, 2023                                |
+|                                                          |
+\**********************************************************/ export default class XXTEA {
+  constructor();
+  private static btoa: any;
+  private static atob: any;
+  private static DELTA: any;
+  private static toBinaryString: any;
+  private static toUint32Array: any;
+  private static int32: any;
+  private static mx: any;
+  private static fixk: any;
+  private static encryptUint32Array: any;
+  private static decryptUint32Array: any;
+  private static utf8Encode: any;
+  private static utf8DecodeShortString: any;
+  private static utf8DecodeLongString: any;
+  private static utf8Decode: any;
+  public static encrypt(data: string | null, key: string): string | null;
+  public static encryptToBase64(data: string | null, key: string): string | null;
+  public static decrypt(data: string, key: string): string;
+  public static decryptFromBase64(data: string | null, key: string): string | null;
+  public static toBinary(str: string): string;
+  public static fromBinary(binary: string): string;
+}

package/libs/xxtea/xxtea.js

@@ -0,0 +1,536 @@
+// https://github.com/xxtea/xxtea-js MIT license
+// https://github.com/zhaidw/xxtea-ts MIT license
+/**********************************************************\
+|                                                          |
+| XXTEA.ts                                                 |
+|                                                          |
+| XXTEA encryption algorithm library for TypeScript.       |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Author: Ma Bingyao <mabingyao@gmail.com>            |
+| TS Code Translated by: zhaidw <zhaidw@jiucai.org>        |
+| LastModified: May 9, 2023                                |
+|                                                          |
+\**********************************************************/ export default class XXTEA {
+  constructor(){
+    throw new Error("XXTEA should be used as static class");
+  }
+  static btoa(str) {
+    if (str === undefined || str === null || str.length === 0) {
+      return "";
+    }
+    const base64EncodeChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+    let buf = [];
+    let i = 0;
+    let j = 0;
+    let len = str.length;
+    let r = len % 3;
+    len = len - r;
+    let l = len / 3 << 2;
+    if (r > 0) {
+      l += 4;
+    }
+    buf = new Array(l);
+    while(i < len){
+      const c = str.charCodeAt(i++) << 16 | str.charCodeAt(i++) << 8 | str.charCodeAt(i++);
+      buf[j++] = base64EncodeChars[c >> 18] + base64EncodeChars[c >> 12 & 0x3f] + base64EncodeChars[c >> 6 & 0x3f] + base64EncodeChars[c & 0x3f];
+    }
+    if (r == 1) {
+      const c = str.charCodeAt(i++);
+      buf[j++] = base64EncodeChars[c >> 2] + base64EncodeChars[(c & 0x03) << 4] + "==";
+    } else if (r == 2) {
+      const c = str.charCodeAt(i++) << 8 | str.charCodeAt(i++);
+      buf[j++] = base64EncodeChars[c >> 10] + base64EncodeChars[c >> 4 & 0x3f] + base64EncodeChars[(c & 0x0f) << 2] + "=";
+    }
+    return buf.join("");
+  }
+  static atob(str) {
+    if (str === undefined || str === null || str.length === 0) {
+      return "";
+    }
+    const base64DecodeChars = [
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      62,
+      -1,
+      -1,
+      -1,
+      63,
+      52,
+      53,
+      54,
+      55,
+      56,
+      57,
+      58,
+      59,
+      60,
+      61,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      -1,
+      -1,
+      -1,
+      -1,
+      63,
+      -1,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34,
+      35,
+      36,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      46,
+      47,
+      48,
+      49,
+      50,
+      51,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1
+    ];
+    let c1, c2, c3, c4;
+    let i, j, len, r, l;
+    let out;
+    len = str.length;
+    if (len % 4 !== 0) {
+      return "";
+    }
+    if (/[^ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\+\/\=]/.test(str)) {
+      return "";
+    }
+    if (str.charAt(len - 2) == "=") {
+      r = 1;
+    } else if (str.charAt(len - 1) == "=") {
+      r = 2;
+    } else {
+      r = 0;
+    }
+    l = len;
+    if (r > 0) {
+      l -= 4;
+    }
+    l = (l >> 2) * 3 + r;
+    out = new Array(l);
+    i = j = 0;
+    while(i < len){
+      // c1
+      c1 = base64DecodeChars[str.charCodeAt(i++)];
+      if (c1 == -1) break;
+      // c2
+      c2 = base64DecodeChars[str.charCodeAt(i++)];
+      if (c2 == -1) break;
+      out[j++] = String.fromCharCode(c1 << 2 | (c2 & 0x30) >> 4);
+      // c3
+      c3 = base64DecodeChars[str.charCodeAt(i++)];
+      if (c3 == -1) break;
+      out[j++] = String.fromCharCode((c2 & 0x0f) << 4 | (c3 & 0x3c) >> 2);
+      // c4
+      c4 = base64DecodeChars[str.charCodeAt(i++)];
+      if (c4 == -1) break;
+      out[j++] = String.fromCharCode((c3 & 0x03) << 6 | c4);
+    }
+    return out.join("");
+  }
+  static DELTA = 0x9e3779b9;
+  static toBinaryString(v, includeLength) {
+    if (v === undefined || v === null || v.length === 0) {
+      return "";
+    }
+    let length = v.length;
+    let n = length << 2;
+    if (includeLength) {
+      let m = v[length - 1];
+      n -= 4;
+      if (m < n - 3 || m > n) {
+        return null;
+      }
+      n = m;
+    }
+    for(let i = 0; i < length; i++){
+      let byte1 = v[i] & 0xff;
+      let byte2 = v[i] >>> 8 & 0xff;
+      let byte3 = v[i] >>> 16 & 0xff;
+      let byte4 = v[i] >>> 24 & 0xff;
+      v[i] = byte1 | byte2 << 8 | byte3 << 16 | byte4 << 24;
+    }
+    let result = "";
+    for(let i = 0; i < length; i++){
+      result += String.fromCharCode(v[i] & 0xff, v[i] >>> 8 & 0xff, v[i] >>> 16 & 0xff, v[i] >>> 24 & 0xff);
+    }
+    if (includeLength) {
+      return result.substring(0, n);
+    }
+    return result;
+  }
+  static toUint32Array(bs, includeLength) {
+    const length = bs.length;
+    let n = length >> 2;
+    if ((length & 3) !== 0) {
+      ++n;
+    }
+    let v;
+    if (includeLength) {
+      v = new Uint32Array(n + 1);
+      v[n] = length;
+    } else {
+      v = new Uint32Array(n);
+    }
+    for(let i = 0; i < length; ++i){
+      v[i >> 2] |= bs.charCodeAt(i) << ((i & 3) << 3);
+    }
+    return v;
+  }
+  static int32(i) {
+    return i & 0xffffffff;
+  }
+  static mx(sum, y, z, p, e, k) {
+    return (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
+  }
+  static fixk(k) {
+    if (k.length < 4) k.length = 4;
+    return k;
+  }
+  static encryptUint32Array(v, k) {
+    const length = v.length;
+    const n = length - 1;
+    let y, z, sum, e, p, q;
+    z = v[n];
+    sum = 0;
+    for(q = Math.floor(6 + 52 / length) | 0; q > 0; --q){
+      sum = this.int32(sum + this.DELTA);
+      e = sum >>> 2 & 3;
+      for(p = 0; p < n; ++p){
+        y = v[p + 1];
+        z = v[p] = this.int32(v[p] + this.mx(sum, y, z, p, e, k));
+      }
+      y = v[0];
+      z = v[n] = this.int32(v[n] + this.mx(sum, y, z, n, e, k));
+    }
+    return v;
+  }
+  static decryptUint32Array(v, k) {
+    const length = v.length;
+    const n = length - 1;
+    let y, z, sum, e, p, q;
+    y = v[0];
+    q = Math.floor(6 + 52 / length);
+    for(sum = this.int32(q * this.DELTA); sum !== 0; sum = this.int32(sum - this.DELTA)){
+      e = sum >>> 2 & 3;
+      for(p = n; p > 0; --p){
+        z = v[p - 1];
+        y = v[p] = this.int32(v[p] - this.mx(sum, y, z, p, e, k));
+      }
+      z = v[n];
+      y = v[0] = this.int32(v[0] - this.mx(sum, y, z, 0, e, k));
+    }
+    return v;
+  }
+  static utf8Encode(str) {
+    if (/^[\x00-\x7f]*$/.test(str)) {
+      return str;
+    }
+    const buf = [];
+    const n = str.length;
+    for(let i = 0, j = 0; i < n; ++i, ++j){
+      const codeUnit = str.charCodeAt(i);
+      if (codeUnit < 0x80) {
+        buf[j] = codeUnit;
+      } else if (codeUnit < 0x800) {
+        buf[j] = 0xc0 | codeUnit >> 6;
+        buf[j + 1] = 0x80 | codeUnit & 0x3f;
+        ++j;
+      } else if (codeUnit < 0xd800 || codeUnit > 0xdfff) {
+        buf[j] = 0xe0 | codeUnit >> 12;
+        buf[j + 1] = 0x80 | codeUnit >> 6 & 0x3f;
+        buf[j + 2] = 0x80 | codeUnit & 0x3f;
+        j += 2;
+      } else {
+        if (i + 1 < n) {
+          const nextCodeUnit = str.charCodeAt(i + 1);
+          if (codeUnit < 0xdc00 && 0xdc00 <= nextCodeUnit && nextCodeUnit <= 0xdfff) {
+            const rune = ((codeUnit & 0x03ff) << 10 | nextCodeUnit & 0x03ff) + 0x010000;
+            buf[j] = 0xf0 | rune >> 18 & 0x3f;
+            buf[j + 1] = 0x80 | rune >> 12 & 0x3f;
+            buf[j + 2] = 0x80 | rune >> 6 & 0x3f;
+            buf[j + 3] = 0x80 | rune & 0x3f;
+            j += 3;
+            ++i;
+            continue;
+          }
+        }
+        throw new Error("Malformed string");
+      }
+    }
+    return String.fromCharCode.apply(null, buf);
+  }
+  static utf8DecodeShortString(bs, n) {
+    if (bs === undefined || bs === null || bs.length === 0) {
+      return "";
+    }
+    const charCodes = new Array(n);
+    let i = 0, off = 0;
+    for(let len = bs.length; i < n && off < len; i++){
+      const unit = bs.charCodeAt(off++);
+      switch(unit >> 4){
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+          charCodes[i] = unit;
+          break;
+        case 12:
+        case 13:
+          if (off < len) {
+            charCodes[i] = (unit & 0x1f) << 6 | bs.charCodeAt(off++) & 0x3f;
+          } else {
+            throw new Error("Unfinished UTF-8 octet sequence");
+          }
+          break;
+        case 14:
+          if (off + 1 < len) {
+            charCodes[i] = (unit & 0x0f) << 12 | (bs.charCodeAt(off++) & 0x3f) << 6 | bs.charCodeAt(off++) & 0x3f;
+          } else {
+            throw new Error("Unfinished UTF-8 octet sequence");
+          }
+          break;
+        case 15:
+          if (off + 2 < len) {
+            const rune = ((unit & 0x07) << 18 | (bs.charCodeAt(off++) & 0x3f) << 12 | (bs.charCodeAt(off++) & 0x3f) << 6 | bs.charCodeAt(off++) & 0x3f) - 0x10000;
+            if (0 <= rune && rune <= 0xfffff) {
+              charCodes[i++] = rune >> 10 & 0x03ff | 0xd800;
+              charCodes[i] = rune & 0x03ff | 0xdc00;
+            } else {
+              throw new Error("Character outside valid Unicode range: 0x" + rune.toString(16));
+            }
+          } else {
+            throw new Error("Unfinished UTF-8 octet sequence");
+          }
+          break;
+        default:
+          throw new Error("Bad UTF-8 encoding 0x" + unit.toString(16));
+      }
+    }
+    if (i < n) {
+      charCodes.length = i;
+    }
+    return String.fromCharCode(...charCodes);
+  }
+  static utf8DecodeLongString(bs, n) {
+    const buf = [];
+    const charCodes = new Array(0x8000);
+    let i = 0, off = 0;
+    for(let len = bs.length; i < n && off < len; i++){
+      const unit = bs.charCodeAt(off++);
+      switch(unit >> 4){
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+          charCodes[i] = unit;
+          break;
+        case 12:
+        case 13:
+          if (off < len) {
+            charCodes[i] = (unit & 0x1f) << 6 | bs.charCodeAt(off++) & 0x3f;
+          } else {
+            throw new Error("Unfinished UTF-8 octet sequence");
+          }
+          break;
+        case 14:
+          if (off + 1 < len) {
+            charCodes[i] = (unit & 0x0f) << 12 | (bs.charCodeAt(off++) & 0x3f) << 6 | bs.charCodeAt(off++) & 0x3f;
+          } else {
+            throw new Error("Unfinished UTF-8 octet sequence");
+          }
+          break;
+        case 15:
+          if (off + 2 < len) {
+            const rune = ((unit & 0x07) << 18 | (bs.charCodeAt(off++) & 0x3f) << 12 | (bs.charCodeAt(off++) & 0x3f) << 6 | bs.charCodeAt(off++) & 0x3f) - 0x10000;
+            if (0 <= rune && rune <= 0xfffff) {
+              charCodes[i++] = rune >> 10 & 0x03ff | 0xd800;
+              charCodes[i] = rune & 0x03ff | 0xdc00;
+            } else {
+              throw new Error("Character outside valid Unicode range: 0x" + rune.toString(16));
+            }
+          } else {
+            throw new Error("Unfinished UTF-8 octet sequence");
+          }
+          break;
+        default:
+          throw new Error("Bad UTF-8 encoding 0x" + unit.toString(16));
+      }
+      if (i >= 0x7fff - 1) {
+        const size = i + 1;
+        charCodes.length = size;
+        buf[buf.length] = String.fromCharCode.apply(String, charCodes);
+        n -= size;
+        i = -1;
+      }
+    }
+    if (i > 0) {
+      charCodes.length = i;
+      buf[buf.length] = String.fromCharCode.apply(String, charCodes);
+    }
+    return buf.join("");
+  }
+  static utf8Decode(bs, n) {
+    if (bs === undefined || bs === null || bs.length === 0) {
+      return "";
+    }
+    if (n === undefined || n === null || n < 0) n = bs.length;
+    if (n === 0) return "";
+    if (/^[\x00-\x7f]*$/.test(bs) || !/^[\x00-\xff]*$/.test(bs)) {
+      if (n === bs.length) return bs;
+      return bs.substr(0, n);
+    }
+    return n < 0x7fff ? this.utf8DecodeShortString(bs, n) : this.utf8DecodeLongString(bs, n);
+  }
+  static encrypt(data, key) {
+    if (data === undefined || data === null || data.length === 0) {
+      return data;
+    }
+    data = this.utf8Encode(data);
+    key = this.utf8Encode(key);
+    return this.toBinaryString(this.encryptUint32Array(Array.from(this.toUint32Array(data, true)), this.fixk(Array.from(this.toUint32Array(key, false)))), false);
+  }
+  static encryptToBase64(data, key) {
+    return this.btoa(this.encrypt(data, key));
+  }
+  static decrypt(data, key) {
+    if (data === undefined || data === null || data.length === 0) {
+      return data;
+    }
+    key = this.utf8Encode(key);
+    return this.utf8Decode(this.toBinaryString(this.decryptUint32Array(Array.from(this.toUint32Array(data, false)), this.fixk(Array.from(this.toUint32Array(key, false)))), true));
+  }
+  static decryptFromBase64(data, key) {
+    return this.decrypt(this.atob(data), key);
+  }
+  static toBinary(str) {
+    const codeUnits = new Uint16Array(str.length);
+    for(let i = 0; i < codeUnits.length; i++){
+      codeUnits[i] = str.charCodeAt(i);
+    }
+    const charCodes = new Uint8Array(codeUnits.buffer);
+    let result = "";
+    for(let i = 0; i < charCodes.byteLength; i++){
+      result += String.fromCharCode(charCodes[i]);
+    }
+    return result;
+  }
+  static fromBinary(binary) {
+    const bytes = new Uint8Array(binary.length);
+    for(let i = 0; i < bytes.length; i++){
+      bytes[i] = binary.charCodeAt(i);
+    }
+    const charCodes = new Uint16Array(bytes.buffer);
+    let result = "";
+    for(let i = 0; i < charCodes.length; i++){
+      result += String.fromCharCode(charCodes[i]);
+    }
+    return result;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///C:/Users/snowa/Documents/Code/KDL/libs/xxtea/xxtea.ts"],"sourcesContent":["// https://github.com/xxtea/xxtea-js MIT license\n// https://github.com/zhaidw/xxtea-ts MIT license\n\n/**********************************************************\\\n|                                                          |\n| XXTEA.ts                                                 |\n|                                                          |\n| XXTEA encryption algorithm library for TypeScript.       |\n|                                                          |\n| Encryption Algorithm Authors:                            |\n|      David J. Wheeler                                    |\n|      Roger M. Needham                                    |\n|                                                          |\n| Code Author: Ma Bingyao <mabingyao@gmail.com>            |\n| TS Code Translated by: zhaidw <zhaidw@jiucai.org>        |\n| LastModified: May 9, 2023                                |\n|                                                          |\n\\**********************************************************/\n\nexport default class XXTEA {\n  constructor() {\n    throw new Error(\"XXTEA should be used as static class\");\n  }\n\n  private static btoa(str: string | null): string {\n    if (str === undefined || str === null || str.length === 0) {\n      return \"\";\n    }\n\n    const base64EncodeChars =\n      \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\".split(\n        \"\",\n      );\n    let buf: string[] = [];\n    let i: number = 0;\n    let j: number = 0;\n    let len: number = str.length;\n    let r: number = len % 3;\n    len = len - r;\n    let l: number = (len / 3) << 2;\n\n    if (r > 0) {\n      l += 4;\n    }\n\n    buf = new Array<string>(l);\n\n    while (i < len) {\n      const c: number =\n        (str.charCodeAt(i++) << 16) |\n        (str.charCodeAt(i++) << 8) |\n        str.charCodeAt(i++);\n      buf[j++] =\n        base64EncodeChars[c >> 18] +\n        base64EncodeChars[(c >> 12) & 0x3f] +\n        base64EncodeChars[(c >> 6) & 0x3f] +\n        base64EncodeChars[c & 0x3f];\n    }\n\n    if (r == 1) {\n      const c: number = str.charCodeAt(i++);\n      buf[j++] =\n        base64EncodeChars[c >> 2] + base64EncodeChars[(c & 0x03) << 4] + \"==\";\n    } else if (r == 2) {\n      const c: number = (str.charCodeAt(i++) << 8) | str.charCodeAt(i++);\n      buf[j++] =\n        base64EncodeChars[c >> 10] +\n        base64EncodeChars[(c >> 4) & 0x3f] +\n        base64EncodeChars[(c & 0x0f) << 2] +\n        \"=\";\n    }\n\n    return buf.join(\"\");\n  }\n\n  private static atob(str: string | null): string {\n    if (str === undefined || str === null || str.length === 0) {\n      return \"\";\n    }\n\n    const base64DecodeChars: number[] = [\n      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n      -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57,\n      58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,\n      10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1,\n      -1, -1, 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,\n      40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1,\n    ];\n\n    let c1: number, c2: number, c3: number, c4: number;\n    let i: number, j: number, len: number, r: number, l: number;\n    let out: string[];\n\n    len = str.length;\n    if (len % 4 !== 0) {\n      return \"\";\n    }\n    if (\n      /[^ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\\+\\/\\=]/.test(\n        str,\n      )\n    ) {\n      return \"\";\n    }\n    if (str.charAt(len - 2) == \"=\") {\n      r = 1;\n    } else if (str.charAt(len - 1) == \"=\") {\n      r = 2;\n    } else {\n      r = 0;\n    }\n    l = len;\n    if (r > 0) {\n      l -= 4;\n    }\n    l = (l >> 2) * 3 + r;\n    out = new Array(l);\n\n    i = j = 0;\n    while (i < len) {\n      // c1\n      c1 = base64DecodeChars[str.charCodeAt(i++)];\n      if (c1 == -1) break;\n\n      // c2\n      c2 = base64DecodeChars[str.charCodeAt(i++)];\n      if (c2 == -1) break;\n\n      out[j++] = String.fromCharCode((c1 << 2) | ((c2 & 0x30) >> 4));\n\n      // c3\n      c3 = base64DecodeChars[str.charCodeAt(i++)];\n      if (c3 == -1) break;\n\n      out[j++] = String.fromCharCode(((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2));\n\n      // c4\n      c4 = base64DecodeChars[str.charCodeAt(i++)];\n      if (c4 == -1) break;\n\n      out[j++] = String.fromCharCode(((c3 & 0x03) << 6) | c4);\n    }\n\n    return out.join(\"\");\n  }\n\n  private static DELTA = 0x9e3779b9;\n\n  private static toBinaryString(\n    v: number[],\n    includeLength: boolean,\n  ): string | null {\n    if (v === undefined || v === null || v.length === 0) {\n      return \"\";\n    }\n\n    let length = v.length;\n    let n = length << 2;\n    if (includeLength) {\n      let m = v[length - 1];\n      n -= 4;\n      if (m < n - 3 || m > n) {\n        return null;\n      }\n      n = m;\n    }\n    for (let i = 0; i < length; i++) {\n      let byte1 = v[i] & 0xff;\n      let byte2 = (v[i] >>> 8) & 0xff;\n      let byte3 = (v[i] >>> 16) & 0xff;\n      let byte4 = (v[i] >>> 24) & 0xff;\n      v[i] = byte1 | (byte2 << 8) | (byte3 << 16) | (byte4 << 24);\n    }\n    let result = \"\";\n    for (let i = 0; i < length; i++) {\n      result += String.fromCharCode(\n        v[i] & 0xff,\n        (v[i] >>> 8) & 0xff,\n        (v[i] >>> 16) & 0xff,\n        (v[i] >>> 24) & 0xff,\n      );\n    }\n    if (includeLength) {\n      return result.substring(0, n);\n    }\n    return result;\n  }\n\n  private static toUint32Array(\n    bs: string,\n    includeLength: boolean,\n  ): Uint32Array {\n    const length = bs.length;\n    let n = length >> 2;\n    if ((length & 3) !== 0) {\n      ++n;\n    }\n    let v: Uint32Array;\n    if (includeLength) {\n      v = new Uint32Array(n + 1);\n      v[n] = length;\n    } else {\n      v = new Uint32Array(n);\n    }\n    for (let i = 0; i < length; ++i) {\n      v[i >> 2] |= bs.charCodeAt(i) << ((i & 3) << 3);\n    }\n    return v;\n  }\n\n  private static int32(i: number): number {\n    return i & 0xffffffff;\n  }\n\n  private static mx(\n    sum: number,\n    y: number,\n    z: number,\n    p: number,\n    e: number,\n    k: number[],\n  ): number {\n    return (\n      (((z >>> 5) ^ (y << 2)) + ((y >>> 3) ^ (z << 4))) ^\n      ((sum ^ y) + (k[(p & 3) ^ e] ^ z))\n    );\n  }\n\n  private static fixk(k: number[]): number[] {\n    if (k.length < 4) k.length = 4;\n    return k;\n  }\n\n  private static encryptUint32Array(v: number[], k: number[]): number[] {\n    const length = v.length;\n    const n = length - 1;\n    let y: number, z: number, sum: number, e: number, p: number, q: number;\n\n    z = v[n];\n    sum = 0;\n    for (q = Math.floor(6 + 52 / length) | 0; q > 0; --q) {\n      sum = this.int32(sum + this.DELTA);\n      e = (sum >>> 2) & 3;\n      for (p = 0; p < n; ++p) {\n        y = v[p + 1];\n        z = v[p] = this.int32(v[p] + this.mx(sum, y, z, p, e, k));\n      }\n      y = v[0];\n      z = v[n] = this.int32(v[n] + this.mx(sum, y, z, n, e, k));\n    }\n    return v;\n  }\n\n  private static decryptUint32Array(v: number[], k: number[]): number[] {\n    const length = v.length;\n    const n = length - 1;\n    let y: number, z: number, sum: number, e: number, p: number, q: number;\n    y = v[0];\n    q = Math.floor(6 + 52 / length);\n    for (\n      sum = this.int32(q * this.DELTA);\n      sum !== 0;\n      sum = this.int32(sum - this.DELTA)\n    ) {\n      e = (sum >>> 2) & 3;\n      for (p = n; p > 0; --p) {\n        z = v[p - 1];\n        y = v[p] = this.int32(v[p] - this.mx(sum, y, z, p, e, k));\n      }\n      z = v[n];\n      y = v[0] = this.int32(v[0] - this.mx(sum, y, z, 0, e, k));\n    }\n    return v;\n  }\n\n  private static utf8Encode(str: string): string {\n    if (/^[\\x00-\\x7f]*$/.test(str)) {\n      return str;\n    }\n    const buf: number[] = [];\n    const n: number = str.length;\n    for (let i: number = 0, j: number = 0; i < n; ++i, ++j) {\n      const codeUnit: number = str.charCodeAt(i);\n      if (codeUnit < 0x80) {\n        buf[j] = codeUnit;\n      } else if (codeUnit < 0x800) {\n        buf[j] = 0xc0 | (codeUnit >> 6);\n        buf[j + 1] = 0x80 | (codeUnit & 0x3f);\n        ++j;\n      } else if (codeUnit < 0xd800 || codeUnit > 0xdfff) {\n        buf[j] = 0xe0 | (codeUnit >> 12);\n        buf[j + 1] = 0x80 | ((codeUnit >> 6) & 0x3f);\n        buf[j + 2] = 0x80 | (codeUnit & 0x3f);\n        j += 2;\n      } else {\n        if (i + 1 < n) {\n          const nextCodeUnit: number = str.charCodeAt(i + 1);\n          if (\n            codeUnit < 0xdc00 &&\n            0xdc00 <= nextCodeUnit &&\n            nextCodeUnit <= 0xdfff\n          ) {\n            const rune: number =\n              (((codeUnit & 0x03ff) << 10) | (nextCodeUnit & 0x03ff)) +\n              0x010000;\n            buf[j] = 0xf0 | ((rune >> 18) & 0x3f);\n            buf[j + 1] = 0x80 | ((rune >> 12) & 0x3f);\n            buf[j + 2] = 0x80 | ((rune >> 6) & 0x3f);\n            buf[j + 3] = 0x80 | (rune & 0x3f);\n            j += 3;\n            ++i;\n            continue;\n          }\n        }\n        throw new Error(\"Malformed string\");\n      }\n    }\n    return String.fromCharCode.apply(null, buf);\n  }\n\n  private static utf8DecodeShortString(bs: string, n: number): string {\n    if (bs === undefined || bs === null || bs.length === 0) {\n      return \"\";\n    }\n\n    const charCodes = new Array<number>(n);\n    let i = 0,\n      off = 0;\n\n    for (let len = bs.length; i < n && off < len; i++) {\n      const unit = bs.charCodeAt(off++);\n\n      switch (unit >> 4) {\n        case 0:\n        case 1:\n        case 2:\n        case 3:\n        case 4:\n        case 5:\n        case 6:\n        case 7:\n          charCodes[i] = unit;\n          break;\n\n        case 12:\n        case 13:\n          if (off < len) {\n            charCodes[i] = ((unit & 0x1f) << 6) | (bs.charCodeAt(off++) & 0x3f);\n          } else {\n            throw new Error(\"Unfinished UTF-8 octet sequence\");\n          }\n          break;\n\n        case 14:\n          if (off + 1 < len) {\n            charCodes[i] =\n              ((unit & 0x0f) << 12) |\n              ((bs.charCodeAt(off++) & 0x3f) << 6) |\n              (bs.charCodeAt(off++) & 0x3f);\n          } else {\n            throw new Error(\"Unfinished UTF-8 octet sequence\");\n          }\n          break;\n\n        case 15:\n          if (off + 2 < len) {\n            const rune =\n              (((unit & 0x07) << 18) |\n                ((bs.charCodeAt(off++) & 0x3f) << 12) |\n                ((bs.charCodeAt(off++) & 0x3f) << 6) |\n                (bs.charCodeAt(off++) & 0x3f)) -\n              0x10000;\n            if (0 <= rune && rune <= 0xfffff) {\n              charCodes[i++] = ((rune >> 10) & 0x03ff) | 0xd800;\n              charCodes[i] = (rune & 0x03ff) | 0xdc00;\n            } else {\n              throw new Error(\n                \"Character outside valid Unicode range: 0x\" + rune.toString(16),\n              );\n            }\n          } else {\n            throw new Error(\"Unfinished UTF-8 octet sequence\");\n          }\n          break;\n\n        default:\n          throw new Error(\"Bad UTF-8 encoding 0x\" + unit.toString(16));\n      }\n    }\n\n    if (i < n) {\n      charCodes.length = i;\n    }\n\n    return String.fromCharCode(...charCodes);\n  }\n\n  private static utf8DecodeLongString(bs: string, n: number): string {\n    const buf: string[] = [];\n    const charCodes: number[] = new Array(0x8000);\n    let i = 0,\n      off = 0;\n\n    for (let len = bs.length; i < n && off < len; i++) {\n      const unit = bs.charCodeAt(off++);\n      switch (unit >> 4) {\n        case 0:\n        case 1:\n        case 2:\n        case 3:\n        case 4:\n        case 5:\n        case 6:\n        case 7:\n          charCodes[i] = unit;\n          break;\n        case 12:\n        case 13:\n          if (off < len) {\n            charCodes[i] = ((unit & 0x1f) << 6) | (bs.charCodeAt(off++) & 0x3f);\n          } else {\n            throw new Error(\"Unfinished UTF-8 octet sequence\");\n          }\n          break;\n        case 14:\n          if (off + 1 < len) {\n            charCodes[i] =\n              ((unit & 0x0f) << 12) |\n              ((bs.charCodeAt(off++) & 0x3f) << 6) |\n              (bs.charCodeAt(off++) & 0x3f);\n          } else {\n            throw new Error(\"Unfinished UTF-8 octet sequence\");\n          }\n          break;\n        case 15:\n          if (off + 2 < len) {\n            const rune =\n              (((unit & 0x07) << 18) |\n                ((bs.charCodeAt(off++) & 0x3f) << 12) |\n                ((bs.charCodeAt(off++) & 0x3f) << 6) |\n                (bs.charCodeAt(off++) & 0x3f)) -\n              0x10000;\n            if (0 <= rune && rune <= 0xfffff) {\n              charCodes[i++] = ((rune >> 10) & 0x03ff) | 0xd800;\n              charCodes[i] = (rune & 0x03ff) | 0xdc00;\n            } else {\n              throw new Error(\n                \"Character outside valid Unicode range: 0x\" + rune.toString(16),\n              );\n            }\n          } else {\n            throw new Error(\"Unfinished UTF-8 octet sequence\");\n          }\n          break;\n        default:\n          throw new Error(\"Bad UTF-8 encoding 0x\" + unit.toString(16));\n      }\n\n      if (i >= 0x7fff - 1) {\n        const size = i + 1;\n        charCodes.length = size;\n        buf[buf.length] = String.fromCharCode.apply(String, charCodes);\n        n -= size;\n        i = -1;\n      }\n    }\n\n    if (i > 0) {\n      charCodes.length = i;\n      buf[buf.length] = String.fromCharCode.apply(String, charCodes);\n    }\n\n    return buf.join(\"\");\n  }\n\n  private static utf8Decode(bs: string | null, n?: number | null): string {\n    if (bs === undefined || bs === null || bs.length === 0) {\n      return \"\";\n    }\n\n    if (n === undefined || n === null || n < 0) n = bs.length;\n    if (n === 0) return \"\";\n    if (/^[\\x00-\\x7f]*$/.test(bs) || !/^[\\x00-\\xff]*$/.test(bs)) {\n      if (n === bs.length) return bs;\n      return bs.substr(0, n);\n    }\n    return n < 0x7fff\n      ? this.utf8DecodeShortString(bs, n)\n      : this.utf8DecodeLongString(bs, n);\n  }\n\n  public static encrypt(data: string | null, key: string): string | null {\n    if (data === undefined || data === null || data.length === 0) {\n      return data;\n    }\n    data = this.utf8Encode(data);\n    key = this.utf8Encode(key);\n    return this.toBinaryString(\n      this.encryptUint32Array(\n        Array.from(this.toUint32Array(data, true)),\n        this.fixk(Array.from(this.toUint32Array(key, false))),\n      ),\n      false,\n    );\n  }\n\n  public static encryptToBase64(\n    data: string | null,\n    key: string,\n  ): string | null {\n    return this.btoa(this.encrypt(data, key));\n  }\n\n  public static decrypt(data: string, key: string): string {\n    if (data === undefined || data === null || data.length === 0) {\n      return data;\n    }\n    key = this.utf8Encode(key);\n\n    return this.utf8Decode(\n      this.toBinaryString(\n        this.decryptUint32Array(\n          Array.from(this.toUint32Array(data, false)),\n          this.fixk(Array.from(this.toUint32Array(key, false))),\n        ),\n        true,\n      ),\n    );\n  }\n\n  public static decryptFromBase64(\n    data: string | null,\n    key: string,\n  ): string | null {\n    return this.decrypt(this.atob(data), key);\n  }\n\n  public static toBinary(str: string): string {\n    const codeUnits = new Uint16Array(str.length);\n\n    for (let i = 0; i < codeUnits.length; i++) {\n      codeUnits[i] = str.charCodeAt(i);\n    }\n\n    const charCodes = new Uint8Array(codeUnits.buffer);\n    let result = \"\";\n\n    for (let i = 0; i < charCodes.byteLength; i++) {\n      result += String.fromCharCode(charCodes[i]);\n    }\n\n    return result;\n  }\n\n  public static fromBinary(binary: string): string {\n    const bytes = new Uint8Array(binary.length);\n\n    for (let i = 0; i < bytes.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n\n    const charCodes = new Uint16Array(bytes.buffer);\n    let result = \"\";\n\n    for (let i = 0; i < charCodes.length; i++) {\n      result += String.fromCharCode(charCodes[i]);\n    }\n\n    return result;\n  }\n}\n"],"names":[],"mappings":"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"}

package/libs/xxtea/xxtea_test.ts

@@ -0,0 +1,26 @@
+import { assertEquals } from "@std/assert";
+import XXTEA from "./xxtea.ts";
+
+Deno.test("mod class xxtea", () => {
+  const str: string = "Hello World! 你好，中国🇨🇳！";
+  const key: string = "1234567890";
+
+  // D4t0rVXUDl3bnWdERhqJmFIanfn/6zAxAY9jD6n9MSMQNoD8TOS4rHHcGuE=
+  let encrypt_data = XXTEA.encryptToBase64(str, key);
+  assertEquals(
+    encrypt_data,
+    "D4t0rVXUDl3bnWdERhqJmFIanfn/6zAxAY9jD6n9MSMQNoD8TOS4rHHcGuE=",
+  );
+  // console.log("encryptToBase64: " + encrypt_data);
+
+  let decrypt_data = XXTEA.decryptFromBase64(encrypt_data, key);
+  assertEquals(decrypt_data, str);
+  // console.log("decryptFromBase64: " + decrypt_data);
+  // console.log("decryptFromBase64 success: " + (str === decrypt_data));
+
+  encrypt_data = XXTEA.encrypt(str, key);
+  decrypt_data = XXTEA.decrypt(encrypt_data || "", key);
+  assertEquals(decrypt_data, str);
+  // console.log("decrypt from binary: " + decrypt_data);
+  // console.log("decrypt from binary success: " + (str === decrypt_data));
+});

package/mod.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 恐咖兵糖的 Deno Libs
+ *
+ * ```ts
+ * export * as hi from "./hi.ts";
+ * ```
+ * @module
+ */ export * as hi from "./hi.js";
+export { default as XXTEA } from "./libs/xxtea/xxtea.js";

package/mod.js

@@ -0,0 +1,11 @@
+// Copyright 2026 kkbt.
+/**
+ * 恐咖兵糖的 Deno Libs
+ *
+ * ```ts
+ * export * as hi from "./hi.ts";
+ * ```
+ * @module
+ */ export * as hi from "./hi.js";
+export { default as XXTEA } from "./libs/xxtea/xxtea.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vQzovVXNlcnMvc25vd2EvRG9jdW1lbnRzL0NvZGUvS0RML21vZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBra2J0LlxuXG4vKipcbiAqIOaBkOWSluWFteezlueahCBEZW5vIExpYnNcbiAqXG4gKiBgYGB0c1xuICogZXhwb3J0ICogYXMgaGkgZnJvbSBcIi4vaGkudHNcIjtcbiAqIGBgYFxuICogQG1vZHVsZVxuICovXG5leHBvcnQgKiBhcyBoaSBmcm9tIFwiLi9oaS5qc1wiO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBYWFRFQSB9IGZyb20gXCIuL2xpYnMveHh0ZWEveHh0ZWEuanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1QkFBdUI7QUFFdkI7Ozs7Ozs7Q0FPQyxHQUNELE9BQU8sS0FBSyxFQUFFLE1BQU0sVUFBVTtBQUM5QixTQUFTLFdBQVcsS0FBSyxRQUFRLHdCQUF3QiJ9

package/mod_test.ts

@@ -0,0 +1,23 @@
+import { assertEquals } from "@std/assert";
+import { hi, XXTEA } from "./mod.ts";
+
+Deno.test("mod func hi", () => {
+  console.log(hi);
+  assertEquals(hi.hello(), undefined);
+});
+
+Deno.test("mod func sum", () => {
+  assertEquals(hi.sum(1, 2), 3);
+});
+
+Deno.test("mod class Hi", () => {
+  const h = new hi.Hi();
+  assertEquals(h.hello(), undefined);
+  assertEquals(h.sum(1, 2), 3);
+});
+
+Deno.test("mod class XXTEA", () => {
+  const encrypted = XXTEA.encryptToBase64("hello", "password");
+  const decrypted = XXTEA.decryptFromBase64(encrypted, "password");
+  assertEquals(decrypted, "hello");
+});

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@kkbt/kdl",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "main": "./mod.js",
+  "types": "./mod.d.ts",
+  "exports": {
+    ".": {
+      "types": "./mod.d.ts",
+      "import": "./mod.js",
+      "default": "./mod.js"
+    }
+  }
+}

package/packages.md

@@ -0,0 +1,9 @@
+
+```bash
+# 生成有 ts/js 等文件的包
+deno pack --allow-dirty 
+bun publish xxx.tgz
+# 或修改 package.json 为 ts 入口
+# bun pm pack # 可以不 pack 没有 ts -> js 步骤
+bun publish
+```