xjs-common 7.0.0

package/dist/func/decorator/transaction.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transaction = void 0;
+const xjs_err_1 = require("../../obj/xjs-err");
+const u_1 = require("../u");
+const s_errCode = 100;
+/**
+ * applies transation to the method. note that the method must return a Promise.
+ * @param op.timeoutSec default is `30`.
+ */
+function transaction(op) {
+    let lock = 0;
+    const timeoutSec = op?.timeoutSec ?? 30;
+    return (target, propertyKey, descriptor) => {
+        const method = descriptor.value;
+        async function exe(...p) {
+            const timelimit = Date.now() + timeoutSec * 1000;
+            while (lock > 0) {
+                if (timelimit <= Date.now())
+                    throw new xjs_err_1.XjsErr(s_errCode, "An exclusive process to execute was already running by other request.");
+                await (0, u_1.delay)(1);
+            }
+            try {
+                lock++;
+                const ret = method.apply(this, p);
+                return ret instanceof Promise ? await ret : ret;
+            }
+            finally {
+                lock--;
+            }
+        }
+        ;
+        descriptor.value = exe;
+    };
+}
+exports.transaction = transaction;

package/dist/func/u-array.d.ts

@@ -0,0 +1,40 @@
+export declare namespace UArray {
+    /**
+     * compares two arrays to valuate equality.
+     * if one side is null or undefined, it returns true when other side is the same.
+     * @param v1 it uses equal operator for comparing elements, so applying object element is not recommended.
+     * @param v2 same as v1.
+     * @param sort it uses {@link Array#sort} on v1 and v2 if true. default is true.
+     * @param useStrictEqual it uses === operator for compareing elements if true, otherwise using == operator. default is true.
+     */
+    function eq(v1: any[], v2: any[], op: {
+        sort?: boolean;
+        useStrictEqual: false;
+    }): boolean;
+    function eq<T>(v1: T[], v2: T[], op: {
+        sort?: boolean;
+        useStrictEqual: true;
+    }): boolean;
+    function eq<T>(v1: T[], v2: T[], op: {
+        sort?: boolean;
+    }): boolean;
+    function eq<T>(v1: T[], v2: T[]): boolean;
+    /**
+     * returns array which is removed duplicate of elements.
+     * this doesn't mutate the param.
+     */
+    function distinct<T>(array: T[]): T[];
+    function distinct<T>(array: T[], op: {
+        k: keyof T;
+        takeLast?: boolean;
+    }): T[];
+    function distinct<T>(array: T[], op: {
+        predicate: (v1: T, v2: T) => boolean;
+        takeLast?: boolean;
+    }): T[];
+    function chop<T>(array: T[], len: number): T[][];
+    function remove<T>(array: T[], v: T): void;
+    function randomPick<T>(array: T[], takeout?: boolean): T;
+    function shuffle<T>(array: T[]): T[];
+    function takeOut<T>(array: T[], filter: (v: T, i?: number) => boolean): T[];
+}

