@maiyunnet/kebab 2.0.4 → 2.0.6

package/index.d.ts

@@ -0,0 +1,14 @@
+export declare const VER = "2.0.6";
+export declare const ROOT_PATH: string;
+export declare const LIB_PATH: string;
+export declare const SYS_PATH: string;
+export declare const ROOT_CWD: string;
+export declare const CONF_CWD: string;
+export declare const CERT_CWD: string;
+export declare const VHOST_CWD: string;
+export declare const LIB_CWD: string;
+export declare const LOG_CWD: string;
+export declare const WWW_CWD: string;
+export declare const IND_CWD: string;
+export declare const FTMP_CWD: string;
+export declare const MOD_CWD: string;

package/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOD_CWD = exports.FTMP_CWD = exports.IND_CWD = exports.WWW_CWD = exports.LOG_CWD = exports.LIB_CWD = exports.VHOST_CWD = exports.CERT_CWD = exports.CONF_CWD = exports.ROOT_CWD = exports.SYS_PATH = exports.LIB_PATH = exports.ROOT_PATH = exports.VER = void 0;
-exports.VER = '2.0.4';
+exports.VER = '2.0.6';
 const dirname = __dirname.replace(/\\/g, '/');
 exports.ROOT_PATH = dirname + '/';
 exports.LIB_PATH = exports.ROOT_PATH + 'lib/';

package/lib/buffer.d.ts

@@ -0,0 +1,25 @@
+export declare class Reader {
+    private readonly _buffer;
+    private _offset;
+    constructor(buffer: Buffer);
+    readUInt8(): number;
+    readUInt16BE(): number;
+    readUInt32BE(): number;
+    readBCDString(length?: number): string;
+    readString(length?: number, encoding?: BufferEncoding): string;
+    readBuffer(length?: number): Buffer;
+    length(): number;
+}
+export declare class Writer {
+    private readonly _buffer;
+    private _offset;
+    constructor(size: number);
+    writeUInt8(value: number): void;
+    writeUInt16BE(value: number): void;
+    writeUInt32BE(value: number): void;
+    writeBCDString(value: string): void;
+    writeString(value: string, encoding?: BufferEncoding): number;
+    get(): Buffer;
+}
+export declare function getReader(buffer: Buffer): Reader;
+export declare function getWriter(size: number): Writer;

package/lib/captcha.d.ts

@@ -0,0 +1,12 @@
+export declare class Captcha {
+    private readonly _link;
+    constructor(opt: {
+        'width': number;
+        'height': number;
+        'length': number;
+    });
+    getBuffer(): string;
+    getBase64(): string;
+    getPhrase(): string;
+}
+export declare function get(width: number, height: number, length?: number): Captcha;

package/lib/captcha.js

@@ -37,8 +37,8 @@ exports.Captcha = void 0;
 exports.get = get;
 const svgCaptcha = __importStar(require("svg-captcha"));
 const mime = __importStar(require("@litert/mime"));
