lakutata
Version:
An IoC-based universal application framework.
1,862 lines (1,699 loc) • 393 kB
JavaScript
/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";
Object.defineProperty(exports, Symbol.toStringTag, {
value: "Module"
});
const e = require("../../../vendor/Package.internal.2.cjs");
const t = require("url");
const r = require("util");
const n = require("../../exceptions/dto/InvalidValueException.cjs");
const s = require("../helpers/As.cjs");
require("../base/abstracts/Exception.cjs");
require("../../../vendor/Package.internal.5.cjs");
require("../../../vendor/Package.internal.6.cjs");
require("../base/internal/ThrowWarning.cjs");
require("../helpers/Templating.cjs");
require("../base/internal/CamelCase.cjs");
require("../helpers/NoCase.cjs");
require("../helpers/DevNull.cjs");
function i(e) {
if (e && e.__esModule) return e;
const t = Object.create(null, {
[Symbol.toStringTag]: {
value: "Module"
}
});
if (e) {
for (const r in e) {
if (r !== "default") {
const n = Object.getOwnPropertyDescriptor(e, r);
Object.defineProperty(t, r, n.get ? n : {
enumerable: true,
get: () => e[r]
});
}
}
}
t.default = e;
return Object.freeze(t);
}
const a = i(t);
const o = i(r);
var l = {};
var u = {
exports: {}
};
var c = class AssertError extends Error {
name="AssertError";
constructor(e, t) {
super(e || "Unknown error");
if (typeof Error.captureStackTrace === "function") {
Error.captureStackTrace(this, t);
}
}
};
var f = function(...e) {
try {
return JSON.stringify(...e);
} catch (e) {
return "[Cannot display object: " + e.message + "]";
}
};
u.exports;
const d = c;
const m = f;
const h = u.exports = function(e, ...t) {
if (e) {
return;
}
if (t.length === 1 && t[0] instanceof Error) {
throw t[0];
}
const r = t.filter(e => e !== "").map(e => typeof e === "string" ? e : e instanceof Error ? e.message : m(e));
throw new d(r.join(" "), h);
};
var p = u.exports;
const g = e.getDefaultExportFromCjs(p);
const y = p;
const b = {};
var _ = function(e, t, r) {
if (t === false || t === null || t === undefined) {
return e;
}
r = r || {};
if (typeof r === "string") {
r = {
separator: r
};
}
const n = Array.isArray(t);
y(!n || !r.separator, "Separator option is not valid for array-based chain");
const s = n ? t : t.split(r.separator || ".");
let i = e;
for (let e = 0; e < s.length; ++e) {
let n = s[e];
const a = r.iterables && b.iterables(i);
if (Array.isArray(i) || a === "set") {
const e = Number(n);
if (Number.isInteger(e)) {
n = e < 0 ? i.length + e : e;
}
}
if (!i || typeof i === "function" && r.functions === false || !a && i[n] === undefined) {
y(!r.strict || e + 1 === s.length, "Missing segment", n, "in reach path ", t);
y(typeof i === "object" || r.functions === true || typeof i !== "function", "Invalid segment", n, "in reach path ", t);
i = r.default;
break;
}
if (!a) {
i = i[n];
} else if (a === "set") {
i = [ ...i ][n];
} else {
i = i.get(n);
}
}
return i;
};
b.iterables = function(e) {
if (e instanceof Set) {
return "set";
}
if (e instanceof Map) {
return "map";
}
};
var v = {
exports: {}
};
v.exports;
(function(e, t) {
const r = {};
t = e.exports = {
array: Array.prototype,
buffer: Buffer && Buffer.prototype,
date: Date.prototype,
error: Error.prototype,
generic: Object.prototype,
map: Map.prototype,
promise: Promise.prototype,
regex: RegExp.prototype,
set: Set.prototype,
url: URL.prototype,
weakMap: WeakMap.prototype,
weakSet: WeakSet.prototype
};
r.typeMap = new Map([ [ "[object Error]", t.error ], [ "[object Map]", t.map ], [ "[object Promise]", t.promise ], [ "[object Set]", t.set ], [ "[object URL]", t.url ], [ "[object WeakMap]", t.weakMap ], [ "[object WeakSet]", t.weakSet ] ]);
t.getInternalProto = function(e) {
if (Array.isArray(e)) {
return t.array;
}
if (Buffer && e instanceof Buffer) {
return t.buffer;
}
if (e instanceof Date) {
return t.date;
}
if (e instanceof RegExp) {
return t.regex;
}
if (e instanceof Error) {
return t.error;
}
const n = Object.prototype.toString.call(e);
return r.typeMap.get(n) || t.generic;
};
})(v, v.exports);
var A = v.exports;
var E = {};
E.keys = function(e, t = {}) {
return t.symbols !== false ? Reflect.ownKeys(e) : Object.getOwnPropertyNames(e);
};
const R = _;
const S = A;
const O = E;
const w = {
needsProtoHack: new Set([ S.set, S.map, S.weakSet, S.weakMap ]),
structuredCloneExists: typeof structuredClone === "function"
};
var N = w.clone = function(e, t = {}, r = null) {
if (typeof e !== "object" || e === null) {
return e;
}
let n = w.clone;
let s = r;
if (t.shallow) {
if (t.shallow !== true) {
return w.cloneWithShallow(e, t);
}
n = e => e;
} else if (s) {
const t = s.get(e);
if (t) {
return t;
}
} else {
s = new Map;
}
const i = S.getInternalProto(e);
switch (i) {
case S.buffer:
return Buffer?.from(e);
case S.date:
return new Date(e.getTime());
case S.regex:
case S.url:
return new i.constructor(e);
}
const a = w.base(e, i, t);
if (a === e) {
return e;
}
if (s) {
s.set(e, a);
}
if (i === S.set) {
for (const r of e) {
a.add(n(r, t, s));
}
} else if (i === S.map) {
for (const [r, i] of e) {
a.set(r, n(i, t, s));
}
}
const o = O.keys(e, t);
for (const r of o) {
if (r === "__proto__") {
continue;
}
if (i === S.array && r === "length") {
a.length = e.length;
continue;
}
if (w.structuredCloneExists && i === S.error && r === "stack") {
continue;
}
const o = Object.getOwnPropertyDescriptor(e, r);
if (o) {
if (o.get || o.set) {
Object.defineProperty(a, r, o);
} else if (o.enumerable) {
a[r] = n(e[r], t, s);
} else {
Object.defineProperty(a, r, {
enumerable: false,
writable: true,
configurable: true,
value: n(e[r], t, s)
});
}
} else {
Object.defineProperty(a, r, {
enumerable: true,
writable: true,
configurable: true,
value: n(e[r], t, s)
});
}
}
return a;
};
w.cloneWithShallow = function(e, t) {
const r = t.shallow;
t = Object.assign({}, t);
t.shallow = false;
const n = new Map;
for (const t of r) {
const r = R(e, t);
if (typeof r === "object" || typeof r === "function") {
n.set(r, r);
}
}
return w.clone(e, t, n);
};
w.base = function(e, t, r) {
if (r.prototype === false) {
if (w.needsProtoHack.has(t)) {
return new t.constructor;
}
return t === S.array ? [] : {};
}
const n = Object.getPrototypeOf(e);
if (n && n.isImmutable) {
return e;
}
if (t === S.array) {
const e = [];
if (n !== t) {
Object.setPrototypeOf(e, n);
}
return e;
} else if (t === S.error && w.structuredCloneExists && (n === t || Error.isPrototypeOf(n.constructor))) {
const t = structuredClone(e);
if (Object.getPrototypeOf(t) !== n) {
Object.setPrototypeOf(t, n);
}
return t;
}
if (w.needsProtoHack.has(t)) {
const e = new n.constructor;
if (n !== t) {
Object.setPrototypeOf(e, n);
}
return e;
}
return Object.create(n);
};
const I = p;
const $ = N;
const T = E;
const C = {};
var x = C.merge = function(e, t, r) {
I(e && typeof e === "object", "Invalid target value: must be an object");
I(t === null || t === undefined || typeof t === "object", "Invalid source value: must be null, undefined, or an object");
if (!t) {
return e;
}
r = Object.assign({
nullOverride: true,
mergeArrays: true
}, r);
if (Array.isArray(t)) {
I(Array.isArray(e), "Cannot merge array onto an object");
if (!r.mergeArrays) {
e.length = 0;
}
for (let n = 0; n < t.length; ++n) {
e.push($(t[n], {
symbols: r.symbols
}));
}
return e;
}
const n = T.keys(t, r);
for (let s = 0; s < n.length; ++s) {
const i = n[s];
if (i === "__proto__" || !Object.prototype.propertyIsEnumerable.call(t, i)) {
continue;
}
const a = t[i];
if (a && typeof a === "object") {
if (e[i] === a) {
continue;
}
if (!e[i] || typeof e[i] !== "object" || Array.isArray(e[i]) !== Array.isArray(a) || a instanceof Date || Buffer && Buffer.isBuffer(a) || a instanceof RegExp) {
e[i] = $(a, {
symbols: r.symbols
});
} else {
C.merge(e[i], a, r);
}
} else {
if (a !== null && a !== undefined) {
e[i] = a;
} else if (r.nullOverride) {
e[i] = a;
}
}
}
return e;
};
const L = p;
const D = N;
const M = x;
const j = _;
const k = {};
var B = function(e, t, r = {}) {
L(e && typeof e === "object", "Invalid defaults value: must be an object");
L(!t || t === true || typeof t === "object", "Invalid source value: must be true, falsy or an object");
L(typeof r === "object", "Invalid options: must be an object");
if (!t) {
return null;
}
if (r.shallow) {
return k.applyToDefaultsWithShallow(e, t, r);
}
const n = D(e);
if (t === true) {
return n;
}
const s = r.nullOverride !== undefined ? r.nullOverride : false;
return M(n, t, {
nullOverride: s,
mergeArrays: false
});
};
k.applyToDefaultsWithShallow = function(e, t, r) {
const n = r.shallow;
L(Array.isArray(n), "Invalid keys");
const s = new Map;
const i = t === true ? null : new Set;
for (let r of n) {
r = Array.isArray(r) ? r : r.split(".");
const n = j(e, r);
if (n && typeof n === "object") {
s.set(n, i && j(t, r) || n);
} else if (i) {
i.add(r);
}
}
const a = D(e, {}, s);
if (!i) {
return a;
}
for (const e of i) {
k.reachCopy(a, t, e);
}
const o = r.nullOverride !== undefined ? r.nullOverride : false;
return M(a, t, {
nullOverride: o,
mergeArrays: false
});
};
k.reachCopy = function(e, t, r) {
for (const e of r) {
if (!(e in t)) {
return;
}
const r = t[e];
if (typeof r !== "object" || r === null) {
return;
}
t = r;
}
const n = t;
let s = e;
for (let e = 0; e < r.length - 1; ++e) {
const t = r[e];
if (typeof s[t] !== "object") {
s[t] = {};
}
s = s[t];
}
s[r[r.length - 1]] = n;
};
const P = {};
var U = P.Bench = class {
constructor() {
this.ts = 0;
this.reset();
}
reset() {
this.ts = P.Bench.now();
}
elapsed() {
return P.Bench.now() - this.ts;
}
static now() {
const e = process.hrtime();
return e[0] * 1e3 + e[1] / 1e6;
}
};
var G = function() {};
const F = G;
var X = function() {
return new Promise(F);
};
const H = A;
const K = {
mismatched: null
};
var V = function(e, t, r) {
r = Object.assign({
prototype: true
}, r);
return !!K.isDeepEqual(e, t, r, []);
};
K.isDeepEqual = function(e, t, r, n) {
if (e === t) {
return e !== 0 || 1 / e === 1 / t;
}
const s = typeof e;
if (s !== typeof t) {
return false;
}
if (e === null || t === null) {
return false;
}
if (s === "function") {
if (!r.deepFunction || e.toString() !== t.toString()) {
return false;
}
} else if (s !== "object") {
return e !== e && t !== t;
}
const i = K.getSharedType(e, t, !!r.prototype);
switch (i) {
case H.buffer:
return Buffer && Buffer.prototype.equals.call(e, t);
case H.promise:
return e === t;
case H.regex:
case H.url:
return e.toString() === t.toString();
case K.mismatched:
return false;
}
for (let r = n.length - 1; r >= 0; --r) {
if (n[r].isSame(e, t)) {
return true;
}
}
n.push(new K.SeenEntry(e, t));
try {
return !!K.isDeepEqualObj(i, e, t, r, n);
} finally {
n.pop();
}
};
K.getSharedType = function(e, t, r) {
if (r) {
if (Object.getPrototypeOf(e) !== Object.getPrototypeOf(t)) {
return K.mismatched;
}
return H.getInternalProto(e);
}
const n = H.getInternalProto(e);
if (n !== H.getInternalProto(t)) {
return K.mismatched;
}
return n;
};
K.valueOf = function(e) {
const t = e.valueOf;
if (t === undefined) {
return e;
}
try {
return t.call(e);
} catch (e) {
return e;
}
};
K.hasOwnEnumerableProperty = function(e, t) {
return Object.prototype.propertyIsEnumerable.call(e, t);
};
K.isSetSimpleEqual = function(e, t) {
for (const r of Set.prototype.values.call(e)) {
if (!Set.prototype.has.call(t, r)) {
return false;
}
}
return true;
};
K.isDeepEqualObj = function(e, t, r, n, s) {
const {isDeepEqual: i, valueOf: a, hasOwnEnumerableProperty: o} = K;
const {keys: l, getOwnPropertySymbols: u} = Object;
if (e === H.array) {
if (n.part) {
for (const e of t) {
for (const t of r) {
if (i(e, t, n, s)) {
return true;
}
}
}
} else {
if (t.length !== r.length) {
return false;
}
for (let e = 0; e < t.length; ++e) {
if (!i(t[e], r[e], n, s)) {
return false;
}
}
return true;
}
} else if (e === H.set) {
if (t.size !== r.size) {
return false;
}
if (!K.isSetSimpleEqual(t, r)) {
const e = new Set(Set.prototype.values.call(r));
for (const r of Set.prototype.values.call(t)) {
if (e.delete(r)) {
continue;
}
let t = false;
for (const a of e) {
if (i(r, a, n, s)) {
e.delete(a);
t = true;
break;
}
}
if (!t) {
return false;
}
}
}
} else if (e === H.map) {
if (t.size !== r.size) {
return false;
}
for (const [e, a] of Map.prototype.entries.call(t)) {
if (a === undefined && !Map.prototype.has.call(r, e)) {
return false;
}
if (!i(a, Map.prototype.get.call(r, e), n, s)) {
return false;
}
}
} else if (e === H.error) {
if (t.name !== r.name || t.message !== r.message) {
return false;
}
}
const c = a(t);
const f = a(r);
if ((t !== c || r !== f) && !i(c, f, n, s)) {
return false;
}
const d = l(t);
if (!n.part && d.length !== l(r).length && !n.skip) {
return false;
}
let m = 0;
for (const e of d) {
if (n.skip && n.skip.includes(e)) {
if (r[e] === undefined) {
++m;
}
continue;
}
if (!o(r, e)) {
return false;
}
if (!i(t[e], r[e], n, s)) {
return false;
}
}
if (!n.part && d.length - m !== l(r).length) {
return false;
}
if (n.symbols !== false) {
const e = u(t);
const a = new Set(u(r));
for (const l of e) {
if (!n.skip?.includes(l)) {
if (o(t, l)) {
if (!o(r, l)) {
return false;
}
if (!i(t[l], r[l], n, s)) {
return false;
}
} else if (o(r, l)) {
return false;
}
}
a.delete(l);
}
for (const e of a) {
if (o(r, e)) {
return false;
}
}
}
return true;
};
K.SeenEntry = class {
constructor(e, t) {
this.obj = e;
this.ref = t;
}
isSame(e, t) {
return this.obj === e && this.ref === t;
}
};
var W = function(e) {
return e.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, "\\$&");
};
const Y = e.getDefaultExportFromCjs(W);
const q = p;
const z = V;
const Z = W;
const J = E;
const Q = {};
var ee = function(e, t, r = {}) {
if (typeof t !== "object") {
t = [ t ];
}
q(!Array.isArray(t) || t.length, "Values array cannot be empty");
if (typeof e === "string") {
return Q.string(e, t, r);
}
if (Array.isArray(e)) {
return Q.array(e, t, r);
}
q(typeof e === "object", "Reference must be string or an object");
return Q.object(e, t, r);
};
Q.array = function(e, t, r) {
if (!Array.isArray(t)) {
t = [ t ];
}
if (!e.length) {
return false;
}
if (r.only && r.once && e.length !== t.length) {
return false;
}
let n;
const s = new Map;
for (const e of t) {
if (!r.deep || !e || typeof e !== "object") {
const t = s.get(e);
if (t) {
++t.allowed;
} else {
s.set(e, {
allowed: 1,
hits: 0
});
}
} else {
n = n ?? Q.compare(r);
let t = false;
for (const [r, i] of s.entries()) {
if (n(r, e)) {
++i.allowed;
t = true;
break;
}
}
if (!t) {
s.set(e, {
allowed: 1,
hits: 0
});
}
}
}
let i = 0;
for (const t of e) {
let e;
if (!r.deep || !t || typeof t !== "object") {
e = s.get(t);
} else {
n = n ?? Q.compare(r);
for (const [r, i] of s.entries()) {
if (n(r, t)) {
e = i;
break;
}
}
}
if (e) {
++e.hits;
++i;
if (r.once && e.hits > e.allowed) {
return false;
}
}
}
if (r.only && i !== e.length) {
return false;
}
for (const e of s.values()) {
if (e.hits === e.allowed) {
continue;
}
if (e.hits < e.allowed && !r.part) {
return false;
}
}
return !!i;
};
Q.object = function(e, t, r) {
q(r.once === undefined, "Cannot use option once with object");
const n = J.keys(e, r);
if (!n.length) {
return false;
}
if (Array.isArray(t)) {
return Q.array(n, t, r);
}
const s = Object.getOwnPropertySymbols(t).filter(e => t.propertyIsEnumerable(e));
const i = [ ...Object.keys(t), ...s ];
const a = Q.compare(r);
const o = new Set(i);
for (const s of n) {
if (!o.has(s)) {
if (r.only) {
return false;
}
continue;
}
if (!a(t[s], e[s])) {
return false;
}
o.delete(s);
}
if (o.size) {
return r.part ? o.size < i.length : false;
}
return true;
};
Q.string = function(e, t, r) {
if (e === "") {
return t.length === 1 && t[0] === "" || !r.once && !t.some(e => e !== "");
}
const n = new Map;
const s = [];
for (const e of t) {
q(typeof e === "string", "Cannot compare string reference to non-string value");
if (e) {
const t = n.get(e);
if (t) {
++t.allowed;
} else {
n.set(e, {
allowed: 1,
hits: 0
});
s.push(Z(e));
}
} else if (r.once || r.only) {
return false;
}
}
if (!s.length) {
return true;
}
const i = new RegExp(`(${s.join("|")})`, "g");
const a = e.replace(i, (e, t) => {
++n.get(t).hits;
return "";
});
if (r.only && a) {
return false;
}
let o = false;
for (const e of n.values()) {
if (e.hits) {
o = true;
}
if (e.hits === e.allowed) {
continue;
}
if (e.hits < e.allowed && !r.part) {
return false;
}
if (r.once) {
return false;
}
}
return !!o;
};
Q.compare = function(e) {
if (!e.deep) {
return Q.shallow;
}
const t = e.only !== undefined;
const r = e.part !== undefined;
const n = {
prototype: t ? e.only : r ? !e.part : false,
part: t ? !e.only : r ? e.part : false
};
return (e, t) => z(e, t, n);
};
Q.shallow = function(e, t) {
return e === t;
};
const te = p;
var re = function(e) {
te(/^[ \w\!#\$%&'\(\)\*\+,\-\.\/\:;<\=>\?@\[\]\^`\{\|\}~\"\\]*$/.test(e), "Bad attribute value (" + e + ")");
return e.replace(/\\/g, "\\\\").replace(/\"/g, '\\"');
};
const ne = {};
var se = function(e) {
if (!e) {
return "";
}
let t = "";
for (let r = 0; r < e.length; ++r) {
const n = e.charCodeAt(r);
if (ne.isSafe(n)) {
t += e[r];
} else {
t += ne.escapeHtmlChar(n);
}
}
return t;
};
ne.escapeHtmlChar = function(e) {
const t = ne.namedHtml.get(e);
if (t) {
return t;
}
if (e >= 256) {
return "&#" + e + ";";
}
const r = e.toString(16).padStart(2, "0");
return `&#x${r};`;
};
ne.isSafe = function(e) {
return ne.safeCharCodes.has(e);
};
ne.namedHtml = new Map([ [ 38, "&" ], [ 60, "<" ], [ 62, ">" ], [ 34, """ ], [ 160, " " ], [ 162, "¢" ], [ 163, "£" ], [ 164, "¤" ], [ 169, "©" ], [ 174, "®" ] ]);
ne.safeCharCodes = function() {
const e = new Set;
for (let t = 32; t < 123; ++t) {
if (t >= 97 || t >= 65 && t <= 90 || t >= 48 && t <= 57 || t === 32 || t === 46 || t === 44 || t === 45 || t === 58 || t === 95) {
e.add(t);
}
}
return e;
}();
const ie = {};
var ae = function(e) {
if (!e) {
return "";
}
return e.replace(/[<>&\u2028\u2029]/g, ie.escape);
};
ie.escape = function(e) {
return ie.replacements.get(e);
};
ie.replacements = new Map([ [ "<", "\\u003c" ], [ ">", "\\u003e" ], [ "&", "\\u0026" ], [ "\u2028", "\\u2028" ], [ "\u2029", "\\u2029" ] ]);
const oe = {};
var le = oe.flatten = function(e, t) {
const r = t || [];
for (const t of e) {
if (Array.isArray(t)) {
oe.flatten(t, r);
} else {
r.push(t);
}
}
return r;
};
const ue = {};
var ce = function(e, t, r = {}) {
if (!e || !t) {
return r.first ? null : [];
}
const n = [];
const s = Array.isArray(e) ? new Set(e) : e;
const i = new Set;
for (const e of t) {
if (ue.has(s, e) && !i.has(e)) {
if (r.first) {
return e;
}
n.push(e);
i.add(e);
}
}
return r.first ? null : n;
};
ue.has = function(e, t) {
if (typeof e.has === "function") {
return e.has(t);
}
return e[t] !== undefined;
};
var fe = function(e) {
return typeof e?.then === "function";
};
const de = {
wrapped: Symbol("wrapped")
};
var me = function(e) {
if (e[de.wrapped]) {
return e;
}
let t = false;
const r = function(...r) {
if (!t) {
t = true;
e(...r);
}
};
r[de.wrapped] = true;
return r;
};
const he = _;
var pe = function(e, t, r) {
return t.replace(/{([^{}]+)}/g, (t, n) => {
const s = he(e, n, r);
return s ?? "";
});
};
const ge = {
maxTimer: 2 ** 31 - 1
};
var ye = function(e, t, r) {
if (typeof e === "bigint") {
e = Number(e);
}
if (e >= Number.MAX_SAFE_INTEGER) {
e = Infinity;
}
if (typeof e !== "number" && e !== undefined) {
throw new TypeError("Timeout must be a number or bigint");
}
return new Promise(n => {
const s = r ? r.setTimeout : setTimeout;
const i = () => {
const r = Math.min(e, ge.maxTimer);
e -= r;
s(() => e > 0 ? i() : n(t), r);
};
if (e !== Infinity) {
i();
}
});
};
l.applyToDefaults = B;
l.assert = p;
l.AssertError = c;
l.Bench = U;
l.block = X;
l.clone = N;
l.contain = ee;
l.deepEqual = V;
l.escapeHeaderAttribute = re;
l.escapeHtml = se;
l.escapeJson = ae;
l.escapeRegex = W;
l.flatten = le;
l.ignore = G;
l.intersect = ce;
l.isPromise = fe;
l.merge = x;
l.once = me;
l.reach = _;
l.reachTemplate = pe;
l.stringify = f;
l.wait = ye;
var be = {};
var _e = {};
var ve = "18.0.2";
const Ae = {
version: ve
};
var Ee = {};
var Re;
function Se() {
if (Re) return Ee;
Re = 1;
const e = qr();
const t = {};
t.wrap = e.string().min(1).max(2).allow(false);
Ee.preferences = e.object({
allowUnknown: e.boolean(),
abortEarly: e.boolean(),
artifacts: e.boolean(),
cache: e.boolean(),
context: e.object(),
convert: e.boolean(),
dateFormat: e.valid("date", "iso", "string", "time", "utc"),
debug: e.boolean(),
errors: {
escapeHtml: e.boolean(),
label: e.valid("path", "key", false),
language: [ e.string(), e.object().ref() ],
render: e.boolean(),
stack: e.boolean(),
wrap: {
label: t.wrap,
array: t.wrap,
string: t.wrap
}
},
externals: e.boolean(),
messages: e.object(),
noDefaults: e.boolean(),
nonEnumerables: e.boolean(),
presence: e.valid("required", "optional", "forbidden"),
skipFunctions: e.boolean(),
stripUnknown: e.object({
arrays: e.boolean(),
objects: e.boolean()
}).or("arrays", "objects").allow(true, false),
warnings: e.boolean()
}).strict();
t.nameRx = /^[a-zA-Z0-9]\w*$/;
t.rule = e.object({
alias: e.array().items(e.string().pattern(t.nameRx)).single(),
args: e.array().items(e.string(), e.object({
name: e.string().pattern(t.nameRx).required(),
ref: e.boolean(),
assert: e.alternatives([ e.function(), e.object().schema() ]).conditional("ref", {
is: true,
then: e.required()
}),
normalize: e.function(),
message: e.string().when("assert", {
is: e.function(),
then: e.required()
})
})),
convert: e.boolean(),
manifest: e.boolean(),
method: e.function().allow(false),
multi: e.boolean(),
validate: e.function()
});
Ee.extension = e.object({
type: e.alternatives([ e.string(), e.object().regex() ]).required(),
args: e.function(),
cast: e.object().pattern(t.nameRx, e.object({
from: e.function().maxArity(1).required(),
to: e.function().minArity(1).maxArity(2).required()
})),
base: e.object().schema().when("type", {
is: e.object().regex(),
then: e.forbidden()
}),
coerce: [ e.function().maxArity(3), e.object({
method: e.function().maxArity(3).required(),
from: e.array().items(e.string()).single()
}) ],
flags: e.object().pattern(t.nameRx, e.object({
setter: e.string(),
default: e.any()
})),
manifest: {
build: e.function().arity(2)
},
messages: [ e.object(), e.string() ],
modifiers: e.object().pattern(t.nameRx, e.function().minArity(1).maxArity(2)),
overrides: e.object().pattern(t.nameRx, e.function()),
prepare: e.function().maxArity(3),
rebuild: e.function().arity(1),
rules: e.object().pattern(t.nameRx, t.rule),
terms: e.object().pattern(t.nameRx, e.object({
init: e.array().allow(null).required(),
manifest: e.object().pattern(/.+/, [ e.valid("schema", "single"), e.object({
mapped: e.object({
from: e.string().required(),
to: e.string().required()
}).required()
}) ])
})),
validate: e.function().maxArity(3)
}).strict();
Ee.extensions = e.array().items(e.object(), e.function().arity(1)).strict();
t.desc = {
buffer: e.object({
buffer: e.string()
}),
func: e.object({
function: e.function().required(),
options: {
literal: true
}
}),
override: e.object({
override: true
}),
ref: e.object({
ref: e.object({
type: e.valid("value", "global", "local"),
path: e.array().required(),
separator: e.string().length(1).allow(false),
ancestor: e.number().min(0).integer().allow("root"),
map: e.array().items(e.array().length(2)).min(1),
adjust: e.function(),
iterables: e.boolean(),
in: e.boolean(),
render: e.boolean()
}).required()
}),
regex: e.object({
regex: e.string().min(3)
}),
special: e.object({
special: e.valid("deep").required()
}),
template: e.object({
template: e.string().required(),
options: e.object()
}),
value: e.object({
value: e.alternatives([ e.object(), e.array() ]).required()
})
};
t.desc.entity = e.alternatives([ e.array().items(e.link("...")), e.boolean(), e.function(), e.number(), e.string(), t.desc.buffer, t.desc.func, t.desc.ref, t.desc.regex, t.desc.special, t.desc.template, t.desc.value, e.link("/") ]);
t.desc.values = e.array().items(null, e.boolean(), e.function(), e.number().allow(Infinity, -Infinity), e.string().allow(""), e.symbol(), t.desc.buffer, t.desc.func, t.desc.override, t.desc.ref, t.desc.regex, t.desc.template, t.desc.value);
t.desc.messages = e.object().pattern(/.+/, [ e.string(), t.desc.template, e.object().pattern(/.+/, [ e.string(), t.desc.template ]) ]);
Ee.description = e.object({
type: e.string().required(),
flags: e.object({
cast: e.string(),
default: e.any(),
description: e.string(),
empty: e.link("/"),
failover: t.desc.entity,
id: e.string(),
label: e.string(),
only: true,
presence: [ "optional", "required", "forbidden" ],
result: [ "raw", "strip" ],
strip: e.boolean(),
unit: e.string()
}).unknown(),
preferences: {
allowUnknown: e.boolean(),
abortEarly: e.boolean(),
artifacts: e.boolean(),
cache: e.boolean(),
convert: e.boolean(),
dateFormat: [ "date", "iso", "string", "time", "utc" ],
errors: {
escapeHtml: e.boolean(),
label: [ "path", "key" ],
language: [ e.string(), t.desc.ref ],
wrap: {
label: t.wrap,
array: t.wrap
}
},
externals: e.boolean(),
messages: t.desc.messages,
noDefaults: e.boolean(),
nonEnumerables: e.boolean(),
presence: [ "required", "optional", "forbidden" ],
skipFunctions: e.boolean(),
stripUnknown: e.object({
arrays: e.boolean(),
objects: e.boolean()
}).or("arrays", "objects").allow(true, false),
warnings: e.boolean()
},
allow: t.desc.values,
invalid: t.desc.values,
rules: e.array().min(1).items({
name: e.string().required(),
args: e.object().min(1),
keep: e.boolean(),
message: [ e.string(), t.desc.messages ],
warn: e.boolean()
}),
keys: e.object().pattern(/.*/, e.link("/")),
link: t.desc.ref
}).pattern(/^[a-z]\w*$/, e.any());
return Ee;
}
var Oe = {};
var we = {
exports: {}
};
var Ne = {};
(function(e) {
const t = {
operators: [ "!", "^", "*", "/", "%", "+", "-", "<", "<=", ">", ">=", "==", "!=", "&&", "||", "??" ],
operatorCharacters: [ "!", "^", "*", "/", "%", "+", "-", "<", "=", ">", "&", "|", "?" ],
operatorsOrder: [ [ "^" ], [ "*", "/", "%" ], [ "+", "-" ], [ "<", "<=", ">", ">=" ], [ "==", "!=" ], [ "&&" ], [ "||", "??" ] ],
operatorsPrefix: [ "!", "n" ],
literals: {
'"': '"',
"`": "`",
"'": "'",
"[": "]"
},
numberRx: /^(?:[0-9]*(\.[0-9]*)?){1}$/,
tokenRx: /^[\w\$\#\.\@\:\{\}]+$/,
symbol: Symbol("formula"),
settings: Symbol("settings")
};
e.Parser = class {
constructor(e, r = {}) {
if (!r[t.settings] && r.constants) {
for (const e in r.constants) {
const t = r.constants[e];
if (t !== null && ![ "boolean", "number", "string" ].includes(typeof t)) {
throw new Error(`Formula constant ${e} contains invalid ${typeof t} value type`);
}
}
}
this.settings = r[t.settings] ? r : Object.assign({
[t.settings]: true,
constants: {},
functions: {}
}, r);
this.single = null;
this._parts = null;
this._parse(e);
}
_parse(r) {
let n = [];
let s = "";
let i = 0;
let a = false;
const o = r => {
if (i) {
throw new Error("Formula missing closing parenthesis");
}
const o = n.length ? n[n.length - 1] : null;
if (!a && !s && !r) {
return;
}
if (o && o.type === "reference" && r === ")") {
o.type = "function";
o.value = this._subFormula(s, o.value);
s = "";
return;
}
if (r === ")") {
const t = new e.Parser(s, this.settings);
n.push({
type: "segment",
value: t
});
} else if (a) {
if (a === "]") {
n.push({
type: "reference",
value: s
});
s = "";
return;
}
n.push({
type: "literal",
value: s
});
} else if (t.operatorCharacters.includes(s)) {
if (o && o.type === "operator" && t.operators.includes(o.value + s)) {
o.value += s;
} else {
n.push({
type: "operator",
value: s
});
}
} else if (s.match(t.numberRx)) {
n.push({
type: "constant",
value: parseFloat(s)
});
} else if (this.settings.constants[s] !== undefined) {
n.push({
type: "constant",
value: this.settings.constants[s]
});
} else {
if (!s.match(t.tokenRx)) {
throw new Error(`Formula contains invalid token: ${s}`);
}
n.push({
type: "reference",
value: s
});
}
s = "";
};
for (const e of r) {
if (a) {
if (e === a) {
o();
a = false;
} else {
s += e;
}
} else if (i) {
if (e === "(") {
s += e;
++i;
} else if (e === ")") {
--i;
if (!i) {
o(e);
} else {
s += e;
}
} else {
s += e;
}
} else if (e in t.literals) {
a = t.literals[e];
} else if (e === "(") {
o();
++i;
} else if (t.operatorCharacters.includes(e)) {
o();
s = e;
o();
} else if (e !== " ") {
s += e;
} else {
o();
}
}
o();
n = n.map((e, t) => {
if (e.type !== "operator" || e.value !== "-" || t && n[t - 1].type !== "operator") {
return e;
}
return {
type: "operator",
value: "n"
};
});
let l = false;
for (const e of n) {
if (e.type === "operator") {
if (t.operatorsPrefix.includes(e.value)) {
continue;
}
if (!l) {
throw new Error("Formula contains an operator in invalid position");
}
if (!t.operators.includes(e.value)) {
throw new Error(`Formula contains an unknown operator ${e.value}`);
}
} else if (l) {
throw new Error("Formula missing expected operator");
}
l = !l;
}
if (!l) {
throw new Error("Formula contains invalid trailing operator");
}
if (n.length === 1 && [ "reference", "literal", "constant" ].includes(n[0].type)) {
this.single = {
type: n[0].type === "reference" ? "reference" : "value",
value: n[0].value
};
}
this._parts = n.map(e => {
if (e.type === "operator") {
return t.operatorsPrefix.includes(e.value) ? e : e.value;
}
if (e.type !== "reference") {
return e.value;
}
if (this.settings.tokenRx && !this.settings.tokenRx.test(e.value)) {
throw new Error(`Formula contains invalid reference ${e.value}`);
}
if (this.settings.reference) {
return this.settings.reference(e.value);
}
return t.reference(e.value);
});
}
_subFormula(r, n) {
const s = this.settings.functions[n];
if (typeof s !== "function") {
throw new Error(`Formula contains unknown function ${n}`);
}
let i = [];
if (r) {
let e = "";
let s = 0;
let a = false;
const o = () => {
if (!e) {
throw new Error(`Formula contains function ${n} with invalid arguments ${r}`);
}
i.push(e);
e = "";
};
for (let n = 0; n < r.length; ++n) {
const i = r[n];
if (a) {
e += i;
if (i === a) {
a = false;
}
} else if (i in t.literals && !s) {
e += i;
a = t.literals[i];
} else if (i === "," && !s) {
o();
} else {
e += i;
if (i === "(") {
++s;
} else if (i === ")") {
--s;
}
}
}
o();
}
i = i.map(t => new e.Parser(t, this.settings));
return function(e) {
const t = [];
for (const r of i) {
t.push(r.evaluate(e));
}
return s.call(e, ...t);
};
}
evaluate(e) {
const r = this._parts.slice();
for (let n = r.length - 2; n >= 0; --n) {
const s = r[n];
if (s && s.type === "operator") {
const i = r[n + 1];
r.splice(n + 1, 1);
const a = t.evaluate(i, e);
r[n] = t.single(s.value, a);
}
}
t.operatorsOrder.forEach(n => {
for (let s = 1; s < r.length - 1; ) {
if (n.includes(r[s])) {
const n = r[s];
const i = t.evaluate(r[s - 1], e);
const a = t.evaluate(r[s + 1], e);
r.splice(s, 2);
const o = t.calculate(n, i, a);
r[s - 1] = o === 0 ? 0 : o;
} else {
s += 2;
}
}
});
return t.evaluate(r[0], e);
}
};
e.Parser.prototype[t.symbol] = true;
t.reference = function(e) {
return function(t) {
return t && t[e] !== undefined ? t[e] : null;
};
};
t.evaluate = function(e, r) {
if (e === null) {
return null;
}
if (typeof e === "function") {
return e(r);
}
if (e[t.symbol]) {
return e.evaluate(r);
}
return e;
};
t.single = function(e, t) {
if (e === "!") {
return t ? false : true;
}
const r = -t;
if (r === 0) {
return 0;
}
return r;
};
t.calculate = function(e, r, n) {
if (e === "??") {
return t.exists(r) ? r : n;
}
if (typeof r === "string" || typeof n === "string") {
if (e === "+") {
r = t.exists(r) ? r : "";
n = t.exists(n) ? n : "";
return r + n;
}
} else {
switch (e) {
case "^":
return Math.pow(r, n);
case "*":
return r * n;
case "/":
return r / n;
case "%":
return r % n;
case "+":
return r + n;
case "-":
return r - n;
}
}
switch (e) {
case "<":
return r < n;
case "<=":
return r <= n;
case ">":
return r > n;
case ">=":
return r >= n;
case "==":
return r === n;
case "!=":
return r !== n;
case "&&":
return r && n;
case "||":
return r || n;
}
return null;
};
t.exists = function(e) {
return e !== null && e !== undefined;
};
})(Ne);
var Ie = {};
var $e = {};
var Te;
function Ce() {
if (Te) return $e;
Te = 1;
const {clone: e} = l;
const t = Fe();
const r = {
annotations: Symbol("annotations")
};
$e.error = function(n) {
if (!this._original || typeof this._original !== "object") {
return this.details[0].message;
}
const s = n ? "" : "[31m";
const i = n ? "" : "[41m";
const a = n ? "" : "[0m";
const o = e(this._original);
for (let e = this.details.length - 1; e >= 0; --e) {
const n = e + 1;
const s = this.details[e];
const i = s.path;
let a = o;
for (let e = 0; ;++e) {
const o = i[e];
if (t.isSchema(a)) {
a = a.clone();
}
if (e + 1 < i.length && typeof a[o] !== "string") {
a = a[o];
} else {
const e = a[r.annotations] || {
errors: {},
missing: {}
};
a[r.annotations] = e;
const t = o || s.context.key;
if (a[o] !== undefined) {
e.errors[t] = e.errors[t] || [];
e.errors[t].push(n);
} else {
e.missing[t] = n;
}
break;
}
}
}
const l = {
key: /_\$key\$_([, \d]+)_\$end\$_"/g,
missing: /"_\$miss\$_([^|]+)\|(\d+)_\$end\$_": "__missing__"/g,
arrayIndex: /\s*"_\$idx\$_([, \d]+)_\$end\$_",?\n(.*)/g,
specials: /"\[(NaN|Symbol.*|-?Infinity|function.*|\(.*)]"/g
};
let u = r.safeStringify(o, 2).replace(l.key, (e, t) => `" ${s}[${t}]${a}`).replace(l.missing, (e, t, r) => `${i}"${t}"${a}${s} [${r}]: -- missing --${a}`).replace(l.arrayIndex, (e, t, r) => `\n${r} ${s}[${t}]${a}`).replace(l.specials, (e, t) => t);
u = `${u}\n${s}`;
for (let e = 0; e < this.details.length; ++e) {
const t = e + 1;
u = `${u}\n[${t}] ${this.details[e].message}`;
}
u = u + a;
return u;
};
r.safeStringify = function(e, t) {
return JSON.stringify(e, r.serializer(), t);
};
r.serializer = function() {
const e = [];
const t = [];
const n = (r, n) => {
if (t[0] === n) {
return "[Circular ~]";
}
return "[Circular ~." + e.slice(0, t.indexOf(n)).join(".") + "]";
};
return function(s, i) {
if (t.length > 0) {
const r = t.indexOf(this);
if (~r) {
t.length = r + 1;
e.length = r + 1;
e[r] = s;
} else {
t.push(this);
e.push(s);
}
if (~t.indexOf(i)) {
i = n.call(this, s, i);
}
} else {
t.push(i);
}
if (i) {
const e = i[r.annotations];
if (e) {
if (Array.isArray(i)) {
const t = [];
for (let r = 0; r < i.length; ++r) {
if (e.errors[r]) {
t.push(`_$idx$_${e.errors[r].sort().join(", ")}_$end$_`);
}
t.push(i[r]);
}
i = t;
} else {
for (const t in e.errors)