package/dist/func/u-array.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UArray = void 0;
+const u_1 = require("./u");
+var UArray;
+(function (UArray) {
+    function eq(v1, v2, op = {}) {
+        const { sort, useStrictEqual } = Object.assign({ sort: true, useStrictEqual: true }, op);
+        if (v1 && !v2 || !v1 && v2)
+            return false;
+        if (!v1)
+            return true;
+        if (v1.length !== v2.length)
+            return false;
+        const a = sort ? [...v1].sort() : v1, b = sort ? [...v2].sort() : v2;
+        return a.every((v, i) => useStrictEqual ? v === b[i] : v == b[i]);
+    }
+    UArray.eq = eq;
+    function distinct(array, op) {
+        if (!array || array.length === 0)
+            return [];
+        if (op?.k)
+            return Array.from((0, u_1.array2map)(array, e => e[op.k]).values()).map(a => op?.takeLast ? a.pop() : a.shift());
+        const a = op?.takeLast ? [...array].reverse() : array;
+        return a.filter((v, i) => a.findIndex(v2 => op?.predicate ? op?.predicate(v, v2) : v == v2) === i);
+    }
+    UArray.distinct = distinct;
+    function chop(array, len) {
+        return [...Array(Math.ceil(array.length / len)).keys()]
+            .map(i => {
+            let endIdx = (i + 1) * len;
+            if (endIdx > array.length)
+                endIdx = array.length;
+            return array.slice(i * len, endIdx);
+        });
+    }
+    UArray.chop = chop;
+    function remove(array, v) {
+        const idx = array.indexOf(v);
+        if (idx !== -1)
+            array.splice(idx, 1);
+    }
+    UArray.remove = remove;
+    function randomPick(array, takeout = true) {
+        const i = Math.floor(array.length * Math.random());
+        const r = array[i];
+        if (takeout)
+            array.splice(i, 1);
+        return r;
+    }
+    UArray.randomPick = randomPick;
+    function shuffle(array) {
+        const cp = [...array];
+        return (0, u_1.int2array)(array.length).map(_ => randomPick(cp));
+    }
+    UArray.shuffle = shuffle;
+    function takeOut(array, filter) {
+        const result = [];
+        for (let i = array.length - 1; i >= 0; i--)
+            if (filter(array[i], i)) {
+                result.unshift(array[i]);
+                array.splice(i, 1);
+            }
+        return result;
+    }
+    UArray.takeOut = takeOut;
+})(UArray = exports.UArray || (exports.UArray = {}));

package/dist/func/u-file.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+export declare namespace UFile {
+    function mkdir(p: string | string[]): boolean;
+    function write(p: string | string[], c: string): void;
+    function exists(...p: string[]): boolean;
+    function read(p: string | string[]): Buffer;
+    function read(p: string | string[], encoding: BufferEncoding): string;
+    function cp(from: string | string[], to: string | string[]): void;
+    function mv(from: string | string[], to: string | string[]): void;
+}

package/dist/func/u-file.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UFile = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const u_type_1 = require("./u-type");
+var UFile;
+(function (UFile) {
+    function mkdir(p) {
+        const dirPath = join(p);
+        const e = fs.existsSync(dirPath);
+        if (!e || !fs.statSync(dirPath).isDirectory())
+            fs.mkdirSync(dirPath, { recursive: true });
+        return !e;
+    }
+    UFile.mkdir = mkdir;
+    function write(p, c) {
+        fs.writeFileSync(join(p), c);
+    }
+    UFile.write = write;
+    function exists(...p) {
+        return !!p && fs.existsSync(path.join(...p));
+    }
+    UFile.exists = exists;
+    function read(p, encoding) {
+        return fs.readFileSync(join(p), encoding);
+    }
+    UFile.read = read;
+    function cp(from, to) {
+        const f = join(from), t = join(to);
+        if (fs.existsSync(f))
+            fs.writeFileSync(t, fs.readFileSync(f));
+    }
+    UFile.cp = cp;
+    function mv(from, to) {
+        const f = join(from), t = join(to);
+        if (fs.existsSync(f) && fs.statSync(f).isFile()) {
+            fs.writeFileSync(t, fs.readFileSync(f));
+            fs.rmSync(f, { force: true });
+        }
+    }
+    UFile.mv = mv;
+    function join(p) {
+        return u_type_1.UType.isString(p) ? p : path.join(...p);
+    }
+})(UFile = exports.UFile || (exports.UFile = {}));

package/dist/func/u-http.d.ts

@@ -0,0 +1,7 @@
+export declare namespace UHttp {
+    function isHttpSuccess(statusCode: number): boolean;
+    function statusCategoryOf(statusCode: number): number;
+    function concatParamsWithEncoding(end: string, params: {
+        [k: string]: string | string[];
+    }): string;
+}