-const core = __importStar(require("~/lib/core"));
-const kebab = __importStar(require("~/index"));
+const core = __importStar(require("../lib/core"));
+const kebab = __importStar(require("../index"));
 svgCaptcha.loadFont(kebab.LIB_PATH + 'captcha/zcool-addict-italic.ttf');
 class Captcha {
     constructor(opt) {

package/lib/consistent.d.ts

@@ -0,0 +1,20 @@
+export declare class Consistent {
+    private readonly _vcount;
+    private readonly _circle;
+    private _keys;
+    constructor(vcount: number);
+    getVcount(): number;
+    add(node: string | string[]): void;
+    remove(node: string | string[]): void;
+    find(key: string | number): string | null;
+    migration(keys: string | number | Array<string | number>, node: string | string[]): Record<string, {
+        'old': string;
+        'new': string;
+    }>;
+}
+export declare function get(vcount?: number): Consistent;
+export declare function fast(key: string | number, nodes: string | string[], vcount?: number): string | null;
+export declare function hash(val: string | number): number;
+export declare function getRange(min: number, max: number, pre?: string): string[];
+export declare function addToCircle(circle: Record<string, string>, node: string | string[], vcount?: number): void;
+export declare function findInCircle(circle: Record<string, string>, key: string | number, keys?: string[]): string | null;

package/lib/consistent.js

@@ -40,7 +40,7 @@ exports.hash = hash;
 exports.getRange = getRange;
 exports.addToCircle = addToCircle;
 exports.findInCircle = findInCircle;
-const crypto = __importStar(require("~/lib/crypto"));
+const crypto = __importStar(require("../lib/crypto"));
 class Consistent {
     constructor(vcount) {
         this._vcount = 300;

package/lib/core.d.ts

@@ -0,0 +1,85 @@
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as stream from 'stream';
+import * as lResponse from '../lib/net/response';
+import * as sCtr from '../sys/ctr';
+import * as types from '../types';
+export declare const globalConfig: types.IConfig & {
+    'httpPort': number;
+    'httpsPort': number;
+    'rpcPort': number;
+    'rpcSecret': string;
+    'debug': boolean;
+    'max': number;
+};
+export interface ICookieOptions {
+    'ttl'?: number;
+    'path'?: string;
+    'domain'?: string;
+    'ssl'?: boolean;
+    'httponly'?: boolean;
+    'samesite'?: 'None' | 'Lax' | 'Strict';
+}
+export declare function setCookie(ctr: sCtr.Ctr, name: string, value: string, opt?: ICookieOptions): void;
+export declare function rand(min: number, max: number, prec?: number): number;
+export declare const RANDOM_N = "0123456789";
+export declare const RANDOM_U = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export declare const RANDOM_L = "abcdefghijklmnopqrstuvwxyz";
+export declare const RANDOM_UN: string;
+export declare const RANDOM_LN: string;
+export declare const RANDOM_LU: string;
+export declare const RANDOM_LUN: string;
+export declare const RANDOM_V = "ACEFGHJKLMNPRSTWXY34567";
+export declare const RANDOM_LUNS: string;
+export declare function random(length?: number, source?: string, block?: string): string;
+export declare const CONVERT62_CHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export declare function convert62(n: bigint | number | string): string;
+export declare function unconvert62(n: string): bigint;
+export declare function purify(text: string): string;
+export declare function checkType(val: any, type: any, tree?: string): string;
+export declare function muid(ctr: sCtr.Ctr, opt?: {
+    'len'?: number;
+    'bin'?: boolean;
+    'key'?: string;
+    'insert'?: string;
+    'num'?: boolean;
+}): string;
+export declare function ip(ctr: sCtr.Ctr | http.IncomingHttpHeaders, req?: http2.Http2ServerRequest | http.IncomingMessage): string;
+export declare const REAL_IP_X = "x-forwarded-for";
+export declare const REAL_IP_CF = "cf-connecting-ip";
+export declare function realIP(ctr: sCtr.Ctr, name?: string): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function objectSort<T extends Record<string, any>>(o: T): T;
+export declare function emptyObject(obj: Record<string, types.Json>, deep?: boolean): void;
+export declare function passThroughAppend(passThrough: stream.PassThrough, data: Array<stream.Readable | lResponse.Response | string | Buffer>, end?: boolean): Promise<void>;
+export declare function exec(command: string): Promise<string | false>;
+export declare function sendReload(hosts?: string[]): Promise<string[]>;
+export declare function sendRestart(hosts?: string[]): Promise<string[]>;
+export declare const global: Record<string, any>;
+export declare function setGlobal(key: string, data: types.Json, hosts?: string[]): Promise<string[]>;
+export declare function removeGlobal(key: string, hosts?: string[]): Promise<string[]>;
+export declare function updateCode(sourcePath: string, path: string, hosts?: string[], config?: boolean): Promise<Record<string, {
+    'result': boolean;
+    'return': string;
+}>>;
+export interface ILogOptions {
+    'path': string;
+    'urlFull': string;
+    'hostname': string;
+    'req': http2.Http2ServerRequest | http.IncomingMessage | null;
+    'get': Record<string, types.Json>;
+    'cookie': Record<string, string>;
+    'headers': http.IncomingHttpHeaders;
+}
+export declare function log(opt: sCtr.Ctr | ILogOptions, msg: string, fend?: string): Promise<void>;
+export declare function getLog(opt: {
+    'host': string;
+    'path': string;
+    'fend'?: string;
+    'search'?: string;
+    'offset'?: number;
+    'limit'?: number;
+}): Promise<string[][] | null | false>;
+export declare function clone(obj: Record<string, any> | any[]): any[] | any;
+export declare function debug(message?: any, ...optionalParams: any[]): void;
+export declare function display(message?: any, ...optionalParams: any[]): void;

package/lib/core.js

@@ -61,14 +61,14 @@ exports.debug = debug;
 exports.display = display;
 const cp = __importStar(require("child_process"));
 const stream = __importStar(require("stream"));
-const lTime = __importStar(require("~/lib/time"));
-const lFs = __importStar(require("~/lib/fs"));
-const lText = __importStar(require("~/lib/text"));
-const lNet = __importStar(require("~/lib/net"));
-const lCrypto = __importStar(require("~/lib/crypto"));
-const lResponse = __importStar(require("~/lib/net/response"));
-const sCtr = __importStar(require("~/sys/ctr"));
-const kebab = __importStar(require("~/index"));
+const lTime = __importStar(require("../lib/time"));
+const lFs = __importStar(require("../lib/fs"));
+const lText = __importStar(require("../lib/text"));
+const lNet = __importStar(require("../lib/net"));
+const lCrypto = __importStar(require("../lib/crypto"));
+const lResponse = __importStar(require("../lib/net/response"));
+const sCtr = __importStar(require("../sys/ctr"));
+const kebab = __importStar(require("../index"));
 exports.globalConfig = {};
 function setCookie(ctr, name, value, opt = {}) {
     const res = ctr.getPrototype('_res');

package/lib/crypto.d.ts

@@ -0,0 +1,47 @@
+import * as crypto from 'crypto';
+export declare function generateKeyPair(type: string, options?: {
+    'modulusLength'?: number;
+    'namedCurve'?: string;
+    'publicKeyEncoding'?: {
+        'type'?: 'pkcs1' | 'spki';
+        'format'?: 'pem' | 'der';
+    };
+    'privateKeyEncoding'?: {
+        'type'?: 'pkcs1' | 'pkcs8' | 'sec1';
+        'format'?: 'pem' | 'der';
+    };
+}): Promise<{
+    'public': string | Buffer;
+    'private': string | Buffer;
+}>;
+export declare function sign(data: crypto.BinaryLike, privateKey: crypto.KeyLike | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput | crypto.SignJsonWebKeyInput, format: 'hex' | 'base64' | 'binary', algorithm?: string): string;
+export declare function sign(data: crypto.BinaryLike, privateKey: crypto.KeyLike | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput | crypto.SignJsonWebKeyInput, format?: 'buffer', algorithm?: string): Buffer;
+export declare function verify(data: crypto.BinaryLike, object: crypto.KeyLike | crypto.VerifyKeyObjectInput | crypto.VerifyPublicKeyInput | crypto.VerifyJsonWebKeyInput, signature: NodeJS.ArrayBufferView, algorithm?: string): boolean;
+export declare function publicEncrypt(key: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare function privateEncrypt(key: crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare function publicDecrypt(key: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare function privateDecrypt(key: crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare const AES_256_ECB = "AES-256-ECB";
+export declare const AES_256_CBC = "AES-256-CBC";
+export declare const AES_256_CFB = "AES-256-CFB";
+export declare const SM4_ECB = "SM4-ECB";
+export declare const SM4_CBC = "SM4-CBC";
+export declare const SM4_CFB = "SM4-CFB";
+export declare function cipherEncrypt(original: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'base64' | 'buffer'): string | Buffer | false;
+export declare function aesEncrypt(original: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function aesEncrypt(original: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'base64'): string | false;
+export declare function sm4Encrypt(original: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function sm4Encrypt(original: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'base64'): string | false;
+export declare function cipherDecrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'binary' | 'buffer'): string | Buffer | false;
+export declare function aesDecrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function aesDecrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'binary'): string | false;
+export declare function sm4Decrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function sm4Decrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'binary'): string | false;
+export declare function hashHmac(algorithm: string, data: Buffer | string, key?: crypto.CipherKey, format?: 'hex' | 'base64'): string;
+export declare function hashHmac(algorithm: string, data: Buffer | string, key: crypto.CipherKey | undefined, format: 'buffer'): Buffer;
+export declare function hashHmacFile(algorithm: string, path: string, key?: crypto.CipherKey, encoding?: 'hex' | 'base64' | 'base64url'): Promise<string | false>;
+export declare function hashHmacFile(algorithm: string, path: string, key: crypto.CipherKey, encoding: 'buffer'): Promise<Buffer | false>;
+export declare function base64Encode(data: string | Buffer): string;
+export declare function base64Decode(data: string, encoding: 'buffer'): Buffer;
+export declare function base64Decode(data: string, encoding?: 'utf8'): string;
+export declare function uuid(options?: crypto.RandomUUIDOptions): string;

package/lib/crypto.js

@@ -53,7 +53,7 @@ exports.base64Encode = base64Encode;
 exports.base64Decode = base64Decode;
 exports.uuid = uuid;
 const crypto = __importStar(require("crypto"));
-const fs = __importStar(require("~/lib/fs"));
+const fs = __importStar(require("../lib/fs"));
 function generateKeyPair(type, options = {}) {
     return new Promise((resolve) => {
         if (options.modulusLength === undefined) {

package/lib/db.d.ts

@@ -0,0 +1,88 @@
+import * as mysql2 from 'mysql2/promise';
+import * as ctr from '../sys/ctr';
+import * as types from '../types';
+export interface IData {
+    'rows': any[] | null;
+    'fields': mysql2.FieldPacket[];
+    'error': {
+        'message': string;
+        'errno': number;
+        [key: string]: any;
+    } | null;
+}
+export interface IPacket {
+    'packet': mysql2.ResultSetHeader | null;
+    'fields': mysql2.FieldPacket[];
+    'error': {
+        'message': string;
+        'errno': number;
+        [key: string]: any;
+    } | null;
+}
+export interface IConnectionInfo {
+    'id': number;
+    'last': number;
+    'host': string;
+    'port': number;
+    'name': string;
+    'user': string;
+    'lost': boolean;
+    'using': boolean;
+    'transaction': boolean;
+}
+export declare class Pool {
+    private _queries;
+    private readonly _etc;
+    constructor(etc: types.IConfigDb);
+    query(sql: string, values?: types.DbValue[]): Promise<IData>;
+    execute(sql: string, values?: types.DbValue[]): Promise<IPacket>;
+    beginTransaction(ctr: ctr.Ctr | null): Promise<Transaction | null>;
+    private _getConnection;
+    getQueries(): number;
+}
+export declare class Transaction {
+    private _queries;
+    private _conn;
+    private readonly _ctr;
+    private readonly _timer;
+    constructor(ctr: ctr.Ctr | null, conn: Connection, opts?: {
+        'warning'?: number;
+        'danger'?: number;
+    });
+    query(sql: string, values?: types.DbValue[]): Promise<IData>;
+    execute(sql: string, values?: types.DbValue[]): Promise<IPacket>;
+    commit(): Promise<boolean>;
+    rollback(): Promise<boolean>;
+}
+export declare class Connection {
+    private _last;
+    private readonly _lastSql;
+    private readonly _link;
+    private _using;
+    private _lost;
+    private _transaction;
+    private readonly _etc;
+    constructor(etc: types.IConfigDb, link: mysql2.Connection);
+    getEtc(): types.IConfigDb;
+    getLast(): number;
+    getLastSql(): Array<{
+        'sql': string;
+        'values'?: types.DbValue[];
+    }>;
+    setLost(): void;
+    isLost(): boolean;
+    isTransaction(): boolean;
+    isUsing(): boolean;
+    using(): boolean;
+    used(): void;
+    refreshLast(): void;
+    isAvailable(): Promise<boolean>;
+    query(sql: string, values?: types.DbValue[]): Promise<IData>;
+    execute(sql: string, values?: types.DbValue[]): Promise<IPacket>;
+    end(): Promise<boolean>;
+    beginTransaction(): Promise<boolean>;
+    commit(): Promise<boolean>;
+    rollback(): Promise<boolean>;
+}
+export declare function get(ctrEtc: ctr.Ctr | types.IConfigDb): Pool;
+export declare function getConnectionList(): IConnectionInfo[];

package/lib/db.js

@@ -37,11 +37,11 @@ exports.Connection = exports.Transaction = exports.Pool = void 0;
 exports.get = get;
 exports.getConnectionList = getConnectionList;
 const mysql2 = __importStar(require("mysql2/promise"));
-const time = __importStar(require("~/lib/time"));
-const lSql = __importStar(require("~/lib/sql"));
-const core = __importStar(require("~/lib/core"));
-const text = __importStar(require("~/lib/text"));
-const ctr = __importStar(require("~/sys/ctr"));
+const time = __importStar(require("../lib/time"));
+const lSql = __importStar(require("../lib/sql"));
+const core = __importStar(require("../lib/core"));
+const text = __importStar(require("../lib/text"));
+const ctr = __importStar(require("../sys/ctr"));
 const connections = [];
 async function checkConnection() {
     const now = time.stamp();

package/lib/dns.d.ts

@@ -0,0 +1,75 @@
+import * as ctr from '../sys/ctr';
+export declare enum ESERVICE {
+    'DNSPOD' = 0,
+    'ALIBABA' = 1
+}
+export interface IOptions {
+    'service': ESERVICE;
+    'secretId'?: string;
+    'secretKey'?: string;
+}
+export interface IDomainList {
+    'total': number;
+    'list': Array<{
+        'id': string;
+        'name': string;
+        'count': number;
+        'punyCode': string;
+    }>;
+}
+export interface IAddDomainRecord {
+    'success': boolean;
+    'id': string;
+}
+export declare const RECORD_TYPE: {
+    A: string;
+    NS: string;
+    MX: string;
+    TXT: string;
+    CNAME: string;
+    SRV: string;
+    AAAA: string;
+};
+export declare enum ERecordLine {
+    'DEFAULT' = 0,
+    'TELECOM' = 1,
+    'UNICOM' = 2,
+    'MOBILE' = 3,
+    'EDU' = 4,
+    'OVERSEA' = 5
+}
+export declare class Dns {
+    private readonly _opt;
+    constructor(ctr: ctr.Ctr, opt: IOptions);
+    private _send;
+    getDomainList(opt: {
+        'offset'?: number;
+        'length'?: number;
+    }): Promise<IDomainList | null>;
+    addDomainRecord(opt: {
+        'domain': string;
+        'sub': string;
+        'type': string;
+        'value': string;
+        'line'?: number;
+        'ttl'?: number;
+        'mx'?: number;
+    }): Promise<IAddDomainRecord | null>;
+    updateDomainRecord(opt: {
+        'domain': string;
+        'record': string;
+        'sub': string;
+        'type': string;
+        'value': string;
+        'line'?: number;
+        'ttl'?: number;
+        'mx'?: number;
+    }): Promise<IAddDomainRecord | null>;
+    deleteDomainRecord(opt: {
+        'domain': string;
+        'id': string;
+    }): Promise<{
+        'success': boolean;
+    } | null>;
+}
+export declare function get(ctr: ctr.Ctr, opt: IOptions): Dns;

package/lib/dns.js

@@ -35,11 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dns = exports.ERecordLine = exports.RECORD_TYPE = exports.ESERVICE = void 0;
 exports.get = get;
-const net = __importStar(require("~/lib/net"));
-const core = __importStar(require("~/lib/core"));
-const text = __importStar(require("~/lib/text"));
-const crypto = __importStar(require("~/lib/crypto"));
-const response = __importStar(require("~/lib/net/response"));
+const net = __importStar(require("../lib/net"));
+const core = __importStar(require("../lib/core"));
+const text = __importStar(require("../lib/text"));
+const crypto = __importStar(require("../lib/crypto"));
+const response = __importStar(require("../lib/net/response"));
 var ESERVICE;
 (function (ESERVICE) {
     ESERVICE[ESERVICE["DNSPOD"] = 0] = "DNSPOD";

package/lib/fs.d.ts

@@ -0,0 +1,49 @@
+import * as fs from 'fs';
+import * as http from 'http';
+import * as http2 from 'http2';
+export declare function getContent(path: string, options?: {
+    'start'?: number;
+    'end'?: number;
+}): Promise<Buffer | null>;
+export declare function getContent(path: string, options: BufferEncoding | {
+    'encoding': BufferEncoding;
+    'start'?: number;
+    'end'?: number;
+}): Promise<string | null>;
+export declare function putContent(path: string, data: string | Buffer, options?: {
+    'encoding'?: BufferEncoding;
+    'mode'?: number;
+    'flag'?: string;
+}): Promise<boolean>;
+export declare function readLink(path: string, encoding?: BufferEncoding): Promise<string | null>;
+export declare function symlink(filePath: string, linkPath: string, type?: 'dir' | 'file' | 'junction'): Promise<boolean>;
+export declare function unlink(path: string): Promise<boolean>;
+export declare function stats(path: string): Promise<fs.Stats | null>;
+export declare function isDir(path: string): Promise<fs.Stats | false>;
+export declare function isFile(path: string): Promise<fs.Stats | false>;
+export declare function mkdir(path: string, mode?: number): Promise<boolean>;
+export declare function rmdir(path: string): Promise<boolean>;
+export declare function rmdirDeep(path: string): Promise<boolean>;
+export declare function chmod(path: string, mod: string | number): Promise<boolean>;
+export declare function rename(oldPath: string, newPath: string): Promise<boolean>;
+export declare function readDir(path: string, encoding?: BufferEncoding): Promise<fs.Dirent[]>;
+export declare function copyFolder(from: string, to: string, ignore?: RegExp[]): Promise<number>;
+export declare function copyFile(src: string, dest: string): Promise<boolean>;
+export declare function createReadStream(path: string, options?: BufferEncoding | {
+    'flags'?: string;
+    'encoding'?: BufferEncoding;
+    'autoClose'?: boolean;
+    'start'?: number;
+    'end'?: number;
+}): fs.ReadStream;
+export declare function pipe(path: string, destination: NodeJS.WritableStream, options?: {
+    'end'?: boolean;
+}): Promise<boolean>;
+export declare function createWriteStream(path: string, options?: BufferEncoding | {
+    'flags'?: string;
+    'encoding'?: BufferEncoding;
+    'mode'?: number;
+    'autoClose'?: boolean;
+    'start'?: number;
+}): fs.WriteStream;
+export declare function readToResponse(path: string, req: http2.Http2ServerRequest | http.IncomingMessage, res: http2.Http2ServerResponse | http.ServerResponse, stat?: fs.Stats | null): Promise<void>;

package/lib/jwt.d.ts

@@ -0,0 +1,30 @@
+import * as kv from '../lib/kv';
+import * as ctr from '../sys/ctr';
+import * as types from '../types';
+export interface IOptions {
+    'name'?: string;
+    'ttl'?: number;
+    'ssl'?: boolean;
+    'secret'?: string;
+    'auth'?: boolean;
+}
+export declare class Jwt {
+    private _link?;
+    private _name;
+    private _ttl;
+    private _ssl;
+    private _secret;
+    private _auth;
+    private _ctr;
+    init(ctr: ctr.Ctr, opt?: IOptions, link?: kv.Pool): Promise<boolean>;
+    renew(): string;
+    clearCookie(): void;
+    destory(): Promise<{
+        token: string;
+        exp: number;
+    } | boolean>;
+}
+export declare function getOrigin(ctr: ctr.Ctr, name?: string, auth?: boolean): string;
+export declare function decode(ctr: ctr.Ctr, val: string, link?: kv.Pool, name?: string, secret?: string): Promise<Record<string, types.DbValue> | false>;
+export declare function block(ctr: ctr.Ctr, token: string, exp: number, link: kv.Pool, name?: string): Promise<boolean>;
+export declare function get(ctr: ctr.Ctr, opt?: IOptions, link?: kv.Pool): Promise<Jwt>;

package/lib/jwt.js

@@ -38,10 +38,10 @@ exports.getOrigin = getOrigin;
 exports.decode = decode;
 exports.block = block;
 exports.get = get;
-const lCore = __importStar(require("~/lib/core"));
-const lTime = __importStar(require("~/lib/time"));
-const lText = __importStar(require("~/lib/text"));
-const lCrypto = __importStar(require("~/lib/crypto"));
+const lCore = __importStar(require("../lib/core"));
+const lTime = __importStar(require("../lib/time"));
+const lText = __importStar(require("../lib/text"));
+const lCrypto = __importStar(require("../lib/crypto"));
 class Jwt {
     async init(ctr, opt = {}, link) {
         const config = ctr.getPrototype('_config');