feat: drpy2升级

Author: Taois

dist/drpy-core-fast.min.js

@@ -1,10 +1,11 @@
 ## drpy_webpack
 
-drpy2框架的打包项目。所有依赖打包成一个`drpy-core.min.js` `drpy-core-lite.min.js`
+drpy2框架的打包项目。所有依赖打包成一个`drpy-core.min.js` `drpy-core-lite.min.js` `drpy-core-fast.min.js`
 
 [drpyS项目传送门](https://github.com/hjdhnx/drpy-node)
 
 当前版本号: `3.9.52beta3 20250801`
+特殊QJS版本: `3.9.54 20260117`
 
 注意复制到drpyS项目 `public/drpy` 目录前需要把 init_test里的一些调试日志注释掉
 

drpy2-fast/drpy-core-fast.min.js

@@ -16,7 +16,8 @@ import './libs/jinja.min.js';
 // import './libs/polywasm.min.js';
 import './libs/xxhash-wasm.min.js';
 // export {Buffer} from './libs/buffer.min.js'
-
+import "./libs/url.js";
+import "./libs/sqlite.js";
 
 // 确保全局依赖可用
 const g = globalThis;
@@ -28,6 +29,7 @@ const CryptoJS = g.CryptoJS;
 const JSON5 = g.JSON5;
 const JSONPath = g.JSONPath;
 const jinja = g.jinja;
+const Database = g.Database;
 // const WebAssembly = g.WebAssembly;
 // const TextEncoder = g.TextEncoder;
 // const TextDecoder = g.TextDecoder;
@@ -66,6 +68,7 @@ export {
     JSON5,
     JSONPath,
     jinja,
+    Database,
     // WebAssembly,
     // TextEncoder,
     // TextDecoder,

drpy2-fast/drpy2-fast.min.js

@@ -1,8 +1,16 @@
 import {cheerio, 模板} from '../dist/drpy-core-fast.min.js';
 
 let vercode = typeof (pdfl) === 'function' ? 'drpy2.1' : 'drpy2';
-const VERSION = vercode + ' 3.9.53 20251007';
+const VERSION = vercode + ' 3.9.54 20260117';
 const UpdateInfo = [
+    {
+        date: '20260117',
+        title: '爱佬新So测试版，使用drpy-core-fast.min.js',
+        version: '3.9.54 20260117',
+        msg: `
+drpy-core-fast.min.js内置了url和sqlite模块
+       `
+    },
     {
         date: '20251007',
         title: '爱佬新So测试版，使用drpy-core-lite.min.js，内置了Buffer库',
@@ -904,7 +912,7 @@ function gzip(str) {
  * @returns {string}
  */
 function ungzip(b64Data) {
-    const binData = Buffer.from(b64Data,'base64');
+    const binData = Buffer.from(b64Data, 'base64');
     const data = zlib.ungzip(binData.buffer);
     return Buffer.from(data, 'utf8').toString();
 }
@@ -1016,7 +1024,8 @@ const RSA = {
                 encryptedData.set(segment, offset);
                 offset += segment.length;
             }
-            return encryptedData.slice(0, offset);;
+            return encryptedData.slice(0, offset);
+            ;
         }
         return crypto.subtle.encrypt(
             {
@@ -1052,15 +1061,15 @@ const RSA = {
             }
             return decryptedData.slice(0, offset);
         }
-        return new Uint8Array(crypto.subtle.decrypt (
+        return new Uint8Array(crypto.subtle.decrypt(
             {
                 name: "RSA-PKCS1-v1_5",
             },
             privateKey,
             mergedData
         ));
     },
-    decode: function(data, key) {
+    decode: function (data, key) {
         try {
             const mergedDataArray = Uint8Array.from(Buffer.from(data, 'base64'));
             const privateKey = this.importPrivateKey(key);
@@ -1073,7 +1082,7 @@ const RSA = {
             throw error;
         }
     },
-    encode: function(plainText, publicKeyPem) {
+    encode: function (plainText, publicKeyPem) {
         try {
             const publicKey = this.importPublicKey(publicKeyPem);
             //console.time("RSA加密");
@@ -3464,7 +3473,7 @@ function getOriginalJs(js_code) {
         const key = crypto.subtle.importKey(
             "raw",
             keyArray,
-            { name: "AES-CBC" },
+            {name: "AES-CBC"},
             false,
             ["decrypt"]
         );

readme.md

@@ -0,0 +1,185 @@
+const sqlite3 = globalThis.sqlite;
+
+const kSqlite3Handle = Symbol('kSqlite3Handle');
+let controllers;
+
+class Database {
+    constructor(dbName = ':memory:', options = { create: true, readOnly: false }) {
+        let flags = 0;
+
+        if (options.create) {
+            flags |= sqlite3.SQLITE_OPEN_CREATE;
+        }
+
+        if (options.readOnly) {
+            flags |= sqlite3.SQLITE_OPEN_READONLY;
+        } else {
+            flags |= sqlite3.SQLITE_OPEN_READWRITE;
+        }
+
+        this[kSqlite3Handle] = sqlite3.open(dbName, flags);
+    }
+
+    close() {
+        let ret = false;
+        if (this[kSqlite3Handle]) {
+            ret = sqlite3.close(this[kSqlite3Handle]);
+            this[kSqlite3Handle] = null;
+        }
+        return ret;
+    }
+
+    exec(sql) {
+        if (!this[kSqlite3Handle]) {
+            throw new Error('Invalid DB');
+        }
+
+        return sqlite3.exec(this[kSqlite3Handle], sql);
+    }
+
+    prepare(sql) {
+        if (!this[kSqlite3Handle]) {
+            throw new Error('Invalid DB');
+        }
+
+        return new Statement(sqlite3.prepare(this[kSqlite3Handle], sql));
+    }
+
+    // Code for transactions is largely copied from better-sqlite3 and Bun
+    // https://github.com/JoshuaWise/better-sqlite3/blob/master/lib/methods/transaction.js
+    // https://github.com/oven-sh/bun/blob/main/src/js/bun/sqlite.ts
+
+    get inTransaction() {
+        if (!this[kSqlite3Handle]) {
+            return false;
+        }
+        return sqlite3.in_transaction(this[kSqlite3Handle]);
+    }
+
+    transaction(fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError('Expected first argument to be a function');
+        }
+
+        const db = this;
+        const controller = getController(db);
+
+        // Each version of the transaction function has these same properties.
+        const properties = {
+            default: { value: wrapTransaction(fn, db, controller.default) },
+            deferred: { value: wrapTransaction(fn, db, controller.deferred) },
+            immediate: { value: wrapTransaction(fn, db, controller.immediate) },
+            exclusive: { value: wrapTransaction(fn, db, controller.exclusive) },
+        };
+
+        Object.defineProperties(properties.default.value, properties);
+        Object.defineProperties(properties.deferred.value, properties);
+        Object.defineProperties(properties.immediate.value, properties);
+        Object.defineProperties(properties.exclusive.value, properties);
+
+        // Return the default version of the transaction function.
+        return properties.default.value;
+    }
+
+    loadExtension(file, entrypoint=undefined) {
+        return sqlite3.load_extension(this[kSqlite3Handle],file,entrypoint);
+    }
+}
+
+// Return the database's cached transaction controller, or create a new one.
+const getController = db => {
+    let controller = (controllers ||= new WeakMap()).get(db);
+
+    if (!controller) {
+        const shared = {
+            commit: db.prepare('COMMIT'),
+            rollback: db.prepare('ROLLBACK'),
+            savepoint: db.prepare('SAVEPOINT `\t_bs3.\t`'),
+            release: db.prepare('RELEASE `\t_bs3.\t`'),
+            rollbackTo: db.prepare('ROLLBACK TO `\t_bs3.\t`'),
+        };
+
+        controller = {
+            default: Object.assign({ begin: db.prepare('BEGIN') }, shared),
+            deferred: Object.assign({ begin: db.prepare('BEGIN DEFERRED') }, shared),
+            immediate: Object.assign({ begin: db.prepare('BEGIN IMMEDIATE') }, shared),
+            exclusive: Object.assign({ begin: db.prepare('BEGIN EXCLUSIVE') }, shared),
+        };
+
+        controllers.set(db, controller);
+    }
+
+    return controller;
+};
+
+// Return a new transaction function by wrapping the given function.
+const wrapTransaction = (fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) =>
+    function transaction() {
+        let before, after, undo;
+
+        if (db.inTransaction) {
+            before = savepoint;
+            after = release;
+            undo = rollbackTo;
+        } else {
+            before = begin;
+            after = commit;
+            undo = rollback;
+        }
+
+        try {
+            before.run();
+
+            const result = Function.prototype.apply.call(fn, this, arguments);
+
+            after.run();
+
+            return result;
+        } catch (ex) {
+            if (db.inTransaction) {
+                undo.run();
+
+                if (undo !== rollback) {
+                    after.run();
+                }
+            }
+            throw ex;
+        }
+    };
+
+const kSqlite3Stmt = Symbol('kSqlite3Stmt');
+
+class Statement {
+    constructor(stmt) {
+        this[kSqlite3Stmt] = stmt;
+    }
+
+    finalize() {
+        return sqlite3.stmt_finalize(this[kSqlite3Stmt]);
+    }
+
+    toString() {
+        return sqlite3.stmt_expand(this[kSqlite3Stmt]);
+    }
+
+    all(...args) {
+        if (args && args.length === 1 && typeof args[0] === 'object') {
+            args = args[0];
+        }
+        return sqlite3.stmt_all(this[kSqlite3Stmt], args);
+    }
+
+    run(...args) {
+        if (args && args.length === 1 && typeof args[0] === 'object') {
+            args = args[0];
+        }
+        return sqlite3.stmt_run(this[kSqlite3Stmt], args);
+    }
+}
+
+Object.defineProperty(globalThis, 'DataBase', {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Database
+});