package/dist/func/u-http.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UHttp = void 0;
+var UHttp;
+(function (UHttp) {
+    function isHttpSuccess(statusCode) {
+        return statusCategoryOf(statusCode) === 2;
+    }
+    UHttp.isHttpSuccess = isHttpSuccess;
+    function statusCategoryOf(statusCode) {
+        return Math.floor(statusCode / 100);
+    }
+    UHttp.statusCategoryOf = statusCategoryOf;
+    function concatParamsWithEncoding(end, params) {
+        if (!params || Object.keys(params).length === 0)
+            return end;
+        const paramsFlatten = Object.entries(params)
+            .flatMap(kv => Array.isArray(kv[1]) ? kv[1].map(v => [kv[0], v]) : [kv]);
+        let result = end ? end + "?" : "";
+        for (var kv of paramsFlatten)
+            result += kv[0] + "=" + encodeURIComponent(kv[1]) + "&";
+        return result.substring(0, result.length - 1);
+    }
+    UHttp.concatParamsWithEncoding = concatParamsWithEncoding;
+})(UHttp = exports.UHttp || (exports.UHttp = {}));

package/dist/func/u-obj.d.ts

@@ -0,0 +1,18 @@
+import { NormalRecord } from "../const/types";
+export declare namespace UObj {
+    /**
+     * assign properties to the object with specified property keys.
+     * @param t target object.
+     * @param s source object.
+     * @param keys property keys which are copied from source object. if omit this, all keys in source object is applied.
+     * @param keepDtypeClass if true, class which has properties decorated with {@link DType} in target object is kept and that is assigned properties recursively.
+     */
+    function assignProperties<T extends NormalRecord, S extends NormalRecord>(t: T, s: S, keys?: (keyof S)[], keepDtypeClass?: boolean): T & Partial<S>;
+    /**
+     * crop properties of the object. the properties is removed with `delete` operator.
+     * @param o object which properties is removed.
+     * @param keys property names to be remained. if omit this, it removes the properties other than properties decorated {@link DType}.
+     * @param exclusive if true, it removes `keys` instead of remaining it.
+     */
+    function crop<T extends NormalRecord>(o: T, keys?: (keyof T)[], exclusive?: boolean): Partial<T>;
+}

package/dist/func/u-obj.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UObj = void 0;
+const d_type_1 = require("./decorator/d-type");
+const u_type_1 = require("./u-type");
+var UObj;
+(function (UObj) {
+    /**
+     * assign properties to the object with specified property keys.
+     * @param t target object.
+     * @param s source object.
+     * @param keys property keys which are copied from source object. if omit this, all keys in source object is applied.
+     * @param keepDtypeClass if true, class which has properties decorated with {@link DType} in target object is kept and that is assigned properties recursively.
+     */
+    function assignProperties(t, s, keys, keepDtypeClass) {
+        for (const k of keys ?? Object.keys(s))
+            if (u_type_1.UType.isDefined(s[k]))
+                if (keepDtypeClass && u_type_1.UType.isObject(t[k]) && u_type_1.UType.isObject(s[k]) && t[k]?.[d_type_1.smbl_tm]) {
+                    assignProperties(t[k], s[k], null, true);
+                }
+                else
+                    t[k] = s[k];
+        return t;
+    }
+    UObj.assignProperties = assignProperties;
+    /**
+     * crop properties of the object. the properties is removed with `delete` operator.
+     * @param o object which properties is removed.
+     * @param keys property names to be remained. if omit this, it removes the properties other than properties decorated {@link DType}.
+     * @param exclusive if true, it removes `keys` instead of remaining it.
+     */
+    function crop(o, keys, exclusive) {
+        if (!keys && !o[d_type_1.smbl_tm])
+            return {};
+        const _keys = keys ?? Object.keys(o[d_type_1.smbl_tm]);
+        Object.keys(o).filter(k => {
+            if (!keys && o[d_type_1.smbl_tm]?.[k]?.rec)
+                crop(o[k]);
+            return !!exclusive === _keys.includes(k);
+        }).forEach(k => delete o[k]);
+        return o;
+    }
+    UObj.crop = crop;
+})(UObj = exports.UObj || (exports.UObj = {}));

package/dist/func/u-string.d.ts

@@ -0,0 +1,9 @@
+export declare namespace UString {
+    function eq(s1: string, s2: string): boolean;
+    function simpleDate2sec(date?: Date): string;
+    function simpleDate2day(date?: Date): string;
+    function trimProps(obj: any): void;
+    function generateRandomString(len: number): string;
+    function idx2az(idx: number): string;
+    function az2idx(az: string): number;
+}

package/dist/func/u-string.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UString = void 0;
+const xjs_err_1 = require("../obj/xjs-err");
+const u_1 = require("./u");
+const u_type_1 = require("./u-type");
+const s_errCode = 20;
+var UString;
+(function (UString) {
+    function eq(s1, s2) {
+        return !u_type_1.UType.isString(s1) || !u_type_1.UType.isString(s2) ? s1 === s2 : s1.trim() === s2.trim();
+    }
+    UString.eq = eq;
+    function simpleDate2sec(date) {
+        return (date ?? new Date()).toISOString().split(".")[0].replace(/[-T:]/g, "");
+    }
+    UString.simpleDate2sec = simpleDate2sec;
+    function simpleDate2day(date) {
+        return simpleDate2sec(date).substring(0, 8);
+    }
+    UString.simpleDate2day = simpleDate2day;
+    function trimProps(obj) {
+        Object.keys(obj)
+            .filter(k => typeof obj[k] === "string")
+            .forEach(k => obj[k] = obj[k]?.trim());
+    }
+    UString.trimProps = trimProps;
+    function generateRandomString(len) {
+        return (0, u_1.int2array)(len).map(_ => {
+            let rnd = Math.floor(62 * Math.random());
+            const remain = rnd - 52;
+            if (remain >= 0)
+                return remain.toString();
+            if (rnd > 26)
+                rnd += 6;
+            return String.fromCharCode(rnd + 65);
+        }).join("");
+    }
+    UString.generateRandomString = generateRandomString;
+    function idx2az(idx) {
+        let az = "", num = idx;
+        while (num >= 0) {
+            az = String.fromCharCode(num % 26 + 97) + az;
+            num = Math.floor(num / 26) - 1;
+        }
+        return az.toUpperCase();
+    }
+    UString.idx2az = idx2az;
+    function az2idx(az) {
+        if (!az?.match(/^[a-zA-Z]+$/))
+            throw new xjs_err_1.XjsErr(s_errCode, "the parameter isn't az(AZ) format.");
+        return az.toLowerCase().split("").map(c => c.charCodeAt(0) - 97).reverse()
+            .map((idx, i) => (idx + 1) * (26 ** i)).reduce((v1, v2) => v1 + v2) - 1;
+    }
+    UString.az2idx = az2idx;
+})(UString = exports.UString || (exports.UString = {}));

package/dist/func/u-type.d.ts

@@ -0,0 +1,21 @@
+import { Type } from "../const/types";
+export declare namespace UType {
+    function isDefined(v: any): boolean;
+    function isEmpty(v: any): boolean;
+    function isString(v: any): v is string;
+    function isNumber(v: any): v is number;
+    function isBigint(v: any): v is bigint;
+    function isBoolean(v: any): v is boolean;
+    function isSymbol(v: any): v is symbol;
+    function isObject(v: any): v is object;
+    function isArray(v: any, t: Type.string): v is string[];
+    function isArray(v: any, t: Type.number): v is number[];
+    function isArray(v: any, t: Type.bigint): v is bigint[];
+    function isArray(v: any, t: Type.boolean): v is boolean[];
+    function isArray(v: any, t: Type.symbol): v is symbol[];
+    function isArray(v: any, t: Type.object): v is object[];
+    function isArray(v: any): v is any[];
+    /** validate properties which attached decorators in {@link DType} */
+    function validate(o: any): boolean;
+    function takeAsArray<T>(v: T | T[]): T[];
+}

package/dist/func/u-type.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UType = void 0;
+const types_1 = require("../const/types");
+const d_type_1 = require("./decorator/d-type");
+var UType;
+(function (UType) {
+    function isDefined(v) {
+        return typeof v !== types_1.Type.undefined;
+    }
+    UType.isDefined = isDefined;
+    function isEmpty(v) {
+        return v === null || typeof v === types_1.Type.undefined;
+    }
+    UType.isEmpty = isEmpty;
+    function isString(v) { return typeof v === types_1.Type.string; }
+    UType.isString = isString;
+    function isNumber(v) { return typeof v === types_1.Type.number; }
+    UType.isNumber = isNumber;
+    function isBigint(v) { return typeof v === types_1.Type.bigint; }
+    UType.isBigint = isBigint;
+    function isBoolean(v) { return typeof v === types_1.Type.boolean; }
+    UType.isBoolean = isBoolean;
+    function isSymbol(v) { return typeof v === types_1.Type.symbol; }
+    UType.isSymbol = isSymbol;
+    function isObject(v) { return typeof v === types_1.Type.object; }
+    UType.isObject = isObject;
+    function isArray(v, t) {
+        return Array.isArray(v) && (!t || v.every(e => typeof e === t));
+    }
+    UType.isArray = isArray;
+    /** validate properties which attached decorators in {@link DType} */
+    function validate(o) {
+        return !o[d_type_1.smbl_tm] || Object.entries(o[d_type_1.smbl_tm])
+            .every(e => validateProp(o[e[0]], e[1]));
+    }
+    UType.validate = validate;
+    function validateProp(prop, td) {
+        if (isEmpty(prop))
+            return !td.req;
+        if (td.t && typeof prop !== td.t)
+            return false;
+        if (td.ary)
+            return Array.isArray(prop) && (!td.ary || prop.every(e => validateProp(e, td.ary)));
+        if (td.rec)
+            return validate(prop);
+        return true;
+    }
+    function takeAsArray(v) {
+        return Array.isArray(v) ? v : [v];
+    }
+    UType.takeAsArray = takeAsArray;
+})(UType = exports.UType || (exports.UType = {}));

package/dist/func/u.d.ts

@@ -0,0 +1,6 @@
+export declare function getJSTDate(): Date;
+export declare function delay(sec: number): Promise<void>;
+export declare function int2array(size: number): number[];
+export declare function array2map<K, T>(array: T[], keyGen: (e: T) => K): Map<K, T[]>;
+export declare function bitor(...bit: number[]): number;
+export declare function checkPortAvailability(port: number): Promise<boolean>;

package/dist/func/u.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPortAvailability = exports.bitor = exports.array2map = exports.int2array = exports.delay = exports.getJSTDate = void 0;
+const xjs_err_1 = require("../obj/xjs-err");
+const s_errCode = 10;
+function getJSTDate() {
+    return new Date(Date.now() + 9 * 60 * 60 * 1000);
+}
+exports.getJSTDate = getJSTDate;
+function delay(sec) {
+    return new Promise(resolve => setTimeout(resolve, 1000 * sec));
+}
+exports.delay = delay;
+function int2array(size) {
+    const s = Number(size);
+    if (Number.isNaN(s))
+        throw new xjs_err_1.XjsErr(s_errCode, "size of the argument is not number.");
+    return Array.from(Array(s).keys());
+}
+exports.int2array = int2array;
+function array2map(array, keyGen) {
+    const map = new Map();
+    for (const e of array) {
+        const k = keyGen(e);
+        if (map.has(k))
+            map.get(k).push(e);
+        else
+            map.set(k, [e]);
+    }
+    return map;
+}
+exports.array2map = array2map;
+function bitor(...bit) {
+    return bit.reduce((a, b) => a | b);
+}
+exports.bitor = bitor;
+function checkPortAvailability(port) {
+    return new Promise(resolve => {
+        const server = require('net').createServer();
+        server.once('error', () => resolve(false))
+            .once('listening', () => { server.close(); resolve(true); })
+            .listen(port);
+    });
+}
+exports.checkPortAvailability = checkPortAvailability;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./const/types";
+export * from "./const/gender";
+export * from "./const/http-method";
+export * from "./func/u";
+export * from "./func/u-obj";
+export * from "./func/u-string";
+export * from "./func/u-array";
+export * from "./func/u-file";
+export * from "./func/u-http";
+export * from "./func/u-type";
+export * from "./func/decorator/transaction";
+export { DType } from "./func/decorator/d-type";
+export * from "./obj/xjs-err";
+export { HttpResolver } from "./prcs/http/http-resolver";
+export { s_clientMode } from "./prcs/http/http-resolver-context";
+export { IHttpClient } from "./prcs/http/i-http-client";

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s_clientMode = exports.HttpResolver = exports.DType = void 0;
+__exportStar(require("./const/types"), exports);
+__exportStar(require("./const/gender"), exports);
+__exportStar(require("./const/http-method"), exports);
+__exportStar(require("./func/u"), exports);
+__exportStar(require("./func/u-obj"), exports);
+__exportStar(require("./func/u-string"), exports);
+__exportStar(require("./func/u-array"), exports);
+__exportStar(require("./func/u-file"), exports);
+__exportStar(require("./func/u-http"), exports);
+__exportStar(require("./func/u-type"), exports);
+__exportStar(require("./func/decorator/transaction"), exports);
+var d_type_1 = require("./func/decorator/d-type");
+Object.defineProperty(exports, "DType", { enumerable: true, get: function () { return d_type_1.DType; } });
+__exportStar(require("./obj/xjs-err"), exports);
+var http_resolver_1 = require("./prcs/http/http-resolver");
+Object.defineProperty(exports, "HttpResolver", { enumerable: true, get: function () { return http_resolver_1.HttpResolver; } });
+var http_resolver_context_1 = require("./prcs/http/http-resolver-context");
+Object.defineProperty(exports, "s_clientMode", { enumerable: true, get: function () { return http_resolver_context_1.s_clientMode; } });

package/dist/obj/type-exp.d.ts

@@ -0,0 +1,8 @@
+import { Type } from "../const/types";
+export declare class TypeExp<T> {
+    private t;
+    private readonly _m;
+    constructor(t: Type.string | Type.number | Type.bigint | Type.null | Type.symbol | Type.undefined);
+    constructor(t: Type.object, model: any);
+    match(o: any): o is T;
+}

package/dist/obj/type-exp.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeExp = void 0;
+const types_1 = require("../const/types");
+class TypeExp {
+    t;
+    _m;
+    constructor(t, model) {
+        this.t = t;
+        this._m = model;
+    }
+    match(o) {
+        if (typeof o !== this.t)
+            return false;
+        if (this.t !== types_1.Type.object)
+            return true;
+        const isArray = Array.isArray(o);
+        if (isArray !== Array.isArray(this._m))
+            return false;
+        return true;
+    }
+}
+exports.TypeExp = TypeExp;

package/dist/obj/xjs-err.d.ts

@@ -0,0 +1,4 @@
+export declare class XjsErr extends Error {
+    code: number;
+    constructor(code: number, msg: string);
+}

package/dist/obj/xjs-err.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XjsErr = void 0;
+class XjsErr extends Error {
+    code;
+    constructor(code, msg) {
+        super(`[XJS] ${msg}`);
+        this.code = code;
+    }
+}
+exports.XjsErr = XjsErr;