--- /srv/reproducible-results/rbuild-debian/r-b-build.mSCOFagS/b1/node-rjsf_5.12.1+~5.0.1-2_arm64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.mSCOFagS/b2/node-rjsf_5.12.1+~5.0.1-2_arm64.changes ├── Files │ @@ -1,2 +1,2 @@ │ │ - 208e6d2345f44ef25e33a795d557de09 350612 javascript optional node-rjsf_5.12.1+~5.0.1-2_all.deb │ + d60749237af2e0edf5cdc05ca673e8f6 357756 javascript optional node-rjsf_5.12.1+~5.0.1-2_all.deb ├── node-rjsf_5.12.1+~5.0.1-2_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2023-12-18 07:52:01.000000 debian-binary │ │ -rw-r--r-- 0 0 0 7604 2023-12-18 07:52:01.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 342816 2023-12-18 07:52:01.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 349960 2023-12-18 07:52:01.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./control │ │ │ │ @@ -1,12 +1,12 @@ │ │ │ │ Package: node-rjsf │ │ │ │ Version: 5.12.1+~5.0.1-2 │ │ │ │ Architecture: all │ │ │ │ Maintainer: Debian Javascript Maintainers │ │ │ │ -Installed-Size: 12045 │ │ │ │ +Installed-Size: 12041 │ │ │ │ Depends: node-ajv (>= 8), node-lodash, node-markdown-to-jsx, node-nanoid, node-prop-types │ │ │ │ Provides: node-jsonpointer (= 5.0.0), node-rjsf-core (= 5.12.1), node-rjsf-utils (= 5.12.1), node-rjsf-validator-ajv6 (= 5.12.1), node-rjsf-validator-ajv8 (= 5.12.1) │ │ │ │ Section: javascript │ │ │ │ Priority: optional │ │ │ │ Homepage: https://github.com/rjsf-team/react-jsonschema-form │ │ │ │ Description: ReactJS component capable of using JSON Schema to declaratively build forms │ │ │ │ node-rjsf provides ReactJS components capable of using JSON Schema to │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -375,15 +375,15 @@ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 54805 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/utils/src/types.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 930 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/utils/src/unwrapErrorHandler.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1063 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/utils/src/utcToLocal.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1468 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/utils/src/validationDataMerge.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1968 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/utils/src/withIdRefPrefix.ts │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1366916 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/index.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1362925 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/index.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/lib/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1490 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/lib/createAjvInstance.d.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 644 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/lib/customizeValidator.d.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 299 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/lib/index.d.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 598 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/lib/types.d.ts │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3716 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/dist/lib/validator.d.ts │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2023-12-18 07:52:01.000000 ./usr/share/nodejs/@rjsf/validator-ajv6/lib/ │ │ │ ├── ./usr/share/nodejs/@rjsf/validator-ajv6/dist/index.js │ │ │ │ ├── js-beautify {} │ │ │ │ │ @@ -6518,15 +6518,15 @@ │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ return object; │ │ │ │ │ }); │ │ │ │ │ │ │ │ │ │ -var defaults_1 = defaults$1; │ │ │ │ │ +var defaults_1$1 = defaults$1; │ │ │ │ │ │ │ │ │ │ var SetCache$1 = _SetCache, │ │ │ │ │ arrayIncludes$1 = _arrayIncludes, │ │ │ │ │ arrayIncludesWith$1 = _arrayIncludesWith, │ │ │ │ │ arrayMap$5 = _arrayMap, │ │ │ │ │ baseUnary$2 = _baseUnary, │ │ │ │ │ cacheHas$1 = _cacheHas; │ │ │ │ │ @@ -6719,15 +6719,15 @@ │ │ │ │ │ │ │ │ │ │ var isBoolean_1 = isBoolean$1; │ │ │ │ │ │ │ │ │ │ var isEqual$1 = isEqual_1; │ │ │ │ │ var sortBy$1 = sortBy_1; │ │ │ │ │ var uniq$2 = uniq_1; │ │ │ │ │ var uniqWith$4 = uniqWith_1; │ │ │ │ │ -var defaults$2 = defaults_1; │ │ │ │ │ +var defaults$2 = defaults_1$1; │ │ │ │ │ var intersectionWith$1 = intersectionWith_1; │ │ │ │ │ var isPlainObject$3 = isPlainObject_1; │ │ │ │ │ var isBoolean = isBoolean_1; │ │ │ │ │ │ │ │ │ │ var normalizeArray = val => Array.isArray(val) ? │ │ │ │ │ val : [val]; │ │ │ │ │ var undef = val => val === undefined; │ │ │ │ │ @@ -33859,1172 +33859,1151 @@ │ │ │ │ │ │ │ │ │ │ var errors = {}; │ │ │ │ │ │ │ │ │ │ var codegen = {}; │ │ │ │ │ │ │ │ │ │ var code$1 = {}; │ │ │ │ │ │ │ │ │ │ -var hasRequiredCode$1; │ │ │ │ │ - │ │ │ │ │ -function requireCode$1() { │ │ │ │ │ - if (hasRequiredCode$1) return code$1; │ │ │ │ │ - hasRequiredCode$1 = 1; │ │ │ │ │ - (function(exports) { │ │ │ │ │ - Object.defineProperty(exports, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0; │ │ │ │ │ - class _CodeOrName {} │ │ │ │ │ - exports._CodeOrName = _CodeOrName; │ │ │ │ │ - exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; │ │ │ │ │ - class Name extends _CodeOrName { │ │ │ │ │ - constructor(s) { │ │ │ │ │ - super(); │ │ │ │ │ - if (!exports.IDENTIFIER.test(s)) │ │ │ │ │ - throw new Error("CodeGen: name must be a valid identifier"); │ │ │ │ │ - this.str = s; │ │ │ │ │ - } │ │ │ │ │ - toString() { │ │ │ │ │ - return this.str; │ │ │ │ │ - } │ │ │ │ │ - emptyStr() { │ │ │ │ │ +(function(exports) { │ │ │ │ │ + Object.defineProperty(exports, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ + }); │ │ │ │ │ + exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0; │ │ │ │ │ + class _CodeOrName {} │ │ │ │ │ + exports._CodeOrName = _CodeOrName; │ │ │ │ │ + exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; │ │ │ │ │ + class Name extends _CodeOrName { │ │ │ │ │ + constructor(s) { │ │ │ │ │ + super(); │ │ │ │ │ + if (!exports.IDENTIFIER.test(s)) │ │ │ │ │ + throw new Error("CodeGen: name must be a valid identifier"); │ │ │ │ │ + this.str = s; │ │ │ │ │ + } │ │ │ │ │ + toString() { │ │ │ │ │ + return this.str; │ │ │ │ │ + } │ │ │ │ │ + emptyStr() { │ │ │ │ │ + return false; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + return { │ │ │ │ │ + [this.str]: 1 │ │ │ │ │ + }; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + exports.Name = Name; │ │ │ │ │ + class _Code extends _CodeOrName { │ │ │ │ │ + constructor(code) { │ │ │ │ │ + super(); │ │ │ │ │ + this._items = typeof code === "string" ? [code] : code; │ │ │ │ │ + } │ │ │ │ │ + toString() { │ │ │ │ │ + return this.str; │ │ │ │ │ + } │ │ │ │ │ + emptyStr() { │ │ │ │ │ + if (this._items.length > 1) │ │ │ │ │ return false; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return { │ │ │ │ │ - [this.str]: 1 │ │ │ │ │ - }; │ │ │ │ │ - } │ │ │ │ │ + const item = this._items[0]; │ │ │ │ │ + return item === "" || item === '""'; │ │ │ │ │ } │ │ │ │ │ - exports.Name = Name; │ │ │ │ │ - class _Code extends _CodeOrName { │ │ │ │ │ - constructor(code) { │ │ │ │ │ - super(); │ │ │ │ │ - this._items = typeof code === "string" ? [code] : code; │ │ │ │ │ - } │ │ │ │ │ - toString() { │ │ │ │ │ - return this.str; │ │ │ │ │ - } │ │ │ │ │ - emptyStr() { │ │ │ │ │ - if (this._items.length > 1) │ │ │ │ │ - return false; │ │ │ │ │ - const item = this._items[0]; │ │ │ │ │ - return item === "" || item === '""'; │ │ │ │ │ - } │ │ │ │ │ - get str() { │ │ │ │ │ - var _a; │ │ │ │ │ - return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, ""))); │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - var _a; │ │ │ │ │ - return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => { │ │ │ │ │ - if (c instanceof Name) │ │ │ │ │ - names[c.str] = (names[c.str] || 0) + 1; │ │ │ │ │ - return names; │ │ │ │ │ - }, {}))); │ │ │ │ │ - } │ │ │ │ │ + get str() { │ │ │ │ │ + var _a; │ │ │ │ │ + return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, ""))); │ │ │ │ │ } │ │ │ │ │ - exports._Code = _Code; │ │ │ │ │ - exports.nil = new _Code(""); │ │ │ │ │ - │ │ │ │ │ - function _(strs, ...args) { │ │ │ │ │ - const code = [strs[0]]; │ │ │ │ │ - let i = 0; │ │ │ │ │ - while (i < args.length) { │ │ │ │ │ - addCodeArg(code, args[i]); │ │ │ │ │ - code.push(strs[++i]); │ │ │ │ │ - } │ │ │ │ │ - return new _Code(code); │ │ │ │ │ + get names() { │ │ │ │ │ + var _a; │ │ │ │ │ + return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => { │ │ │ │ │ + if (c instanceof Name) │ │ │ │ │ + names[c.str] = (names[c.str] || 0) + 1; │ │ │ │ │ + return names; │ │ │ │ │ + }, {}))); │ │ │ │ │ } │ │ │ │ │ - exports._ = _; │ │ │ │ │ - const plus = new _Code("+"); │ │ │ │ │ + } │ │ │ │ │ + exports._Code = _Code; │ │ │ │ │ + exports.nil = new _Code(""); │ │ │ │ │ │ │ │ │ │ - function str(strs, ...args) { │ │ │ │ │ - const expr = [safeStringify(strs[0])]; │ │ │ │ │ - let i = 0; │ │ │ │ │ - while (i < args.length) { │ │ │ │ │ - expr.push(plus); │ │ │ │ │ - addCodeArg(expr, args[i]); │ │ │ │ │ - expr.push(plus, safeStringify(strs[++i])); │ │ │ │ │ - } │ │ │ │ │ - optimize(expr); │ │ │ │ │ - return new _Code(expr); │ │ │ │ │ - } │ │ │ │ │ - exports.str = str; │ │ │ │ │ - │ │ │ │ │ - function addCodeArg(code, arg) { │ │ │ │ │ - if (arg instanceof _Code) │ │ │ │ │ - code.push(...arg._items); │ │ │ │ │ - else if (arg instanceof Name) │ │ │ │ │ - code.push(arg); │ │ │ │ │ - else │ │ │ │ │ - code.push(interpolate(arg)); │ │ │ │ │ - } │ │ │ │ │ - exports.addCodeArg = addCodeArg; │ │ │ │ │ + function _(strs, ...args) { │ │ │ │ │ + const code = [strs[0]]; │ │ │ │ │ + let i = 0; │ │ │ │ │ + while (i < args.length) { │ │ │ │ │ + addCodeArg(code, args[i]); │ │ │ │ │ + code.push(strs[++i]); │ │ │ │ │ + } │ │ │ │ │ + return new _Code(code); │ │ │ │ │ + } │ │ │ │ │ + exports._ = _; │ │ │ │ │ + const plus = new _Code("+"); │ │ │ │ │ + │ │ │ │ │ + function str(strs, ...args) { │ │ │ │ │ + const expr = [safeStringify(strs[0])]; │ │ │ │ │ + let i = 0; │ │ │ │ │ + while (i < args.length) { │ │ │ │ │ + expr.push(plus); │ │ │ │ │ + addCodeArg(expr, args[i]); │ │ │ │ │ + expr.push(plus, safeStringify(strs[++i])); │ │ │ │ │ + } │ │ │ │ │ + optimize(expr); │ │ │ │ │ + return new _Code(expr); │ │ │ │ │ + } │ │ │ │ │ + exports.str = str; │ │ │ │ │ + │ │ │ │ │ + function addCodeArg(code, arg) { │ │ │ │ │ + if (arg instanceof _Code) │ │ │ │ │ + code.push(...arg._items); │ │ │ │ │ + else if (arg instanceof Name) │ │ │ │ │ + code.push(arg); │ │ │ │ │ + else │ │ │ │ │ + code.push(interpolate(arg)); │ │ │ │ │ + } │ │ │ │ │ + exports.addCodeArg = addCodeArg; │ │ │ │ │ │ │ │ │ │ - function optimize(expr) { │ │ │ │ │ - let i = 1; │ │ │ │ │ - while (i < expr.length - 1) { │ │ │ │ │ - if (expr[i] === plus) { │ │ │ │ │ - const res = mergeExprItems(expr[i - 1], expr[i + 1]); │ │ │ │ │ - if (res !== undefined) { │ │ │ │ │ - expr.splice(i - 1, 3, res); │ │ │ │ │ - continue; │ │ │ │ │ - } │ │ │ │ │ - expr[i++] = "+"; │ │ │ │ │ + function optimize(expr) { │ │ │ │ │ + let i = 1; │ │ │ │ │ + while (i < expr.length - 1) { │ │ │ │ │ + if (expr[i] === plus) { │ │ │ │ │ + const res = mergeExprItems(expr[i - 1], expr[i + 1]); │ │ │ │ │ + if (res !== undefined) { │ │ │ │ │ + expr.splice(i - 1, 3, res); │ │ │ │ │ + continue; │ │ │ │ │ } │ │ │ │ │ - i++; │ │ │ │ │ + expr[i++] = "+"; │ │ │ │ │ } │ │ │ │ │ + i++; │ │ │ │ │ } │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function mergeExprItems(a, b) { │ │ │ │ │ - if (b === '""') │ │ │ │ │ - return a; │ │ │ │ │ - if (a === '""') │ │ │ │ │ - return b; │ │ │ │ │ - if (typeof a == "string") { │ │ │ │ │ - if (b instanceof Name || a[a.length - 1] !== '"') │ │ │ │ │ - return; │ │ │ │ │ - if (typeof b != "string") │ │ │ │ │ - return `${a.slice(0, -1)}${b}"`; │ │ │ │ │ - if (b[0] === '"') │ │ │ │ │ - return a.slice(0, -1) + b.slice(1); │ │ │ │ │ + function mergeExprItems(a, b) { │ │ │ │ │ + if (b === '""') │ │ │ │ │ + return a; │ │ │ │ │ + if (a === '""') │ │ │ │ │ + return b; │ │ │ │ │ + if (typeof a == "string") { │ │ │ │ │ + if (b instanceof Name || a[a.length - 1] !== '"') │ │ │ │ │ return; │ │ │ │ │ - } │ │ │ │ │ - if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) │ │ │ │ │ - return `"${a}${b.slice(1)}`; │ │ │ │ │ + if (typeof b != "string") │ │ │ │ │ + return `${a.slice(0, -1)}${b}"`; │ │ │ │ │ + if (b[0] === '"') │ │ │ │ │ + return a.slice(0, -1) + b.slice(1); │ │ │ │ │ return; │ │ │ │ │ } │ │ │ │ │ + if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) │ │ │ │ │ + return `"${a}${b.slice(1)}`; │ │ │ │ │ + return; │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function strConcat(c1, c2) { │ │ │ │ │ - return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`; │ │ │ │ │ - } │ │ │ │ │ - exports.strConcat = strConcat; │ │ │ │ │ - // TODO do not allow arrays here │ │ │ │ │ - function interpolate(x) { │ │ │ │ │ - return typeof x == "number" || typeof x == "boolean" || x === null ? │ │ │ │ │ - x : │ │ │ │ │ - safeStringify(Array.isArray(x) ? x.join(",") : x); │ │ │ │ │ - } │ │ │ │ │ + function strConcat(c1, c2) { │ │ │ │ │ + return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`; │ │ │ │ │ + } │ │ │ │ │ + exports.strConcat = strConcat; │ │ │ │ │ + // TODO do not allow arrays here │ │ │ │ │ + function interpolate(x) { │ │ │ │ │ + return typeof x == "number" || typeof x == "boolean" || x === null ? │ │ │ │ │ + x : │ │ │ │ │ + safeStringify(Array.isArray(x) ? x.join(",") : x); │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function stringify(x) { │ │ │ │ │ - return new _Code(safeStringify(x)); │ │ │ │ │ - } │ │ │ │ │ - exports.stringify = stringify; │ │ │ │ │ + function stringify(x) { │ │ │ │ │ + return new _Code(safeStringify(x)); │ │ │ │ │ + } │ │ │ │ │ + exports.stringify = stringify; │ │ │ │ │ │ │ │ │ │ - function safeStringify(x) { │ │ │ │ │ - return JSON.stringify(x) │ │ │ │ │ - .replace(/\u2028/g, "\\u2028") │ │ │ │ │ - .replace(/\u2029/g, "\\u2029"); │ │ │ │ │ - } │ │ │ │ │ - exports.safeStringify = safeStringify; │ │ │ │ │ + function safeStringify(x) { │ │ │ │ │ + return JSON.stringify(x) │ │ │ │ │ + .replace(/\u2028/g, "\\u2028") │ │ │ │ │ + .replace(/\u2029/g, "\\u2029"); │ │ │ │ │ + } │ │ │ │ │ + exports.safeStringify = safeStringify; │ │ │ │ │ │ │ │ │ │ - function getProperty(key) { │ │ │ │ │ - return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`; │ │ │ │ │ - } │ │ │ │ │ - exports.getProperty = getProperty; │ │ │ │ │ - //Does best effort to format the name properly │ │ │ │ │ - function getEsmExportName(key) { │ │ │ │ │ - if (typeof key == "string" && exports.IDENTIFIER.test(key)) { │ │ │ │ │ - return new _Code(`${key}`); │ │ │ │ │ - } │ │ │ │ │ - throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`); │ │ │ │ │ + function getProperty(key) { │ │ │ │ │ + return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`; │ │ │ │ │ + } │ │ │ │ │ + exports.getProperty = getProperty; │ │ │ │ │ + //Does best effort to format the name properly │ │ │ │ │ + function getEsmExportName(key) { │ │ │ │ │ + if (typeof key == "string" && exports.IDENTIFIER.test(key)) { │ │ │ │ │ + return new _Code(`${key}`); │ │ │ │ │ } │ │ │ │ │ - exports.getEsmExportName = getEsmExportName; │ │ │ │ │ + throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`); │ │ │ │ │ + } │ │ │ │ │ + exports.getEsmExportName = getEsmExportName; │ │ │ │ │ │ │ │ │ │ - function regexpCode(rx) { │ │ │ │ │ - return new _Code(rx.toString()); │ │ │ │ │ - } │ │ │ │ │ - exports.regexpCode = regexpCode; │ │ │ │ │ + function regexpCode(rx) { │ │ │ │ │ + return new _Code(rx.toString()); │ │ │ │ │ + } │ │ │ │ │ + exports.regexpCode = regexpCode; │ │ │ │ │ │ │ │ │ │ - }(code$1)); │ │ │ │ │ - return code$1; │ │ │ │ │ -} │ │ │ │ │ +}(code$1)); │ │ │ │ │ │ │ │ │ │ var scope = {}; │ │ │ │ │ │ │ │ │ │ -var hasRequiredScope; │ │ │ │ │ - │ │ │ │ │ -function requireScope() { │ │ │ │ │ - if (hasRequiredScope) return scope; │ │ │ │ │ - hasRequiredScope = 1; │ │ │ │ │ - (function(exports) { │ │ │ │ │ - Object.defineProperty(exports, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0; │ │ │ │ │ - const code_1 = requireCode$1(); │ │ │ │ │ - class ValueError extends Error { │ │ │ │ │ - constructor(name) { │ │ │ │ │ - super(`CodeGen: "code" for ${name} not defined`); │ │ │ │ │ - this.value = name.value; │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - var UsedValueState; │ │ │ │ │ - (function(UsedValueState) { │ │ │ │ │ - UsedValueState[UsedValueState["Started"] = 0] = "Started"; │ │ │ │ │ - UsedValueState[UsedValueState["Completed"] = 1] = "Completed"; │ │ │ │ │ - })(UsedValueState = exports.UsedValueState || (exports.UsedValueState = {})); │ │ │ │ │ - exports.varKinds = { │ │ │ │ │ - const: new code_1.Name("const"), │ │ │ │ │ - let: new code_1.Name("let"), │ │ │ │ │ - var: new code_1.Name("var"), │ │ │ │ │ - }; │ │ │ │ │ - class Scope { │ │ │ │ │ - constructor({ │ │ │ │ │ - prefixes, │ │ │ │ │ - parent │ │ │ │ │ - } = {}) { │ │ │ │ │ - this._names = {}; │ │ │ │ │ - this._prefixes = prefixes; │ │ │ │ │ - this._parent = parent; │ │ │ │ │ - } │ │ │ │ │ - toName(nameOrPrefix) { │ │ │ │ │ - return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix); │ │ │ │ │ - } │ │ │ │ │ - name(prefix) { │ │ │ │ │ - return new code_1.Name(this._newName(prefix)); │ │ │ │ │ - } │ │ │ │ │ - _newName(prefix) { │ │ │ │ │ - const ng = this._names[prefix] || this._nameGroup(prefix); │ │ │ │ │ - return `${prefix}${ng.index++}`; │ │ │ │ │ - } │ │ │ │ │ - _nameGroup(prefix) { │ │ │ │ │ - var _a, _b; │ │ │ │ │ - if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || (this._prefixes && !this._prefixes.has(prefix))) { │ │ │ │ │ - throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`); │ │ │ │ │ - } │ │ │ │ │ - return (this._names[prefix] = { │ │ │ │ │ - prefix, │ │ │ │ │ - index: 0 │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ +(function(exports) { │ │ │ │ │ + Object.defineProperty(exports, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ + }); │ │ │ │ │ + exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0; │ │ │ │ │ + const code_1 = code$1; │ │ │ │ │ + class ValueError extends Error { │ │ │ │ │ + constructor(name) { │ │ │ │ │ + super(`CodeGen: "code" for ${name} not defined`); │ │ │ │ │ + this.value = name.value; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + var UsedValueState; │ │ │ │ │ + (function(UsedValueState) { │ │ │ │ │ + UsedValueState[UsedValueState["Started"] = 0] = "Started"; │ │ │ │ │ + UsedValueState[UsedValueState["Completed"] = 1] = "Completed"; │ │ │ │ │ + })(UsedValueState = exports.UsedValueState || (exports.UsedValueState = {})); │ │ │ │ │ + exports.varKinds = { │ │ │ │ │ + const: new code_1.Name("const"), │ │ │ │ │ + let: new code_1.Name("let"), │ │ │ │ │ + var: new code_1.Name("var"), │ │ │ │ │ + }; │ │ │ │ │ + class Scope { │ │ │ │ │ + constructor({ │ │ │ │ │ + prefixes, │ │ │ │ │ + parent │ │ │ │ │ + } = {}) { │ │ │ │ │ + this._names = {}; │ │ │ │ │ + this._prefixes = prefixes; │ │ │ │ │ + this._parent = parent; │ │ │ │ │ + } │ │ │ │ │ + toName(nameOrPrefix) { │ │ │ │ │ + return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix); │ │ │ │ │ + } │ │ │ │ │ + name(prefix) { │ │ │ │ │ + return new code_1.Name(this._newName(prefix)); │ │ │ │ │ + } │ │ │ │ │ + _newName(prefix) { │ │ │ │ │ + const ng = this._names[prefix] || this._nameGroup(prefix); │ │ │ │ │ + return `${prefix}${ng.index++}`; │ │ │ │ │ + } │ │ │ │ │ + _nameGroup(prefix) { │ │ │ │ │ + var _a, _b; │ │ │ │ │ + if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || (this._prefixes && !this._prefixes.has(prefix))) { │ │ │ │ │ + throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`); │ │ │ │ │ + } │ │ │ │ │ + return (this._names[prefix] = { │ │ │ │ │ + prefix, │ │ │ │ │ + index: 0 │ │ │ │ │ + }); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + exports.Scope = Scope; │ │ │ │ │ + class ValueScopeName extends code_1.Name { │ │ │ │ │ + constructor(prefix, nameStr) { │ │ │ │ │ + super(nameStr); │ │ │ │ │ + this.prefix = prefix; │ │ │ │ │ + } │ │ │ │ │ + setValue(value, { │ │ │ │ │ + property, │ │ │ │ │ + itemIndex │ │ │ │ │ + }) { │ │ │ │ │ + this.value = value; │ │ │ │ │ + this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + exports.ValueScopeName = ValueScopeName; │ │ │ │ │ + const line = (0, code_1._) `\n`; │ │ │ │ │ + class ValueScope extends Scope { │ │ │ │ │ + constructor(opts) { │ │ │ │ │ + super(opts); │ │ │ │ │ + this._values = {}; │ │ │ │ │ + this._scope = opts.scope; │ │ │ │ │ + this.opts = { │ │ │ │ │ + ...opts, │ │ │ │ │ + _n: opts.lines ? line : code_1.nil │ │ │ │ │ + }; │ │ │ │ │ } │ │ │ │ │ - exports.Scope = Scope; │ │ │ │ │ - class ValueScopeName extends code_1.Name { │ │ │ │ │ - constructor(prefix, nameStr) { │ │ │ │ │ - super(nameStr); │ │ │ │ │ - this.prefix = prefix; │ │ │ │ │ + get() { │ │ │ │ │ + return this._scope; │ │ │ │ │ + } │ │ │ │ │ + name(prefix) { │ │ │ │ │ + return new ValueScopeName(prefix, this._newName(prefix)); │ │ │ │ │ + } │ │ │ │ │ + value(nameOrPrefix, value) { │ │ │ │ │ + var _a; │ │ │ │ │ + if (value.ref === undefined) │ │ │ │ │ + throw new Error("CodeGen: ref must be passed in value"); │ │ │ │ │ + const name = this.toName(nameOrPrefix); │ │ │ │ │ + const { │ │ │ │ │ + prefix │ │ │ │ │ + } = name; │ │ │ │ │ + const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref; │ │ │ │ │ + let vs = this._values[prefix]; │ │ │ │ │ + if (vs) { │ │ │ │ │ + const _name = vs.get(valueKey); │ │ │ │ │ + if (_name) │ │ │ │ │ + return _name; │ │ │ │ │ + } else { │ │ │ │ │ + vs = this._values[prefix] = new Map(); │ │ │ │ │ } │ │ │ │ │ - setValue(value, { │ │ │ │ │ - property, │ │ │ │ │ + vs.set(valueKey, name); │ │ │ │ │ + const s = this._scope[prefix] || (this._scope[prefix] = []); │ │ │ │ │ + const itemIndex = s.length; │ │ │ │ │ + s[itemIndex] = value.ref; │ │ │ │ │ + name.setValue(value, { │ │ │ │ │ + property: prefix, │ │ │ │ │ itemIndex │ │ │ │ │ - }) { │ │ │ │ │ - this.value = value; │ │ │ │ │ - this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`; │ │ │ │ │ - } │ │ │ │ │ + }); │ │ │ │ │ + return name; │ │ │ │ │ } │ │ │ │ │ - exports.ValueScopeName = ValueScopeName; │ │ │ │ │ - const line = (0, code_1._) `\n`; │ │ │ │ │ - class ValueScope extends Scope { │ │ │ │ │ - constructor(opts) { │ │ │ │ │ - super(opts); │ │ │ │ │ - this._values = {}; │ │ │ │ │ - this._scope = opts.scope; │ │ │ │ │ - this.opts = { │ │ │ │ │ - ...opts, │ │ │ │ │ - _n: opts.lines ? line : code_1.nil │ │ │ │ │ - }; │ │ │ │ │ - } │ │ │ │ │ - get() { │ │ │ │ │ - return this._scope; │ │ │ │ │ - } │ │ │ │ │ - name(prefix) { │ │ │ │ │ - return new ValueScopeName(prefix, this._newName(prefix)); │ │ │ │ │ - } │ │ │ │ │ - value(nameOrPrefix, value) { │ │ │ │ │ - var _a; │ │ │ │ │ - if (value.ref === undefined) │ │ │ │ │ - throw new Error("CodeGen: ref must be passed in value"); │ │ │ │ │ - const name = this.toName(nameOrPrefix); │ │ │ │ │ - const { │ │ │ │ │ - prefix │ │ │ │ │ - } = name; │ │ │ │ │ - const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref; │ │ │ │ │ - let vs = this._values[prefix]; │ │ │ │ │ - if (vs) { │ │ │ │ │ - const _name = vs.get(valueKey); │ │ │ │ │ - if (_name) │ │ │ │ │ - return _name; │ │ │ │ │ - } else { │ │ │ │ │ - vs = this._values[prefix] = new Map(); │ │ │ │ │ - } │ │ │ │ │ - vs.set(valueKey, name); │ │ │ │ │ - const s = this._scope[prefix] || (this._scope[prefix] = []); │ │ │ │ │ - const itemIndex = s.length; │ │ │ │ │ - s[itemIndex] = value.ref; │ │ │ │ │ - name.setValue(value, { │ │ │ │ │ - property: prefix, │ │ │ │ │ - itemIndex │ │ │ │ │ - }); │ │ │ │ │ - return name; │ │ │ │ │ - } │ │ │ │ │ - getValue(prefix, keyOrRef) { │ │ │ │ │ - const vs = this._values[prefix]; │ │ │ │ │ + getValue(prefix, keyOrRef) { │ │ │ │ │ + const vs = this._values[prefix]; │ │ │ │ │ + if (!vs) │ │ │ │ │ + return; │ │ │ │ │ + return vs.get(keyOrRef); │ │ │ │ │ + } │ │ │ │ │ + scopeRefs(scopeName, values = this._values) { │ │ │ │ │ + return this._reduceValues(values, (name) => { │ │ │ │ │ + if (name.scopePath === undefined) │ │ │ │ │ + throw new Error(`CodeGen: name "${name}" has no value`); │ │ │ │ │ + return (0, code_1._) `${scopeName}${name.scopePath}`; │ │ │ │ │ + }); │ │ │ │ │ + } │ │ │ │ │ + scopeCode(values = this._values, usedValues, getCode) { │ │ │ │ │ + return this._reduceValues(values, (name) => { │ │ │ │ │ + if (name.value === undefined) │ │ │ │ │ + throw new Error(`CodeGen: name "${name}" has no value`); │ │ │ │ │ + return name.value.code; │ │ │ │ │ + }, usedValues, getCode); │ │ │ │ │ + } │ │ │ │ │ + _reduceValues(values, valueCode, usedValues = {}, getCode) { │ │ │ │ │ + let code = code_1.nil; │ │ │ │ │ + for (const prefix in values) { │ │ │ │ │ + const vs = values[prefix]; │ │ │ │ │ if (!vs) │ │ │ │ │ - return; │ │ │ │ │ - return vs.get(keyOrRef); │ │ │ │ │ - } │ │ │ │ │ - scopeRefs(scopeName, values = this._values) { │ │ │ │ │ - return this._reduceValues(values, (name) => { │ │ │ │ │ - if (name.scopePath === undefined) │ │ │ │ │ - throw new Error(`CodeGen: name "${name}" has no value`); │ │ │ │ │ - return (0, code_1._) `${scopeName}${name.scopePath}`; │ │ │ │ │ + continue; │ │ │ │ │ + const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map()); │ │ │ │ │ + vs.forEach((name) => { │ │ │ │ │ + if (nameSet.has(name)) │ │ │ │ │ + return; │ │ │ │ │ + nameSet.set(name, UsedValueState.Started); │ │ │ │ │ + let c = valueCode(name); │ │ │ │ │ + if (c) { │ │ │ │ │ + const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const; │ │ │ │ │ + code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`; │ │ │ │ │ + } else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) { │ │ │ │ │ + code = (0, code_1._) `${code}${c}${this.opts._n}`; │ │ │ │ │ + } else { │ │ │ │ │ + throw new ValueError(name); │ │ │ │ │ + } │ │ │ │ │ + nameSet.set(name, UsedValueState.Completed); │ │ │ │ │ }); │ │ │ │ │ } │ │ │ │ │ - scopeCode(values = this._values, usedValues, getCode) { │ │ │ │ │ - return this._reduceValues(values, (name) => { │ │ │ │ │ - if (name.value === undefined) │ │ │ │ │ - throw new Error(`CodeGen: name "${name}" has no value`); │ │ │ │ │ - return name.value.code; │ │ │ │ │ - }, usedValues, getCode); │ │ │ │ │ - } │ │ │ │ │ - _reduceValues(values, valueCode, usedValues = {}, getCode) { │ │ │ │ │ - let code = code_1.nil; │ │ │ │ │ - for (const prefix in values) { │ │ │ │ │ - const vs = values[prefix]; │ │ │ │ │ - if (!vs) │ │ │ │ │ - continue; │ │ │ │ │ - const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map()); │ │ │ │ │ - vs.forEach((name) => { │ │ │ │ │ - if (nameSet.has(name)) │ │ │ │ │ - return; │ │ │ │ │ - nameSet.set(name, UsedValueState.Started); │ │ │ │ │ - let c = valueCode(name); │ │ │ │ │ - if (c) { │ │ │ │ │ - const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const; │ │ │ │ │ - code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`; │ │ │ │ │ - } else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) { │ │ │ │ │ - code = (0, code_1._) `${code}${c}${this.opts._n}`; │ │ │ │ │ - } else { │ │ │ │ │ - throw new ValueError(name); │ │ │ │ │ - } │ │ │ │ │ - nameSet.set(name, UsedValueState.Completed); │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ - return code; │ │ │ │ │ - } │ │ │ │ │ + return code; │ │ │ │ │ } │ │ │ │ │ - exports.ValueScope = ValueScope; │ │ │ │ │ - │ │ │ │ │ - }(scope)); │ │ │ │ │ - return scope; │ │ │ │ │ -} │ │ │ │ │ + } │ │ │ │ │ + exports.ValueScope = ValueScope; │ │ │ │ │ │ │ │ │ │ -var hasRequiredCodegen; │ │ │ │ │ +}(scope)); │ │ │ │ │ │ │ │ │ │ -function requireCodegen() { │ │ │ │ │ - if (hasRequiredCodegen) return codegen; │ │ │ │ │ - hasRequiredCodegen = 1; │ │ │ │ │ - (function(exports) { │ │ │ │ │ - Object.defineProperty(exports, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0; │ │ │ │ │ - const code_1 = requireCode$1(); │ │ │ │ │ - const scope_1 = requireScope(); │ │ │ │ │ - var code_2 = requireCode$1(); │ │ │ │ │ - Object.defineProperty(exports, "_", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2._; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "str", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.str; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "strConcat", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.strConcat; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "nil", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.nil; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "getProperty", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.getProperty; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "stringify", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.stringify; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "regexpCode", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.regexpCode; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "Name", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return code_2.Name; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - var scope_2 = requireScope(); │ │ │ │ │ - Object.defineProperty(exports, "Scope", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return scope_2.Scope; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "ValueScope", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return scope_2.ValueScope; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "ValueScopeName", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return scope_2.ValueScopeName; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - Object.defineProperty(exports, "varKinds", { │ │ │ │ │ - enumerable: true, │ │ │ │ │ - get: function() { │ │ │ │ │ - return scope_2.varKinds; │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - exports.operators = { │ │ │ │ │ - GT: new code_1._Code(">"), │ │ │ │ │ - GTE: new code_1._Code(">="), │ │ │ │ │ - LT: new code_1._Code("<"), │ │ │ │ │ - LTE: new code_1._Code("<="), │ │ │ │ │ - EQ: new code_1._Code("==="), │ │ │ │ │ - NEQ: new code_1._Code("!=="), │ │ │ │ │ - NOT: new code_1._Code("!"), │ │ │ │ │ - OR: new code_1._Code("||"), │ │ │ │ │ - AND: new code_1._Code("&&"), │ │ │ │ │ - ADD: new code_1._Code("+"), │ │ │ │ │ - }; │ │ │ │ │ - class Node { │ │ │ │ │ - optimizeNodes() { │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(_names, _constants) { │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ +(function(exports) { │ │ │ │ │ + Object.defineProperty(exports, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ + }); │ │ │ │ │ + exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0; │ │ │ │ │ + const code_1 = code$1; │ │ │ │ │ + const scope_1 = scope; │ │ │ │ │ + var code_2 = code$1; │ │ │ │ │ + Object.defineProperty(exports, "_", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2._; │ │ │ │ │ } │ │ │ │ │ - class Def extends Node { │ │ │ │ │ - constructor(varKind, name, rhs) { │ │ │ │ │ - super(); │ │ │ │ │ - this.varKind = varKind; │ │ │ │ │ - this.name = name; │ │ │ │ │ - this.rhs = rhs; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - es5, │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - const varKind = es5 ? scope_1.varKinds.var : this.varKind; │ │ │ │ │ - const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`; │ │ │ │ │ - return `${varKind} ${this.name}${rhs};` + _n; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - if (!names[this.name.str]) │ │ │ │ │ - return; │ │ │ │ │ - if (this.rhs) │ │ │ │ │ - this.rhs = optimizeExpr(this.rhs, names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {}; │ │ │ │ │ - } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "str", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.str; │ │ │ │ │ } │ │ │ │ │ - class Assign extends Node { │ │ │ │ │ - constructor(lhs, rhs, sideEffects) { │ │ │ │ │ - super(); │ │ │ │ │ - this.lhs = lhs; │ │ │ │ │ - this.rhs = rhs; │ │ │ │ │ - this.sideEffects = sideEffects; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - return `${this.lhs} = ${this.rhs};` + _n; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) │ │ │ │ │ - return; │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "strConcat", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.strConcat; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "nil", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.nil; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "getProperty", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.getProperty; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "stringify", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.stringify; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "regexpCode", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.regexpCode; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "Name", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return code_2.Name; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + var scope_2 = scope; │ │ │ │ │ + Object.defineProperty(exports, "Scope", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return scope_2.Scope; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "ValueScope", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return scope_2.ValueScope; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "ValueScopeName", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return scope_2.ValueScopeName; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + Object.defineProperty(exports, "varKinds", { │ │ │ │ │ + enumerable: true, │ │ │ │ │ + get: function() { │ │ │ │ │ + return scope_2.varKinds; │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ + exports.operators = { │ │ │ │ │ + GT: new code_1._Code(">"), │ │ │ │ │ + GTE: new code_1._Code(">="), │ │ │ │ │ + LT: new code_1._Code("<"), │ │ │ │ │ + LTE: new code_1._Code("<="), │ │ │ │ │ + EQ: new code_1._Code("==="), │ │ │ │ │ + NEQ: new code_1._Code("!=="), │ │ │ │ │ + NOT: new code_1._Code("!"), │ │ │ │ │ + OR: new code_1._Code("||"), │ │ │ │ │ + AND: new code_1._Code("&&"), │ │ │ │ │ + ADD: new code_1._Code("+"), │ │ │ │ │ + }; │ │ │ │ │ + class Node { │ │ │ │ │ + optimizeNodes() { │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + optimizeNames(_names, _constants) { │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Def extends Node { │ │ │ │ │ + constructor(varKind, name, rhs) { │ │ │ │ │ + super(); │ │ │ │ │ + this.varKind = varKind; │ │ │ │ │ + this.name = name; │ │ │ │ │ + this.rhs = rhs; │ │ │ │ │ + } │ │ │ │ │ + render({ │ │ │ │ │ + es5, │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + const varKind = es5 ? scope_1.varKinds.var : this.varKind; │ │ │ │ │ + const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`; │ │ │ │ │ + return `${varKind} ${this.name}${rhs};` + _n; │ │ │ │ │ + } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + if (!names[this.name.str]) │ │ │ │ │ + return; │ │ │ │ │ + if (this.rhs) │ │ │ │ │ this.rhs = optimizeExpr(this.rhs, names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - const names = this.lhs instanceof code_1.Name ? {} : { │ │ │ │ │ - ...this.lhs.names │ │ │ │ │ - }; │ │ │ │ │ - return addExprNames(names, this.rhs); │ │ │ │ │ - } │ │ │ │ │ + return this; │ │ │ │ │ } │ │ │ │ │ - class AssignOp extends Assign { │ │ │ │ │ - constructor(lhs, op, rhs, sideEffects) { │ │ │ │ │ - super(lhs, rhs, sideEffects); │ │ │ │ │ - this.op = op; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - return `${this.lhs} ${this.op}= ${this.rhs};` + _n; │ │ │ │ │ - } │ │ │ │ │ + get names() { │ │ │ │ │ + return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {}; │ │ │ │ │ } │ │ │ │ │ - class Label extends Node { │ │ │ │ │ - constructor(label) { │ │ │ │ │ - super(); │ │ │ │ │ - this.label = label; │ │ │ │ │ - this.names = {}; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - return `${this.label}:` + _n; │ │ │ │ │ - } │ │ │ │ │ + } │ │ │ │ │ + class Assign extends Node { │ │ │ │ │ + constructor(lhs, rhs, sideEffects) { │ │ │ │ │ + super(); │ │ │ │ │ + this.lhs = lhs; │ │ │ │ │ + this.rhs = rhs; │ │ │ │ │ + this.sideEffects = sideEffects; │ │ │ │ │ } │ │ │ │ │ - class Break extends Node { │ │ │ │ │ - constructor(label) { │ │ │ │ │ - super(); │ │ │ │ │ - this.label = label; │ │ │ │ │ - this.names = {}; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - const label = this.label ? ` ${this.label}` : ""; │ │ │ │ │ - return `break${label};` + _n; │ │ │ │ │ - } │ │ │ │ │ + render({ │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + return `${this.lhs} = ${this.rhs};` + _n; │ │ │ │ │ } │ │ │ │ │ - class Throw extends Node { │ │ │ │ │ - constructor(error) { │ │ │ │ │ - super(); │ │ │ │ │ - this.error = error; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - return `throw ${this.error};` + _n; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return this.error.names; │ │ │ │ │ - } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) │ │ │ │ │ + return; │ │ │ │ │ + this.rhs = optimizeExpr(this.rhs, names, constants); │ │ │ │ │ + return this; │ │ │ │ │ } │ │ │ │ │ - class AnyCode extends Node { │ │ │ │ │ - constructor(code) { │ │ │ │ │ - super(); │ │ │ │ │ - this.code = code; │ │ │ │ │ - } │ │ │ │ │ - render({ │ │ │ │ │ - _n │ │ │ │ │ - }) { │ │ │ │ │ - return `${this.code};` + _n; │ │ │ │ │ - } │ │ │ │ │ - optimizeNodes() { │ │ │ │ │ - return `${this.code}` ? this : undefined; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - this.code = optimizeExpr(this.code, names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return this.code instanceof code_1._CodeOrName ? this.code.names : {}; │ │ │ │ │ - } │ │ │ │ │ + get names() { │ │ │ │ │ + const names = this.lhs instanceof code_1.Name ? {} : { │ │ │ │ │ + ...this.lhs.names │ │ │ │ │ + }; │ │ │ │ │ + return addExprNames(names, this.rhs); │ │ │ │ │ } │ │ │ │ │ - class ParentNode extends Node { │ │ │ │ │ - constructor(nodes = []) { │ │ │ │ │ - super(); │ │ │ │ │ - this.nodes = nodes; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - return this.nodes.reduce((code, n) => code + n.render(opts), ""); │ │ │ │ │ - } │ │ │ │ │ - optimizeNodes() { │ │ │ │ │ - const { │ │ │ │ │ - nodes │ │ │ │ │ - } = this; │ │ │ │ │ - let i = nodes.length; │ │ │ │ │ - while (i--) { │ │ │ │ │ - const n = nodes[i].optimizeNodes(); │ │ │ │ │ - if (Array.isArray(n)) │ │ │ │ │ - nodes.splice(i, 1, ...n); │ │ │ │ │ - else if (n) │ │ │ │ │ - nodes[i] = n; │ │ │ │ │ - else │ │ │ │ │ - nodes.splice(i, 1); │ │ │ │ │ - } │ │ │ │ │ - return nodes.length > 0 ? this : undefined; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - const { │ │ │ │ │ - nodes │ │ │ │ │ - } = this; │ │ │ │ │ - let i = nodes.length; │ │ │ │ │ - while (i--) { │ │ │ │ │ - // iterating backwards improves 1-pass optimization │ │ │ │ │ - const n = nodes[i]; │ │ │ │ │ - if (n.optimizeNames(names, constants)) │ │ │ │ │ - continue; │ │ │ │ │ - subtractNames(names, n.names); │ │ │ │ │ + } │ │ │ │ │ + class AssignOp extends Assign { │ │ │ │ │ + constructor(lhs, op, rhs, sideEffects) { │ │ │ │ │ + super(lhs, rhs, sideEffects); │ │ │ │ │ + this.op = op; │ │ │ │ │ + } │ │ │ │ │ + render({ │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + return `${this.lhs} ${this.op}= ${this.rhs};` + _n; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Label extends Node { │ │ │ │ │ + constructor(label) { │ │ │ │ │ + super(); │ │ │ │ │ + this.label = label; │ │ │ │ │ + this.names = {}; │ │ │ │ │ + } │ │ │ │ │ + render({ │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + return `${this.label}:` + _n; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Break extends Node { │ │ │ │ │ + constructor(label) { │ │ │ │ │ + super(); │ │ │ │ │ + this.label = label; │ │ │ │ │ + this.names = {}; │ │ │ │ │ + } │ │ │ │ │ + render({ │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + const label = this.label ? ` ${this.label}` : ""; │ │ │ │ │ + return `break${label};` + _n; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Throw extends Node { │ │ │ │ │ + constructor(error) { │ │ │ │ │ + super(); │ │ │ │ │ + this.error = error; │ │ │ │ │ + } │ │ │ │ │ + render({ │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + return `throw ${this.error};` + _n; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + return this.error.names; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class AnyCode extends Node { │ │ │ │ │ + constructor(code) { │ │ │ │ │ + super(); │ │ │ │ │ + this.code = code; │ │ │ │ │ + } │ │ │ │ │ + render({ │ │ │ │ │ + _n │ │ │ │ │ + }) { │ │ │ │ │ + return `${this.code};` + _n; │ │ │ │ │ + } │ │ │ │ │ + optimizeNodes() { │ │ │ │ │ + return `${this.code}` ? this : undefined; │ │ │ │ │ + } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + this.code = optimizeExpr(this.code, names, constants); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + return this.code instanceof code_1._CodeOrName ? this.code.names : {}; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class ParentNode extends Node { │ │ │ │ │ + constructor(nodes = []) { │ │ │ │ │ + super(); │ │ │ │ │ + this.nodes = nodes; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + return this.nodes.reduce((code, n) => code + n.render(opts), ""); │ │ │ │ │ + } │ │ │ │ │ + optimizeNodes() { │ │ │ │ │ + const { │ │ │ │ │ + nodes │ │ │ │ │ + } = this; │ │ │ │ │ + let i = nodes.length; │ │ │ │ │ + while (i--) { │ │ │ │ │ + const n = nodes[i].optimizeNodes(); │ │ │ │ │ + if (Array.isArray(n)) │ │ │ │ │ + nodes.splice(i, 1, ...n); │ │ │ │ │ + else if (n) │ │ │ │ │ + nodes[i] = n; │ │ │ │ │ + else │ │ │ │ │ nodes.splice(i, 1); │ │ │ │ │ - } │ │ │ │ │ - return nodes.length > 0 ? this : undefined; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return this.nodes.reduce((names, n) => addNames(names, n.names), {}); │ │ │ │ │ } │ │ │ │ │ + return nodes.length > 0 ? this : undefined; │ │ │ │ │ } │ │ │ │ │ - class BlockNode extends ParentNode { │ │ │ │ │ - render(opts) { │ │ │ │ │ - return "{" + opts._n + super.render(opts) + "}" + opts._n; │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - class Root extends ParentNode {} │ │ │ │ │ - class Else extends BlockNode {} │ │ │ │ │ - Else.kind = "else"; │ │ │ │ │ - class If extends BlockNode { │ │ │ │ │ - constructor(condition, nodes) { │ │ │ │ │ - super(nodes); │ │ │ │ │ - this.condition = condition; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - let code = `if(${this.condition})` + super.render(opts); │ │ │ │ │ - if (this.else) │ │ │ │ │ - code += "else " + this.else.render(opts); │ │ │ │ │ - return code; │ │ │ │ │ - } │ │ │ │ │ - optimizeNodes() { │ │ │ │ │ - super.optimizeNodes(); │ │ │ │ │ - const cond = this.condition; │ │ │ │ │ - if (cond === true) │ │ │ │ │ - return this.nodes; // else is ignored here │ │ │ │ │ - let e = this.else; │ │ │ │ │ - if (e) { │ │ │ │ │ - const ns = e.optimizeNodes(); │ │ │ │ │ - e = this.else = Array.isArray(ns) ? new Else(ns) : ns; │ │ │ │ │ - } │ │ │ │ │ - if (e) { │ │ │ │ │ - if (cond === false) │ │ │ │ │ - return e instanceof If ? e : e.nodes; │ │ │ │ │ - if (this.nodes.length) │ │ │ │ │ - return this; │ │ │ │ │ - return new If(not(cond), e instanceof If ? [e] : e.nodes); │ │ │ │ │ - } │ │ │ │ │ - if (cond === false || !this.nodes.length) │ │ │ │ │ - return undefined; │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - var _a; │ │ │ │ │ - this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants); │ │ │ │ │ - if (!(super.optimizeNames(names, constants) || this.else)) │ │ │ │ │ - return; │ │ │ │ │ - this.condition = optimizeExpr(this.condition, names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - const names = super.names; │ │ │ │ │ - addExprNames(names, this.condition); │ │ │ │ │ - if (this.else) │ │ │ │ │ - addNames(names, this.else.names); │ │ │ │ │ - return names; │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + const { │ │ │ │ │ + nodes │ │ │ │ │ + } = this; │ │ │ │ │ + let i = nodes.length; │ │ │ │ │ + while (i--) { │ │ │ │ │ + // iterating backwards improves 1-pass optimization │ │ │ │ │ + const n = nodes[i]; │ │ │ │ │ + if (n.optimizeNames(names, constants)) │ │ │ │ │ + continue; │ │ │ │ │ + subtractNames(names, n.names); │ │ │ │ │ + nodes.splice(i, 1); │ │ │ │ │ + } │ │ │ │ │ + return nodes.length > 0 ? this : undefined; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + return this.nodes.reduce((names, n) => addNames(names, n.names), {}); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class BlockNode extends ParentNode { │ │ │ │ │ + render(opts) { │ │ │ │ │ + return "{" + opts._n + super.render(opts) + "}" + opts._n; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Root extends ParentNode {} │ │ │ │ │ + class Else extends BlockNode {} │ │ │ │ │ + Else.kind = "else"; │ │ │ │ │ + class If extends BlockNode { │ │ │ │ │ + constructor(condition, nodes) { │ │ │ │ │ + super(nodes); │ │ │ │ │ + this.condition = condition; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + let code = `if(${this.condition})` + super.render(opts); │ │ │ │ │ + if (this.else) │ │ │ │ │ + code += "else " + this.else.render(opts); │ │ │ │ │ + return code; │ │ │ │ │ + } │ │ │ │ │ + optimizeNodes() { │ │ │ │ │ + super.optimizeNodes(); │ │ │ │ │ + const cond = this.condition; │ │ │ │ │ + if (cond === true) │ │ │ │ │ + return this.nodes; // else is ignored here │ │ │ │ │ + let e = this.else; │ │ │ │ │ + if (e) { │ │ │ │ │ + const ns = e.optimizeNodes(); │ │ │ │ │ + e = this.else = Array.isArray(ns) ? new Else(ns) : ns; │ │ │ │ │ + } │ │ │ │ │ + if (e) { │ │ │ │ │ + if (cond === false) │ │ │ │ │ + return e instanceof If ? e : e.nodes; │ │ │ │ │ + if (this.nodes.length) │ │ │ │ │ + return this; │ │ │ │ │ + return new If(not(cond), e instanceof If ? [e] : e.nodes); │ │ │ │ │ } │ │ │ │ │ + if (cond === false || !this.nodes.length) │ │ │ │ │ + return undefined; │ │ │ │ │ + return this; │ │ │ │ │ } │ │ │ │ │ - If.kind = "if"; │ │ │ │ │ - class For extends BlockNode {} │ │ │ │ │ - For.kind = "for"; │ │ │ │ │ - class ForLoop extends For { │ │ │ │ │ - constructor(iteration) { │ │ │ │ │ - super(); │ │ │ │ │ - this.iteration = iteration; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - return `for(${this.iteration})` + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - if (!super.optimizeNames(names, constants)) │ │ │ │ │ - return; │ │ │ │ │ - this.iteration = optimizeExpr(this.iteration, names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return addNames(super.names, this.iteration.names); │ │ │ │ │ - } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + var _a; │ │ │ │ │ + this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants); │ │ │ │ │ + if (!(super.optimizeNames(names, constants) || this.else)) │ │ │ │ │ + return; │ │ │ │ │ + this.condition = optimizeExpr(this.condition, names, constants); │ │ │ │ │ + return this; │ │ │ │ │ } │ │ │ │ │ - class ForRange extends For { │ │ │ │ │ - constructor(varKind, name, from, to) { │ │ │ │ │ - super(); │ │ │ │ │ - this.varKind = varKind; │ │ │ │ │ - this.name = name; │ │ │ │ │ - this.from = from; │ │ │ │ │ - this.to = to; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind; │ │ │ │ │ - const { │ │ │ │ │ - name, │ │ │ │ │ - from, │ │ │ │ │ - to │ │ │ │ │ - } = this; │ │ │ │ │ - return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - const names = addExprNames(super.names, this.from); │ │ │ │ │ - return addExprNames(names, this.to); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - class ForIter extends For { │ │ │ │ │ - constructor(loop, varKind, name, iterable) { │ │ │ │ │ - super(); │ │ │ │ │ - this.loop = loop; │ │ │ │ │ - this.varKind = varKind; │ │ │ │ │ - this.name = name; │ │ │ │ │ - this.iterable = iterable; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - if (!super.optimizeNames(names, constants)) │ │ │ │ │ - return; │ │ │ │ │ - this.iterable = optimizeExpr(this.iterable, names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - return addNames(super.names, this.iterable.names); │ │ │ │ │ - } │ │ │ │ │ + get names() { │ │ │ │ │ + const names = super.names; │ │ │ │ │ + addExprNames(names, this.condition); │ │ │ │ │ + if (this.else) │ │ │ │ │ + addNames(names, this.else.names); │ │ │ │ │ + return names; │ │ │ │ │ } │ │ │ │ │ - class Func extends BlockNode { │ │ │ │ │ - constructor(name, args, async) { │ │ │ │ │ - super(); │ │ │ │ │ - this.name = name; │ │ │ │ │ - this.args = args; │ │ │ │ │ - this.async = async; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - const _async = this.async ? "async " : ""; │ │ │ │ │ - return `${_async}function ${this.name}(${this.args})` + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - Func.kind = "func"; │ │ │ │ │ - class Return extends ParentNode { │ │ │ │ │ - render(opts) { │ │ │ │ │ - return "return " + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - Return.kind = "return"; │ │ │ │ │ - class Try extends BlockNode { │ │ │ │ │ - render(opts) { │ │ │ │ │ - let code = "try" + super.render(opts); │ │ │ │ │ - if (this.catch) │ │ │ │ │ - code += this.catch.render(opts); │ │ │ │ │ - if (this.finally) │ │ │ │ │ - code += this.finally.render(opts); │ │ │ │ │ - return code; │ │ │ │ │ - } │ │ │ │ │ - optimizeNodes() { │ │ │ │ │ - var _a, _b; │ │ │ │ │ - super.optimizeNodes(); │ │ │ │ │ - (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes(); │ │ │ │ │ - (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes(); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - optimizeNames(names, constants) { │ │ │ │ │ - var _a, _b; │ │ │ │ │ - super.optimizeNames(names, constants); │ │ │ │ │ - (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants); │ │ │ │ │ - (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - get names() { │ │ │ │ │ - const names = super.names; │ │ │ │ │ - if (this.catch) │ │ │ │ │ - addNames(names, this.catch.names); │ │ │ │ │ - if (this.finally) │ │ │ │ │ - addNames(names, this.finally.names); │ │ │ │ │ - return names; │ │ │ │ │ + } │ │ │ │ │ + If.kind = "if"; │ │ │ │ │ + class For extends BlockNode {} │ │ │ │ │ + For.kind = "for"; │ │ │ │ │ + class ForLoop extends For { │ │ │ │ │ + constructor(iteration) { │ │ │ │ │ + super(); │ │ │ │ │ + this.iteration = iteration; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + return `for(${this.iteration})` + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + if (!super.optimizeNames(names, constants)) │ │ │ │ │ + return; │ │ │ │ │ + this.iteration = optimizeExpr(this.iteration, names, constants); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + return addNames(super.names, this.iteration.names); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class ForRange extends For { │ │ │ │ │ + constructor(varKind, name, from, to) { │ │ │ │ │ + super(); │ │ │ │ │ + this.varKind = varKind; │ │ │ │ │ + this.name = name; │ │ │ │ │ + this.from = from; │ │ │ │ │ + this.to = to; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind; │ │ │ │ │ + const { │ │ │ │ │ + name, │ │ │ │ │ + from, │ │ │ │ │ + to │ │ │ │ │ + } = this; │ │ │ │ │ + return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + const names = addExprNames(super.names, this.from); │ │ │ │ │ + return addExprNames(names, this.to); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class ForIter extends For { │ │ │ │ │ + constructor(loop, varKind, name, iterable) { │ │ │ │ │ + super(); │ │ │ │ │ + this.loop = loop; │ │ │ │ │ + this.varKind = varKind; │ │ │ │ │ + this.name = name; │ │ │ │ │ + this.iterable = iterable; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + if (!super.optimizeNames(names, constants)) │ │ │ │ │ + return; │ │ │ │ │ + this.iterable = optimizeExpr(this.iterable, names, constants); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + return addNames(super.names, this.iterable.names); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Func extends BlockNode { │ │ │ │ │ + constructor(name, args, async) { │ │ │ │ │ + super(); │ │ │ │ │ + this.name = name; │ │ │ │ │ + this.args = args; │ │ │ │ │ + this.async = async; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + const _async = this.async ? "async " : ""; │ │ │ │ │ + return `${_async}function ${this.name}(${this.args})` + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + Func.kind = "func"; │ │ │ │ │ + class Return extends ParentNode { │ │ │ │ │ + render(opts) { │ │ │ │ │ + return "return " + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + Return.kind = "return"; │ │ │ │ │ + class Try extends BlockNode { │ │ │ │ │ + render(opts) { │ │ │ │ │ + let code = "try" + super.render(opts); │ │ │ │ │ + if (this.catch) │ │ │ │ │ + code += this.catch.render(opts); │ │ │ │ │ + if (this.finally) │ │ │ │ │ + code += this.finally.render(opts); │ │ │ │ │ + return code; │ │ │ │ │ + } │ │ │ │ │ + optimizeNodes() { │ │ │ │ │ + var _a, _b; │ │ │ │ │ + super.optimizeNodes(); │ │ │ │ │ + (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes(); │ │ │ │ │ + (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes(); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + optimizeNames(names, constants) { │ │ │ │ │ + var _a, _b; │ │ │ │ │ + super.optimizeNames(names, constants); │ │ │ │ │ + (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants); │ │ │ │ │ + (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + get names() { │ │ │ │ │ + const names = super.names; │ │ │ │ │ + if (this.catch) │ │ │ │ │ + addNames(names, this.catch.names); │ │ │ │ │ + if (this.finally) │ │ │ │ │ + addNames(names, this.finally.names); │ │ │ │ │ + return names; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + class Catch extends BlockNode { │ │ │ │ │ + constructor(error) { │ │ │ │ │ + super(); │ │ │ │ │ + this.error = error; │ │ │ │ │ + } │ │ │ │ │ + render(opts) { │ │ │ │ │ + return `catch(${this.error})` + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + Catch.kind = "catch"; │ │ │ │ │ + class Finally extends BlockNode { │ │ │ │ │ + render(opts) { │ │ │ │ │ + return "finally" + super.render(opts); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + Finally.kind = "finally"; │ │ │ │ │ + class CodeGen { │ │ │ │ │ + constructor(extScope, opts = {}) { │ │ │ │ │ + this._values = {}; │ │ │ │ │ + this._blockStarts = []; │ │ │ │ │ + this._constants = {}; │ │ │ │ │ + this.opts = { │ │ │ │ │ + ...opts, │ │ │ │ │ + _n: opts.lines ? "\n" : "" │ │ │ │ │ + }; │ │ │ │ │ + this._extScope = extScope; │ │ │ │ │ + this._scope = new scope_1.Scope({ │ │ │ │ │ + parent: extScope │ │ │ │ │ + }); │ │ │ │ │ + this._nodes = [new Root()]; │ │ │ │ │ + } │ │ │ │ │ + toString() { │ │ │ │ │ + return this._root.render(this.opts); │ │ │ │ │ + } │ │ │ │ │ + // returns unique name in the internal scope │ │ │ │ │ + name(prefix) { │ │ │ │ │ + return this._scope.name(prefix); │ │ │ │ │ + } │ │ │ │ │ + // reserves unique name in the external scope │ │ │ │ │ + scopeName(prefix) { │ │ │ │ │ + return this._extScope.name(prefix); │ │ │ │ │ + } │ │ │ │ │ + // reserves unique name in the external scope and assigns value to it │ │ │ │ │ + scopeValue(prefixOrName, value) { │ │ │ │ │ + const name = this._extScope.value(prefixOrName, value); │ │ │ │ │ + const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set()); │ │ │ │ │ + vs.add(name); │ │ │ │ │ + return name; │ │ │ │ │ + } │ │ │ │ │ + getScopeValue(prefix, keyOrRef) { │ │ │ │ │ + return this._extScope.getValue(prefix, keyOrRef); │ │ │ │ │ + } │ │ │ │ │ + // return code that assigns values in the external scope to the names that are used internally │ │ │ │ │ + // (same names that were returned by gen.scopeName or gen.scopeValue) │ │ │ │ │ + scopeRefs(scopeName) { │ │ │ │ │ + return this._extScope.scopeRefs(scopeName, this._values); │ │ │ │ │ + } │ │ │ │ │ + scopeCode() { │ │ │ │ │ + return this._extScope.scopeCode(this._values); │ │ │ │ │ + } │ │ │ │ │ + _def(varKind, nameOrPrefix, rhs, constant) { │ │ │ │ │ + const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ + if (rhs !== undefined && constant) │ │ │ │ │ + this._constants[name.str] = rhs; │ │ │ │ │ + this._leafNode(new Def(varKind, name, rhs)); │ │ │ │ │ + return name; │ │ │ │ │ + } │ │ │ │ │ + // `const` declaration (`var` in es5 mode) │ │ │ │ │ + const (nameOrPrefix, rhs, _constant) { │ │ │ │ │ + return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant); │ │ │ │ │ + } │ │ │ │ │ + // `let` declaration with optional assignment (`var` in es5 mode) │ │ │ │ │ + let (nameOrPrefix, rhs, _constant) { │ │ │ │ │ + return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant); │ │ │ │ │ + } │ │ │ │ │ + // `var` declaration with optional assignment │ │ │ │ │ + var (nameOrPrefix, rhs, _constant) { │ │ │ │ │ + return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant); │ │ │ │ │ + } │ │ │ │ │ + // assignment code │ │ │ │ │ + assign(lhs, rhs, sideEffects) { │ │ │ │ │ + return this._leafNode(new Assign(lhs, rhs, sideEffects)); │ │ │ │ │ + } │ │ │ │ │ + // `+=` code │ │ │ │ │ + add(lhs, rhs) { │ │ │ │ │ + return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs)); │ │ │ │ │ + } │ │ │ │ │ + // appends passed SafeExpr to code or executes Block │ │ │ │ │ + code(c) { │ │ │ │ │ + if (typeof c == "function") │ │ │ │ │ + c(); │ │ │ │ │ + else if (c !== code_1.nil) │ │ │ │ │ + this._leafNode(new AnyCode(c)); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + // returns code for object literal for the passed argument list of key-value pairs │ │ │ │ │ + object(...keyValues) { │ │ │ │ │ + const code = ["{"]; │ │ │ │ │ + for (const [key, value] of keyValues) { │ │ │ │ │ + if (code.length > 1) │ │ │ │ │ + code.push(","); │ │ │ │ │ + code.push(key); │ │ │ │ │ + if (key !== value || this.opts.es5) { │ │ │ │ │ + code.push(":"); │ │ │ │ │ + (0, code_1.addCodeArg)(code, value); │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + code.push("}"); │ │ │ │ │ + return new code_1._Code(code); │ │ │ │ │ + } │ │ │ │ │ + // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) │ │ │ │ │ + if (condition, thenBody, elseBody) { │ │ │ │ │ + this._blockNode(new If(condition)); │ │ │ │ │ + if (thenBody && elseBody) { │ │ │ │ │ + this.code(thenBody).else().code(elseBody).endIf(); │ │ │ │ │ + } else if (thenBody) { │ │ │ │ │ + this.code(thenBody).endIf(); │ │ │ │ │ + } else if (elseBody) { │ │ │ │ │ + throw new Error('CodeGen: "else" body without "then" body'); │ │ │ │ │ } │ │ │ │ │ + return this; │ │ │ │ │ } │ │ │ │ │ - class Catch extends BlockNode { │ │ │ │ │ - constructor(error) { │ │ │ │ │ - super(); │ │ │ │ │ - this.error = error; │ │ │ │ │ - } │ │ │ │ │ - render(opts) { │ │ │ │ │ - return `catch(${this.error})` + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - Catch.kind = "catch"; │ │ │ │ │ - class Finally extends BlockNode { │ │ │ │ │ - render(opts) { │ │ │ │ │ - return "finally" + super.render(opts); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - Finally.kind = "finally"; │ │ │ │ │ - class CodeGen { │ │ │ │ │ - constructor(extScope, opts = {}) { │ │ │ │ │ - this._values = {}; │ │ │ │ │ - this._blockStarts = []; │ │ │ │ │ - this._constants = {}; │ │ │ │ │ - this.opts = { │ │ │ │ │ - ...opts, │ │ │ │ │ - _n: opts.lines ? "\n" : "" │ │ │ │ │ - }; │ │ │ │ │ - this._extScope = extScope; │ │ │ │ │ - this._scope = new scope_1.Scope({ │ │ │ │ │ - parent: extScope │ │ │ │ │ + // `else if` clause - invalid without `if` or after `else` clauses │ │ │ │ │ + elseIf(condition) { │ │ │ │ │ + return this._elseNode(new If(condition)); │ │ │ │ │ + } │ │ │ │ │ + // `else` clause - only valid after `if` or `else if` clauses │ │ │ │ │ + else() { │ │ │ │ │ + return this._elseNode(new Else()); │ │ │ │ │ + } │ │ │ │ │ + // end `if` statement (needed if gen.if was used only with condition) │ │ │ │ │ + endIf() { │ │ │ │ │ + return this._endBlockNode(If, Else); │ │ │ │ │ + } │ │ │ │ │ + _for(node, forBody) { │ │ │ │ │ + this._blockNode(node); │ │ │ │ │ + if (forBody) │ │ │ │ │ + this.code(forBody).endFor(); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + // a generic `for` clause (or statement if `forBody` is passed) │ │ │ │ │ + for (iteration, forBody) { │ │ │ │ │ + return this._for(new ForLoop(iteration), forBody); │ │ │ │ │ + } │ │ │ │ │ + // `for` statement for a range of values │ │ │ │ │ + forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) { │ │ │ │ │ + const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ + return this._for(new ForRange(varKind, name, from, to), () => forBody(name)); │ │ │ │ │ + } │ │ │ │ │ + // `for-of` statement (in es5 mode replace with a normal for loop) │ │ │ │ │ + forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) { │ │ │ │ │ + const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ + if (this.opts.es5) { │ │ │ │ │ + const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable); │ │ │ │ │ + return this.forRange("_i", 0, (0, code_1._) `${arr}.length`, (i) => { │ │ │ │ │ + this.var(name, (0, code_1._) `${arr}[${i}]`); │ │ │ │ │ + forBody(name); │ │ │ │ │ }); │ │ │ │ │ - this._nodes = [new Root()]; │ │ │ │ │ } │ │ │ │ │ - toString() { │ │ │ │ │ - return this._root.render(this.opts); │ │ │ │ │ - } │ │ │ │ │ - // returns unique name in the internal scope │ │ │ │ │ - name(prefix) { │ │ │ │ │ - return this._scope.name(prefix); │ │ │ │ │ - } │ │ │ │ │ - // reserves unique name in the external scope │ │ │ │ │ - scopeName(prefix) { │ │ │ │ │ - return this._extScope.name(prefix); │ │ │ │ │ - } │ │ │ │ │ - // reserves unique name in the external scope and assigns value to it │ │ │ │ │ - scopeValue(prefixOrName, value) { │ │ │ │ │ - const name = this._extScope.value(prefixOrName, value); │ │ │ │ │ - const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set()); │ │ │ │ │ - vs.add(name); │ │ │ │ │ - return name; │ │ │ │ │ - } │ │ │ │ │ - getScopeValue(prefix, keyOrRef) { │ │ │ │ │ - return this._extScope.getValue(prefix, keyOrRef); │ │ │ │ │ - } │ │ │ │ │ - // return code that assigns values in the external scope to the names that are used internally │ │ │ │ │ - // (same names that were returned by gen.scopeName or gen.scopeValue) │ │ │ │ │ - scopeRefs(scopeName) { │ │ │ │ │ - return this._extScope.scopeRefs(scopeName, this._values); │ │ │ │ │ - } │ │ │ │ │ - scopeCode() { │ │ │ │ │ - return this._extScope.scopeCode(this._values); │ │ │ │ │ - } │ │ │ │ │ - _def(varKind, nameOrPrefix, rhs, constant) { │ │ │ │ │ - const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ - if (rhs !== undefined && constant) │ │ │ │ │ - this._constants[name.str] = rhs; │ │ │ │ │ - this._leafNode(new Def(varKind, name, rhs)); │ │ │ │ │ - return name; │ │ │ │ │ - } │ │ │ │ │ - // `const` declaration (`var` in es5 mode) │ │ │ │ │ - const (nameOrPrefix, rhs, _constant) { │ │ │ │ │ - return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant); │ │ │ │ │ - } │ │ │ │ │ - // `let` declaration with optional assignment (`var` in es5 mode) │ │ │ │ │ - let (nameOrPrefix, rhs, _constant) { │ │ │ │ │ - return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant); │ │ │ │ │ - } │ │ │ │ │ - // `var` declaration with optional assignment │ │ │ │ │ - var (nameOrPrefix, rhs, _constant) { │ │ │ │ │ - return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant); │ │ │ │ │ - } │ │ │ │ │ - // assignment code │ │ │ │ │ - assign(lhs, rhs, sideEffects) { │ │ │ │ │ - return this._leafNode(new Assign(lhs, rhs, sideEffects)); │ │ │ │ │ - } │ │ │ │ │ - // `+=` code │ │ │ │ │ - add(lhs, rhs) { │ │ │ │ │ - return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs)); │ │ │ │ │ - } │ │ │ │ │ - // appends passed SafeExpr to code or executes Block │ │ │ │ │ - code(c) { │ │ │ │ │ - if (typeof c == "function") │ │ │ │ │ - c(); │ │ │ │ │ - else if (c !== code_1.nil) │ │ │ │ │ - this._leafNode(new AnyCode(c)); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - // returns code for object literal for the passed argument list of key-value pairs │ │ │ │ │ - object(...keyValues) { │ │ │ │ │ - const code = ["{"]; │ │ │ │ │ - for (const [key, value] of keyValues) { │ │ │ │ │ - if (code.length > 1) │ │ │ │ │ - code.push(","); │ │ │ │ │ - code.push(key); │ │ │ │ │ - if (key !== value || this.opts.es5) { │ │ │ │ │ - code.push(":"); │ │ │ │ │ - (0, code_1.addCodeArg)(code, value); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - code.push("}"); │ │ │ │ │ - return new code_1._Code(code); │ │ │ │ │ - } │ │ │ │ │ - // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) │ │ │ │ │ - if (condition, thenBody, elseBody) { │ │ │ │ │ - this._blockNode(new If(condition)); │ │ │ │ │ - if (thenBody && elseBody) { │ │ │ │ │ - this.code(thenBody).else().code(elseBody).endIf(); │ │ │ │ │ - } else if (thenBody) { │ │ │ │ │ - this.code(thenBody).endIf(); │ │ │ │ │ - } else if (elseBody) { │ │ │ │ │ - throw new Error('CodeGen: "else" body without "then" body'); │ │ │ │ │ - } │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - // `else if` clause - invalid without `if` or after `else` clauses │ │ │ │ │ - elseIf(condition) { │ │ │ │ │ - return this._elseNode(new If(condition)); │ │ │ │ │ - } │ │ │ │ │ - // `else` clause - only valid after `if` or `else if` clauses │ │ │ │ │ - else() { │ │ │ │ │ - return this._elseNode(new Else()); │ │ │ │ │ - } │ │ │ │ │ - // end `if` statement (needed if gen.if was used only with condition) │ │ │ │ │ - endIf() { │ │ │ │ │ - return this._endBlockNode(If, Else); │ │ │ │ │ - } │ │ │ │ │ - _for(node, forBody) { │ │ │ │ │ - this._blockNode(node); │ │ │ │ │ - if (forBody) │ │ │ │ │ - this.code(forBody).endFor(); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - // a generic `for` clause (or statement if `forBody` is passed) │ │ │ │ │ - for (iteration, forBody) { │ │ │ │ │ - return this._for(new ForLoop(iteration), forBody); │ │ │ │ │ - } │ │ │ │ │ - // `for` statement for a range of values │ │ │ │ │ - forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) { │ │ │ │ │ - const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ - return this._for(new ForRange(varKind, name, from, to), () => forBody(name)); │ │ │ │ │ - } │ │ │ │ │ - // `for-of` statement (in es5 mode replace with a normal for loop) │ │ │ │ │ - forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) { │ │ │ │ │ - const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ - if (this.opts.es5) { │ │ │ │ │ - const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable); │ │ │ │ │ - return this.forRange("_i", 0, (0, code_1._) `${arr}.length`, (i) => { │ │ │ │ │ - this.var(name, (0, code_1._) `${arr}[${i}]`); │ │ │ │ │ - forBody(name); │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ - return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)); │ │ │ │ │ - } │ │ │ │ │ - // `for-in` statement. │ │ │ │ │ - // With option `ownProperties` replaced with a `for-of` loop for object keys │ │ │ │ │ - forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) { │ │ │ │ │ - if (this.opts.ownProperties) { │ │ │ │ │ - return this.forOf(nameOrPrefix, (0, code_1._) `Object.keys(${obj})`, forBody); │ │ │ │ │ - } │ │ │ │ │ - const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ - return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)); │ │ │ │ │ - } │ │ │ │ │ - // end `for` loop │ │ │ │ │ - endFor() { │ │ │ │ │ - return this._endBlockNode(For); │ │ │ │ │ - } │ │ │ │ │ - // `label` statement │ │ │ │ │ - label(label) { │ │ │ │ │ - return this._leafNode(new Label(label)); │ │ │ │ │ - } │ │ │ │ │ - // `break` statement │ │ │ │ │ - break (label) { │ │ │ │ │ - return this._leafNode(new Break(label)); │ │ │ │ │ - } │ │ │ │ │ - // `return` statement │ │ │ │ │ - return (value) { │ │ │ │ │ - const node = new Return(); │ │ │ │ │ - this._blockNode(node); │ │ │ │ │ - this.code(value); │ │ │ │ │ - if (node.nodes.length !== 1) │ │ │ │ │ - throw new Error('CodeGen: "return" should have one node'); │ │ │ │ │ - return this._endBlockNode(Return); │ │ │ │ │ - } │ │ │ │ │ - // `try` statement │ │ │ │ │ - try (tryBody, catchCode, finallyCode) { │ │ │ │ │ - if (!catchCode && !finallyCode) │ │ │ │ │ - throw new Error('CodeGen: "try" without "catch" and "finally"'); │ │ │ │ │ - const node = new Try(); │ │ │ │ │ - this._blockNode(node); │ │ │ │ │ - this.code(tryBody); │ │ │ │ │ - if (catchCode) { │ │ │ │ │ - const error = this.name("e"); │ │ │ │ │ - this._currNode = node.catch = new Catch(error); │ │ │ │ │ - catchCode(error); │ │ │ │ │ - } │ │ │ │ │ - if (finallyCode) { │ │ │ │ │ - this._currNode = node.finally = new Finally(); │ │ │ │ │ - this.code(finallyCode); │ │ │ │ │ - } │ │ │ │ │ - return this._endBlockNode(Catch, Finally); │ │ │ │ │ - } │ │ │ │ │ - // `throw` statement │ │ │ │ │ - throw (error) { │ │ │ │ │ - return this._leafNode(new Throw(error)); │ │ │ │ │ - } │ │ │ │ │ - // start self-balancing block │ │ │ │ │ - block(body, nodeCount) { │ │ │ │ │ - this._blockStarts.push(this._nodes.length); │ │ │ │ │ - if (body) │ │ │ │ │ - this.code(body).endBlock(nodeCount); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - // end the current self-balancing block │ │ │ │ │ - endBlock(nodeCount) { │ │ │ │ │ - const len = this._blockStarts.pop(); │ │ │ │ │ - if (len === undefined) │ │ │ │ │ - throw new Error("CodeGen: not in self-balancing block"); │ │ │ │ │ - const toClose = this._nodes.length - len; │ │ │ │ │ - if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) { │ │ │ │ │ - throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`); │ │ │ │ │ - } │ │ │ │ │ - this._nodes.length = len; │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - // `function` heading (or definition if funcBody is passed) │ │ │ │ │ - func(name, args = code_1.nil, async, funcBody) { │ │ │ │ │ - this._blockNode(new Func(name, args, async)); │ │ │ │ │ - if (funcBody) │ │ │ │ │ - this.code(funcBody).endFunc(); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - // end function definition │ │ │ │ │ - endFunc() { │ │ │ │ │ - return this._endBlockNode(Func); │ │ │ │ │ - } │ │ │ │ │ - optimize(n = 1) { │ │ │ │ │ - while (n-- > 0) { │ │ │ │ │ - this._root.optimizeNodes(); │ │ │ │ │ - this._root.optimizeNames(this._root.names, this._constants); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - _leafNode(node) { │ │ │ │ │ - this._currNode.nodes.push(node); │ │ │ │ │ - return this; │ │ │ │ │ + return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)); │ │ │ │ │ + } │ │ │ │ │ + // `for-in` statement. │ │ │ │ │ + // With option `ownProperties` replaced with a `for-of` loop for object keys │ │ │ │ │ + forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) { │ │ │ │ │ + if (this.opts.ownProperties) { │ │ │ │ │ + return this.forOf(nameOrPrefix, (0, code_1._) `Object.keys(${obj})`, forBody); │ │ │ │ │ + } │ │ │ │ │ + const name = this._scope.toName(nameOrPrefix); │ │ │ │ │ + return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)); │ │ │ │ │ + } │ │ │ │ │ + // end `for` loop │ │ │ │ │ + endFor() { │ │ │ │ │ + return this._endBlockNode(For); │ │ │ │ │ + } │ │ │ │ │ + // `label` statement │ │ │ │ │ + label(label) { │ │ │ │ │ + return this._leafNode(new Label(label)); │ │ │ │ │ + } │ │ │ │ │ + // `break` statement │ │ │ │ │ + break (label) { │ │ │ │ │ + return this._leafNode(new Break(label)); │ │ │ │ │ + } │ │ │ │ │ + // `return` statement │ │ │ │ │ + return (value) { │ │ │ │ │ + const node = new Return(); │ │ │ │ │ + this._blockNode(node); │ │ │ │ │ + this.code(value); │ │ │ │ │ + if (node.nodes.length !== 1) │ │ │ │ │ + throw new Error('CodeGen: "return" should have one node'); │ │ │ │ │ + return this._endBlockNode(Return); │ │ │ │ │ + } │ │ │ │ │ + // `try` statement │ │ │ │ │ + try (tryBody, catchCode, finallyCode) { │ │ │ │ │ + if (!catchCode && !finallyCode) │ │ │ │ │ + throw new Error('CodeGen: "try" without "catch" and "finally"'); │ │ │ │ │ + const node = new Try(); │ │ │ │ │ + this._blockNode(node); │ │ │ │ │ + this.code(tryBody); │ │ │ │ │ + if (catchCode) { │ │ │ │ │ + const error = this.name("e"); │ │ │ │ │ + this._currNode = node.catch = new Catch(error); │ │ │ │ │ + catchCode(error); │ │ │ │ │ + } │ │ │ │ │ + if (finallyCode) { │ │ │ │ │ + this._currNode = node.finally = new Finally(); │ │ │ │ │ + this.code(finallyCode); │ │ │ │ │ + } │ │ │ │ │ + return this._endBlockNode(Catch, Finally); │ │ │ │ │ + } │ │ │ │ │ + // `throw` statement │ │ │ │ │ + throw (error) { │ │ │ │ │ + return this._leafNode(new Throw(error)); │ │ │ │ │ + } │ │ │ │ │ + // start self-balancing block │ │ │ │ │ + block(body, nodeCount) { │ │ │ │ │ + this._blockStarts.push(this._nodes.length); │ │ │ │ │ + if (body) │ │ │ │ │ + this.code(body).endBlock(nodeCount); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + // end the current self-balancing block │ │ │ │ │ + endBlock(nodeCount) { │ │ │ │ │ + const len = this._blockStarts.pop(); │ │ │ │ │ + if (len === undefined) │ │ │ │ │ + throw new Error("CodeGen: not in self-balancing block"); │ │ │ │ │ + const toClose = this._nodes.length - len; │ │ │ │ │ + if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) { │ │ │ │ │ + throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`); │ │ │ │ │ } │ │ │ │ │ - _blockNode(node) { │ │ │ │ │ - this._currNode.nodes.push(node); │ │ │ │ │ - this._nodes.push(node); │ │ │ │ │ - } │ │ │ │ │ - _endBlockNode(N1, N2) { │ │ │ │ │ - const n = this._currNode; │ │ │ │ │ - if (n instanceof N1 || (N2 && n instanceof N2)) { │ │ │ │ │ - this._nodes.pop(); │ │ │ │ │ - return this; │ │ │ │ │ - } │ │ │ │ │ - throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`); │ │ │ │ │ + this._nodes.length = len; │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + // `function` heading (or definition if funcBody is passed) │ │ │ │ │ + func(name, args = code_1.nil, async, funcBody) { │ │ │ │ │ + this._blockNode(new Func(name, args, async)); │ │ │ │ │ + if (funcBody) │ │ │ │ │ + this.code(funcBody).endFunc(); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + // end function definition │ │ │ │ │ + endFunc() { │ │ │ │ │ + return this._endBlockNode(Func); │ │ │ │ │ + } │ │ │ │ │ + optimize(n = 1) { │ │ │ │ │ + while (n-- > 0) { │ │ │ │ │ + this._root.optimizeNodes(); │ │ │ │ │ + this._root.optimizeNames(this._root.names, this._constants); │ │ │ │ │ } │ │ │ │ │ - _elseNode(node) { │ │ │ │ │ - const n = this._currNode; │ │ │ │ │ - if (!(n instanceof If)) { │ │ │ │ │ - throw new Error('CodeGen: "else" without "if"'); │ │ │ │ │ - } │ │ │ │ │ - this._currNode = n.else = node; │ │ │ │ │ + } │ │ │ │ │ + _leafNode(node) { │ │ │ │ │ + this._currNode.nodes.push(node); │ │ │ │ │ + return this; │ │ │ │ │ + } │ │ │ │ │ + _blockNode(node) { │ │ │ │ │ + this._currNode.nodes.push(node); │ │ │ │ │ + this._nodes.push(node); │ │ │ │ │ + } │ │ │ │ │ + _endBlockNode(N1, N2) { │ │ │ │ │ + const n = this._currNode; │ │ │ │ │ + if (n instanceof N1 || (N2 && n instanceof N2)) { │ │ │ │ │ + this._nodes.pop(); │ │ │ │ │ return this; │ │ │ │ │ } │ │ │ │ │ - get _root() { │ │ │ │ │ - return this._nodes[0]; │ │ │ │ │ - } │ │ │ │ │ - get _currNode() { │ │ │ │ │ - const ns = this._nodes; │ │ │ │ │ - return ns[ns.length - 1]; │ │ │ │ │ - } │ │ │ │ │ - set _currNode(node) { │ │ │ │ │ - const ns = this._nodes; │ │ │ │ │ - ns[ns.length - 1] = node; │ │ │ │ │ + throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`); │ │ │ │ │ + } │ │ │ │ │ + _elseNode(node) { │ │ │ │ │ + const n = this._currNode; │ │ │ │ │ + if (!(n instanceof If)) { │ │ │ │ │ + throw new Error('CodeGen: "else" without "if"'); │ │ │ │ │ } │ │ │ │ │ + this._currNode = n.else = node; │ │ │ │ │ + return this; │ │ │ │ │ } │ │ │ │ │ - exports.CodeGen = CodeGen; │ │ │ │ │ - │ │ │ │ │ - function addNames(names, from) { │ │ │ │ │ - for (const n in from) │ │ │ │ │ - names[n] = (names[n] || 0) + (from[n] || 0); │ │ │ │ │ - return names; │ │ │ │ │ + get _root() { │ │ │ │ │ + return this._nodes[0]; │ │ │ │ │ } │ │ │ │ │ - │ │ │ │ │ - function addExprNames(names, from) { │ │ │ │ │ - return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names; │ │ │ │ │ + get _currNode() { │ │ │ │ │ + const ns = this._nodes; │ │ │ │ │ + return ns[ns.length - 1]; │ │ │ │ │ + } │ │ │ │ │ + set _currNode(node) { │ │ │ │ │ + const ns = this._nodes; │ │ │ │ │ + ns[ns.length - 1] = node; │ │ │ │ │ } │ │ │ │ │ + } │ │ │ │ │ + exports.CodeGen = CodeGen; │ │ │ │ │ │ │ │ │ │ - function optimizeExpr(expr, names, constants) { │ │ │ │ │ - if (expr instanceof code_1.Name) │ │ │ │ │ - return replaceName(expr); │ │ │ │ │ - if (!canOptimize(expr)) │ │ │ │ │ - return expr; │ │ │ │ │ - return new code_1._Code(expr._items.reduce((items, c) => { │ │ │ │ │ - if (c instanceof code_1.Name) │ │ │ │ │ - c = replaceName(c); │ │ │ │ │ - if (c instanceof code_1._Code) │ │ │ │ │ - items.push(...c._items); │ │ │ │ │ - else │ │ │ │ │ - items.push(c); │ │ │ │ │ - return items; │ │ │ │ │ - }, [])); │ │ │ │ │ - │ │ │ │ │ - function replaceName(n) { │ │ │ │ │ - const c = constants[n.str]; │ │ │ │ │ - if (c === undefined || names[n.str] !== 1) │ │ │ │ │ - return n; │ │ │ │ │ - delete names[n.str]; │ │ │ │ │ - return c; │ │ │ │ │ - } │ │ │ │ │ + function addNames(names, from) { │ │ │ │ │ + for (const n in from) │ │ │ │ │ + names[n] = (names[n] || 0) + (from[n] || 0); │ │ │ │ │ + return names; │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function canOptimize(e) { │ │ │ │ │ - return (e instanceof code_1._Code && │ │ │ │ │ - e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined)); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ + function addExprNames(names, from) { │ │ │ │ │ + return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names; │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function subtractNames(names, from) { │ │ │ │ │ - for (const n in from) │ │ │ │ │ - names[n] = (names[n] || 0) - (from[n] || 0); │ │ │ │ │ - } │ │ │ │ │ + function optimizeExpr(expr, names, constants) { │ │ │ │ │ + if (expr instanceof code_1.Name) │ │ │ │ │ + return replaceName(expr); │ │ │ │ │ + if (!canOptimize(expr)) │ │ │ │ │ + return expr; │ │ │ │ │ + return new code_1._Code(expr._items.reduce((items, c) => { │ │ │ │ │ + if (c instanceof code_1.Name) │ │ │ │ │ + c = replaceName(c); │ │ │ │ │ + if (c instanceof code_1._Code) │ │ │ │ │ + items.push(...c._items); │ │ │ │ │ + else │ │ │ │ │ + items.push(c); │ │ │ │ │ + return items; │ │ │ │ │ + }, [])); │ │ │ │ │ │ │ │ │ │ - function not(x) { │ │ │ │ │ - return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._) `!${par(x)}`; │ │ │ │ │ - } │ │ │ │ │ - exports.not = not; │ │ │ │ │ - const andCode = mappend(exports.operators.AND); │ │ │ │ │ - // boolean AND (&&) expression with the passed arguments │ │ │ │ │ - function and(...args) { │ │ │ │ │ - return args.reduce(andCode); │ │ │ │ │ - } │ │ │ │ │ - exports.and = and; │ │ │ │ │ - const orCode = mappend(exports.operators.OR); │ │ │ │ │ - // boolean OR (||) expression with the passed arguments │ │ │ │ │ - function or(...args) { │ │ │ │ │ - return args.reduce(orCode); │ │ │ │ │ + function replaceName(n) { │ │ │ │ │ + const c = constants[n.str]; │ │ │ │ │ + if (c === undefined || names[n.str] !== 1) │ │ │ │ │ + return n; │ │ │ │ │ + delete names[n.str]; │ │ │ │ │ + return c; │ │ │ │ │ } │ │ │ │ │ - exports.or = or; │ │ │ │ │ │ │ │ │ │ - function mappend(op) { │ │ │ │ │ - return (x, y) => (x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._) `${par(x)} ${op} ${par(y)}`); │ │ │ │ │ + function canOptimize(e) { │ │ │ │ │ + return (e instanceof code_1._Code && │ │ │ │ │ + e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined)); │ │ │ │ │ } │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function par(x) { │ │ │ │ │ - return x instanceof code_1.Name ? x : (0, code_1._) `(${x})`; │ │ │ │ │ - } │ │ │ │ │ + function subtractNames(names, from) { │ │ │ │ │ + for (const n in from) │ │ │ │ │ + names[n] = (names[n] || 0) - (from[n] || 0); │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - }(codegen)); │ │ │ │ │ - return codegen; │ │ │ │ │ -} │ │ │ │ │ + function not(x) { │ │ │ │ │ + return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._) `!${par(x)}`; │ │ │ │ │ + } │ │ │ │ │ + exports.not = not; │ │ │ │ │ + const andCode = mappend(exports.operators.AND); │ │ │ │ │ + // boolean AND (&&) expression with the passed arguments │ │ │ │ │ + function and(...args) { │ │ │ │ │ + return args.reduce(andCode); │ │ │ │ │ + } │ │ │ │ │ + exports.and = and; │ │ │ │ │ + const orCode = mappend(exports.operators.OR); │ │ │ │ │ + // boolean OR (||) expression with the passed arguments │ │ │ │ │ + function or(...args) { │ │ │ │ │ + return args.reduce(orCode); │ │ │ │ │ + } │ │ │ │ │ + exports.or = or; │ │ │ │ │ + │ │ │ │ │ + function mappend(op) { │ │ │ │ │ + return (x, y) => (x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._) `${par(x)} ${op} ${par(y)}`); │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ + function par(x) { │ │ │ │ │ + return x instanceof code_1.Name ? x : (0, code_1._) `(${x})`; │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ +}(codegen)); │ │ │ │ │ │ │ │ │ │ var util = {}; │ │ │ │ │ │ │ │ │ │ (function(exports) { │ │ │ │ │ Object.defineProperty(exports, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const code_1 = requireCode$1(); │ │ │ │ │ + const codegen_1 = codegen; │ │ │ │ │ + const code_1 = code$1; │ │ │ │ │ // TODO refactor to use Set │ │ │ │ │ function toHash(arr) { │ │ │ │ │ const hash = {}; │ │ │ │ │ for (const item of arr) │ │ │ │ │ hash[item] = true; │ │ │ │ │ return hash; │ │ │ │ │ } │ │ │ │ │ @@ -35220,321 +35199,298 @@ │ │ │ │ │ throw new Error(msg); │ │ │ │ │ it.self.logger.warn(msg); │ │ │ │ │ } │ │ │ │ │ exports.checkStrictMode = checkStrictMode; │ │ │ │ │ │ │ │ │ │ }(util)); │ │ │ │ │ │ │ │ │ │ -var names = {}; │ │ │ │ │ +var names$1 = {}; │ │ │ │ │ │ │ │ │ │ -var hasRequiredNames; │ │ │ │ │ +Object.defineProperty(names$1, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +const codegen_1$t = codegen; │ │ │ │ │ +const names = { │ │ │ │ │ + // validation function arguments │ │ │ │ │ + data: new codegen_1$t.Name("data"), │ │ │ │ │ + // args passed from referencing schema │ │ │ │ │ + valCxt: new codegen_1$t.Name("valCxt"), │ │ │ │ │ + instancePath: new codegen_1$t.Name("instancePath"), │ │ │ │ │ + parentData: new codegen_1$t.Name("parentData"), │ │ │ │ │ + parentDataProperty: new codegen_1$t.Name("parentDataProperty"), │ │ │ │ │ + rootData: new codegen_1$t.Name("rootData"), │ │ │ │ │ + dynamicAnchors: new codegen_1$t.Name("dynamicAnchors"), │ │ │ │ │ + // function scoped variables │ │ │ │ │ + vErrors: new codegen_1$t.Name("vErrors"), │ │ │ │ │ + errors: new codegen_1$t.Name("errors"), │ │ │ │ │ + this: new codegen_1$t.Name("this"), │ │ │ │ │ + // "globals" │ │ │ │ │ + self: new codegen_1$t.Name("self"), │ │ │ │ │ + scope: new codegen_1$t.Name("scope"), │ │ │ │ │ + // JTD serialize/parse name for JSON string and position │ │ │ │ │ + json: new codegen_1$t.Name("json"), │ │ │ │ │ + jsonPos: new codegen_1$t.Name("jsonPos"), │ │ │ │ │ + jsonLen: new codegen_1$t.Name("jsonLen"), │ │ │ │ │ + jsonPart: new codegen_1$t.Name("jsonPart"), │ │ │ │ │ +}; │ │ │ │ │ +names$1.default = names; │ │ │ │ │ │ │ │ │ │ -function requireNames() { │ │ │ │ │ - if (hasRequiredNames) return names; │ │ │ │ │ - hasRequiredNames = 1; │ │ │ │ │ - Object.defineProperty(names, "__esModule", { │ │ │ │ │ +(function(exports) { │ │ │ │ │ + Object.defineProperty(exports, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const names$1 = { │ │ │ │ │ - // validation function arguments │ │ │ │ │ - data: new codegen_1.Name("data"), │ │ │ │ │ - // args passed from referencing schema │ │ │ │ │ - valCxt: new codegen_1.Name("valCxt"), │ │ │ │ │ - instancePath: new codegen_1.Name("instancePath"), │ │ │ │ │ - parentData: new codegen_1.Name("parentData"), │ │ │ │ │ - parentDataProperty: new codegen_1.Name("parentDataProperty"), │ │ │ │ │ - rootData: new codegen_1.Name("rootData"), │ │ │ │ │ - dynamicAnchors: new codegen_1.Name("dynamicAnchors"), │ │ │ │ │ - // function scoped variables │ │ │ │ │ - vErrors: new codegen_1.Name("vErrors"), │ │ │ │ │ - errors: new codegen_1.Name("errors"), │ │ │ │ │ - this: new codegen_1.Name("this"), │ │ │ │ │ - // "globals" │ │ │ │ │ - self: new codegen_1.Name("self"), │ │ │ │ │ - scope: new codegen_1.Name("scope"), │ │ │ │ │ - // JTD serialize/parse name for JSON string and position │ │ │ │ │ - json: new codegen_1.Name("json"), │ │ │ │ │ - jsonPos: new codegen_1.Name("jsonPos"), │ │ │ │ │ - jsonLen: new codegen_1.Name("jsonLen"), │ │ │ │ │ - jsonPart: new codegen_1.Name("jsonPart"), │ │ │ │ │ + exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0; │ │ │ │ │ + const codegen_1 = codegen; │ │ │ │ │ + const util_1 = util; │ │ │ │ │ + const names_1 = names$1; │ │ │ │ │ + exports.keywordError = { │ │ │ │ │ + message: ({ │ │ │ │ │ + keyword │ │ │ │ │ + }) => (0, codegen_1.str) `must pass "${keyword}" keyword validation`, │ │ │ │ │ + }; │ │ │ │ │ + exports.keyword$DataError = { │ │ │ │ │ + message: ({ │ │ │ │ │ + keyword, │ │ │ │ │ + schemaType │ │ │ │ │ + }) => schemaType ? │ │ │ │ │ + (0, codegen_1.str) `"${keyword}" keyword must be ${schemaType} ($data)` : │ │ │ │ │ + (0, codegen_1.str) `"${keyword}" keyword is invalid ($data)`, │ │ │ │ │ }; │ │ │ │ │ - names.default = names$1; │ │ │ │ │ - │ │ │ │ │ - return names; │ │ │ │ │ -} │ │ │ │ │ - │ │ │ │ │ -var hasRequiredErrors; │ │ │ │ │ - │ │ │ │ │ -function requireErrors() { │ │ │ │ │ - if (hasRequiredErrors) return errors; │ │ │ │ │ - hasRequiredErrors = 1; │ │ │ │ │ - (function(exports) { │ │ │ │ │ - Object.defineProperty(exports, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const util_1 = util; │ │ │ │ │ - const names_1 = requireNames(); │ │ │ │ │ - exports.keywordError = { │ │ │ │ │ - message: ({ │ │ │ │ │ - keyword │ │ │ │ │ - }) => (0, codegen_1.str) `must pass "${keyword}" keyword validation`, │ │ │ │ │ - }; │ │ │ │ │ - exports.keyword$DataError = { │ │ │ │ │ - message: ({ │ │ │ │ │ - keyword, │ │ │ │ │ - schemaType │ │ │ │ │ - }) => schemaType ? │ │ │ │ │ - (0, codegen_1.str) `"${keyword}" keyword must be ${schemaType} ($data)` : │ │ │ │ │ - (0, codegen_1.str) `"${keyword}" keyword is invalid ($data)`, │ │ │ │ │ - }; │ │ │ │ │ - │ │ │ │ │ - function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) { │ │ │ │ │ - const { │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - compositeRule, │ │ │ │ │ - allErrors │ │ │ │ │ - } = it; │ │ │ │ │ - const errObj = errorObjectCode(cxt, error, errorPaths); │ │ │ │ │ - if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : (compositeRule || allErrors)) { │ │ │ │ │ - addError(gen, errObj); │ │ │ │ │ - } else { │ │ │ │ │ - returnErrors(it, (0, codegen_1._) `[${errObj}]`); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - exports.reportError = reportError; │ │ │ │ │ │ │ │ │ │ - function reportExtraError(cxt, error = exports.keywordError, errorPaths) { │ │ │ │ │ - const { │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - compositeRule, │ │ │ │ │ - allErrors │ │ │ │ │ - } = it; │ │ │ │ │ - const errObj = errorObjectCode(cxt, error, errorPaths); │ │ │ │ │ + function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) { │ │ │ │ │ + const { │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + compositeRule, │ │ │ │ │ + allErrors │ │ │ │ │ + } = it; │ │ │ │ │ + const errObj = errorObjectCode(cxt, error, errorPaths); │ │ │ │ │ + if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : (compositeRule || allErrors)) { │ │ │ │ │ addError(gen, errObj); │ │ │ │ │ - if (!(compositeRule || allErrors)) { │ │ │ │ │ - returnErrors(it, names_1.default.vErrors); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - exports.reportExtraError = reportExtraError; │ │ │ │ │ - │ │ │ │ │ - function resetErrorsCount(gen, errsCount) { │ │ │ │ │ - gen.assign(names_1.default.errors, errsCount); │ │ │ │ │ - gen.if((0, codegen_1._) `${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._) `${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null))); │ │ │ │ │ + } else { │ │ │ │ │ + returnErrors(it, (0, codegen_1._) `[${errObj}]`); │ │ │ │ │ } │ │ │ │ │ - exports.resetErrorsCount = resetErrorsCount; │ │ │ │ │ + } │ │ │ │ │ + exports.reportError = reportError; │ │ │ │ │ │ │ │ │ │ - function extendErrors({ │ │ │ │ │ + function reportExtraError(cxt, error = exports.keywordError, errorPaths) { │ │ │ │ │ + const { │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + const { │ │ │ │ │ gen, │ │ │ │ │ - keyword, │ │ │ │ │ - schemaValue, │ │ │ │ │ - data, │ │ │ │ │ - errsCount, │ │ │ │ │ - it, │ │ │ │ │ - }) { │ │ │ │ │ - /* istanbul ignore if */ │ │ │ │ │ - if (errsCount === undefined) │ │ │ │ │ - throw new Error("ajv implementation error"); │ │ │ │ │ - const err = gen.name("err"); │ │ │ │ │ - gen.forRange("i", errsCount, names_1.default.errors, (i) => { │ │ │ │ │ - gen.const(err, (0, codegen_1._) `${names_1.default.vErrors}[${i}]`); │ │ │ │ │ - gen.if((0, codegen_1._) `${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._) `${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath))); │ │ │ │ │ - gen.assign((0, codegen_1._) `${err}.schemaPath`, (0, codegen_1.str) `${it.errSchemaPath}/${keyword}`); │ │ │ │ │ - if (it.opts.verbose) { │ │ │ │ │ - gen.assign((0, codegen_1._) `${err}.schema`, schemaValue); │ │ │ │ │ - gen.assign((0, codegen_1._) `${err}.data`, data); │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ - exports.extendErrors = extendErrors; │ │ │ │ │ - │ │ │ │ │ - function addError(gen, errObj) { │ │ │ │ │ - const err = gen.const("err", errObj); │ │ │ │ │ - gen.if((0, codegen_1._) `${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._) `[${err}]`), (0, codegen_1._) `${names_1.default.vErrors}.push(${err})`); │ │ │ │ │ - gen.code((0, codegen_1._) `${names_1.default.errors}++`); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function returnErrors(it, errs) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - validateName, │ │ │ │ │ - schemaEnv │ │ │ │ │ - } = it; │ │ │ │ │ - if (schemaEnv.$async) { │ │ │ │ │ - gen.throw((0, codegen_1._) `new ${it.ValidationError}(${errs})`); │ │ │ │ │ - } else { │ │ │ │ │ - gen.assign((0, codegen_1._) `${validateName}.errors`, errs); │ │ │ │ │ - gen.return(false); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - const E = { │ │ │ │ │ - keyword: new codegen_1.Name("keyword"), │ │ │ │ │ - schemaPath: new codegen_1.Name("schemaPath"), │ │ │ │ │ - params: new codegen_1.Name("params"), │ │ │ │ │ - propertyName: new codegen_1.Name("propertyName"), │ │ │ │ │ - message: new codegen_1.Name("message"), │ │ │ │ │ - schema: new codegen_1.Name("schema"), │ │ │ │ │ - parentSchema: new codegen_1.Name("parentSchema"), │ │ │ │ │ - }; │ │ │ │ │ - │ │ │ │ │ - function errorObjectCode(cxt, error, errorPaths) { │ │ │ │ │ - const { │ │ │ │ │ - createErrors │ │ │ │ │ - } = cxt.it; │ │ │ │ │ - if (createErrors === false) │ │ │ │ │ - return (0, codegen_1._) `{}`; │ │ │ │ │ - return errorObject(cxt, error, errorPaths); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function errorObject(cxt, error, errorPaths = {}) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - const keyValues = [ │ │ │ │ │ - errorInstancePath(it, errorPaths), │ │ │ │ │ - errorSchemaPath(cxt, errorPaths), │ │ │ │ │ - ]; │ │ │ │ │ - extraErrorProps(cxt, error, keyValues); │ │ │ │ │ - return gen.object(...keyValues); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function errorInstancePath({ │ │ │ │ │ - errorPath │ │ │ │ │ - }, { │ │ │ │ │ - instancePath │ │ │ │ │ - }) { │ │ │ │ │ - const instPath = instancePath ? │ │ │ │ │ - (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : │ │ │ │ │ - errorPath; │ │ │ │ │ - return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)]; │ │ │ │ │ + compositeRule, │ │ │ │ │ + allErrors │ │ │ │ │ + } = it; │ │ │ │ │ + const errObj = errorObjectCode(cxt, error, errorPaths); │ │ │ │ │ + addError(gen, errObj); │ │ │ │ │ + if (!(compositeRule || allErrors)) { │ │ │ │ │ + returnErrors(it, names_1.default.vErrors); │ │ │ │ │ } │ │ │ │ │ + } │ │ │ │ │ + exports.reportExtraError = reportExtraError; │ │ │ │ │ │ │ │ │ │ - function errorSchemaPath({ │ │ │ │ │ - keyword, │ │ │ │ │ - it: { │ │ │ │ │ - errSchemaPath │ │ │ │ │ - } │ │ │ │ │ - }, { │ │ │ │ │ - schemaPath, │ │ │ │ │ - parentSchema │ │ │ │ │ - }) { │ │ │ │ │ - let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str) `${errSchemaPath}/${keyword}`; │ │ │ │ │ - if (schemaPath) { │ │ │ │ │ - schPath = (0, codegen_1.str) `${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`; │ │ │ │ │ - } │ │ │ │ │ - return [E.schemaPath, schPath]; │ │ │ │ │ - } │ │ │ │ │ + function resetErrorsCount(gen, errsCount) { │ │ │ │ │ + gen.assign(names_1.default.errors, errsCount); │ │ │ │ │ + gen.if((0, codegen_1._) `${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._) `${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null))); │ │ │ │ │ + } │ │ │ │ │ + exports.resetErrorsCount = resetErrorsCount; │ │ │ │ │ │ │ │ │ │ - function extraErrorProps(cxt, { │ │ │ │ │ - params, │ │ │ │ │ - message │ │ │ │ │ - }, keyValues) { │ │ │ │ │ - const { │ │ │ │ │ - keyword, │ │ │ │ │ - data, │ │ │ │ │ - schemaValue, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - const { │ │ │ │ │ - opts, │ │ │ │ │ - propertyName, │ │ │ │ │ - topSchemaRef, │ │ │ │ │ - schemaPath │ │ │ │ │ - } = it; │ │ │ │ │ - keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._) `{}`]); │ │ │ │ │ - if (opts.messages) { │ │ │ │ │ - keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]); │ │ │ │ │ - } │ │ │ │ │ - if (opts.verbose) { │ │ │ │ │ - keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._) `${topSchemaRef}${schemaPath}`], [names_1.default.data, data]); │ │ │ │ │ + function extendErrors({ │ │ │ │ │ + gen, │ │ │ │ │ + keyword, │ │ │ │ │ + schemaValue, │ │ │ │ │ + data, │ │ │ │ │ + errsCount, │ │ │ │ │ + it, │ │ │ │ │ + }) { │ │ │ │ │ + /* istanbul ignore if */ │ │ │ │ │ + if (errsCount === undefined) │ │ │ │ │ + throw new Error("ajv implementation error"); │ │ │ │ │ + const err = gen.name("err"); │ │ │ │ │ + gen.forRange("i", errsCount, names_1.default.errors, (i) => { │ │ │ │ │ + gen.const(err, (0, codegen_1._) `${names_1.default.vErrors}[${i}]`); │ │ │ │ │ + gen.if((0, codegen_1._) `${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._) `${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath))); │ │ │ │ │ + gen.assign((0, codegen_1._) `${err}.schemaPath`, (0, codegen_1.str) `${it.errSchemaPath}/${keyword}`); │ │ │ │ │ + if (it.opts.verbose) { │ │ │ │ │ + gen.assign((0, codegen_1._) `${err}.schema`, schemaValue); │ │ │ │ │ + gen.assign((0, codegen_1._) `${err}.data`, data); │ │ │ │ │ } │ │ │ │ │ - if (propertyName) │ │ │ │ │ - keyValues.push([E.propertyName, propertyName]); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - }(errors)); │ │ │ │ │ - return errors; │ │ │ │ │ -} │ │ │ │ │ - │ │ │ │ │ -var hasRequiredBoolSchema; │ │ │ │ │ + }); │ │ │ │ │ + } │ │ │ │ │ + exports.extendErrors = extendErrors; │ │ │ │ │ │ │ │ │ │ -function requireBoolSchema() { │ │ │ │ │ - if (hasRequiredBoolSchema) return boolSchema; │ │ │ │ │ - hasRequiredBoolSchema = 1; │ │ │ │ │ - Object.defineProperty(boolSchema, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0; │ │ │ │ │ - const errors_1 = requireErrors(); │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const names_1 = requireNames(); │ │ │ │ │ - const boolError = { │ │ │ │ │ - message: "boolean schema is false", │ │ │ │ │ - }; │ │ │ │ │ + function addError(gen, errObj) { │ │ │ │ │ + const err = gen.const("err", errObj); │ │ │ │ │ + gen.if((0, codegen_1._) `${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._) `[${err}]`), (0, codegen_1._) `${names_1.default.vErrors}.push(${err})`); │ │ │ │ │ + gen.code((0, codegen_1._) `${names_1.default.errors}++`); │ │ │ │ │ + } │ │ │ │ │ │ │ │ │ │ - function topBoolOrEmptySchema(it) { │ │ │ │ │ + function returnErrors(it, errs) { │ │ │ │ │ const { │ │ │ │ │ gen, │ │ │ │ │ - schema, │ │ │ │ │ - validateName │ │ │ │ │ + validateName, │ │ │ │ │ + schemaEnv │ │ │ │ │ } = it; │ │ │ │ │ - if (schema === false) { │ │ │ │ │ - falseSchemaError(it, false); │ │ │ │ │ - } else if (typeof schema == "object" && schema.$async === true) { │ │ │ │ │ - gen.return(names_1.default.data); │ │ │ │ │ + if (schemaEnv.$async) { │ │ │ │ │ + gen.throw((0, codegen_1._) `new ${it.ValidationError}(${errs})`); │ │ │ │ │ } else { │ │ │ │ │ - gen.assign((0, codegen_1._) `${validateName}.errors`, null); │ │ │ │ │ - gen.return(true); │ │ │ │ │ + gen.assign((0, codegen_1._) `${validateName}.errors`, errs); │ │ │ │ │ + gen.return(false); │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ - boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema; │ │ │ │ │ + const E = { │ │ │ │ │ + keyword: new codegen_1.Name("keyword"), │ │ │ │ │ + schemaPath: new codegen_1.Name("schemaPath"), │ │ │ │ │ + params: new codegen_1.Name("params"), │ │ │ │ │ + propertyName: new codegen_1.Name("propertyName"), │ │ │ │ │ + message: new codegen_1.Name("message"), │ │ │ │ │ + schema: new codegen_1.Name("schema"), │ │ │ │ │ + parentSchema: new codegen_1.Name("parentSchema"), │ │ │ │ │ + }; │ │ │ │ │ │ │ │ │ │ - function boolOrEmptySchema(it, valid) { │ │ │ │ │ + function errorObjectCode(cxt, error, errorPaths) { │ │ │ │ │ + const { │ │ │ │ │ + createErrors │ │ │ │ │ + } = cxt.it; │ │ │ │ │ + if (createErrors === false) │ │ │ │ │ + return (0, codegen_1._) `{}`; │ │ │ │ │ + return errorObject(cxt, error, errorPaths); │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ + function errorObject(cxt, error, errorPaths = {}) { │ │ │ │ │ const { │ │ │ │ │ gen, │ │ │ │ │ - schema │ │ │ │ │ - } = it; │ │ │ │ │ - if (schema === false) { │ │ │ │ │ - gen.var(valid, false); // TODO var │ │ │ │ │ - falseSchemaError(it); │ │ │ │ │ - } else { │ │ │ │ │ - gen.var(valid, true); // TODO var │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + const keyValues = [ │ │ │ │ │ + errorInstancePath(it, errorPaths), │ │ │ │ │ + errorSchemaPath(cxt, errorPaths), │ │ │ │ │ + ]; │ │ │ │ │ + extraErrorProps(cxt, error, keyValues); │ │ │ │ │ + return gen.object(...keyValues); │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ + function errorInstancePath({ │ │ │ │ │ + errorPath │ │ │ │ │ + }, { │ │ │ │ │ + instancePath │ │ │ │ │ + }) { │ │ │ │ │ + const instPath = instancePath ? │ │ │ │ │ + (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : │ │ │ │ │ + errorPath; │ │ │ │ │ + return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)]; │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ + function errorSchemaPath({ │ │ │ │ │ + keyword, │ │ │ │ │ + it: { │ │ │ │ │ + errSchemaPath │ │ │ │ │ + } │ │ │ │ │ + }, { │ │ │ │ │ + schemaPath, │ │ │ │ │ + parentSchema │ │ │ │ │ + }) { │ │ │ │ │ + let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str) `${errSchemaPath}/${keyword}`; │ │ │ │ │ + if (schemaPath) { │ │ │ │ │ + schPath = (0, codegen_1.str) `${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`; │ │ │ │ │ } │ │ │ │ │ + return [E.schemaPath, schPath]; │ │ │ │ │ } │ │ │ │ │ - boolSchema.boolOrEmptySchema = boolOrEmptySchema; │ │ │ │ │ │ │ │ │ │ - function falseSchemaError(it, overrideAllErrors) { │ │ │ │ │ + function extraErrorProps(cxt, { │ │ │ │ │ + params, │ │ │ │ │ + message │ │ │ │ │ + }, keyValues) { │ │ │ │ │ const { │ │ │ │ │ - gen, │ │ │ │ │ - data │ │ │ │ │ - } = it; │ │ │ │ │ - // TODO maybe some other interface should be used for non-keyword validation errors... │ │ │ │ │ - const cxt = { │ │ │ │ │ - gen, │ │ │ │ │ - keyword: "false schema", │ │ │ │ │ + keyword, │ │ │ │ │ data, │ │ │ │ │ - schema: false, │ │ │ │ │ - schemaCode: false, │ │ │ │ │ - schemaValue: false, │ │ │ │ │ - params: {}, │ │ │ │ │ - it, │ │ │ │ │ - }; │ │ │ │ │ - (0, errors_1.reportError)(cxt, boolError, undefined, overrideAllErrors); │ │ │ │ │ + schemaValue, │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + const { │ │ │ │ │ + opts, │ │ │ │ │ + propertyName, │ │ │ │ │ + topSchemaRef, │ │ │ │ │ + schemaPath │ │ │ │ │ + } = it; │ │ │ │ │ + keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._) `{}`]); │ │ │ │ │ + if (opts.messages) { │ │ │ │ │ + keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]); │ │ │ │ │ + } │ │ │ │ │ + if (opts.verbose) { │ │ │ │ │ + keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._) `${topSchemaRef}${schemaPath}`], [names_1.default.data, data]); │ │ │ │ │ + } │ │ │ │ │ + if (propertyName) │ │ │ │ │ + keyValues.push([E.propertyName, propertyName]); │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ +}(errors)); │ │ │ │ │ + │ │ │ │ │ +Object.defineProperty(boolSchema, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0; │ │ │ │ │ +const errors_1$2 = errors; │ │ │ │ │ +const codegen_1$s = codegen; │ │ │ │ │ +const names_1$6 = names$1; │ │ │ │ │ +const boolError = { │ │ │ │ │ + message: "boolean schema is false", │ │ │ │ │ +}; │ │ │ │ │ + │ │ │ │ │ +function topBoolOrEmptySchema(it) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + schema, │ │ │ │ │ + validateName │ │ │ │ │ + } = it; │ │ │ │ │ + if (schema === false) { │ │ │ │ │ + falseSchemaError(it, false); │ │ │ │ │ + } else if (typeof schema == "object" && schema.$async === true) { │ │ │ │ │ + gen.return(names_1$6.default.data); │ │ │ │ │ + } else { │ │ │ │ │ + gen.assign((0, codegen_1$s._) `${validateName}.errors`, null); │ │ │ │ │ + gen.return(true); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ +boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema; │ │ │ │ │ │ │ │ │ │ - return boolSchema; │ │ │ │ │ +function boolOrEmptySchema(it, valid) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + schema │ │ │ │ │ + } = it; │ │ │ │ │ + if (schema === false) { │ │ │ │ │ + gen.var(valid, false); // TODO var │ │ │ │ │ + falseSchemaError(it); │ │ │ │ │ + } else { │ │ │ │ │ + gen.var(valid, true); // TODO var │ │ │ │ │ + } │ │ │ │ │ +} │ │ │ │ │ +boolSchema.boolOrEmptySchema = boolOrEmptySchema; │ │ │ │ │ + │ │ │ │ │ +function falseSchemaError(it, overrideAllErrors) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + data │ │ │ │ │ + } = it; │ │ │ │ │ + // TODO maybe some other interface should be used for non-keyword validation errors... │ │ │ │ │ + const cxt = { │ │ │ │ │ + gen, │ │ │ │ │ + keyword: "false schema", │ │ │ │ │ + data, │ │ │ │ │ + schema: false, │ │ │ │ │ + schemaCode: false, │ │ │ │ │ + schemaValue: false, │ │ │ │ │ + params: {}, │ │ │ │ │ + it, │ │ │ │ │ + }; │ │ │ │ │ + (0, errors_1$2.reportError)(cxt, boolError, undefined, overrideAllErrors); │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ var dataType = {}; │ │ │ │ │ │ │ │ │ │ var rules = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(rules, "__esModule", { │ │ │ │ │ @@ -35585,57 +35541,49 @@ │ │ │ │ │ keywords: {}, │ │ │ │ │ }; │ │ │ │ │ } │ │ │ │ │ rules.getRules = getRules; │ │ │ │ │ │ │ │ │ │ var applicability = {}; │ │ │ │ │ │ │ │ │ │ -var hasRequiredApplicability; │ │ │ │ │ - │ │ │ │ │ -function requireApplicability() { │ │ │ │ │ - if (hasRequiredApplicability) return applicability; │ │ │ │ │ - hasRequiredApplicability = 1; │ │ │ │ │ - Object.defineProperty(applicability, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - applicability.shouldUseRule = applicability.shouldUseGroup = applicability.schemaHasRulesForType = void 0; │ │ │ │ │ - │ │ │ │ │ - function schemaHasRulesForType({ │ │ │ │ │ - schema, │ │ │ │ │ - self │ │ │ │ │ - }, type) { │ │ │ │ │ - const group = self.RULES.types[type]; │ │ │ │ │ - return group && group !== true && shouldUseGroup(schema, group); │ │ │ │ │ - } │ │ │ │ │ - applicability.schemaHasRulesForType = schemaHasRulesForType; │ │ │ │ │ +Object.defineProperty(applicability, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +applicability.shouldUseRule = applicability.shouldUseGroup = applicability.schemaHasRulesForType = void 0; │ │ │ │ │ │ │ │ │ │ - function shouldUseGroup(schema, group) { │ │ │ │ │ - return group.rules.some((rule) => shouldUseRule(schema, rule)); │ │ │ │ │ - } │ │ │ │ │ - applicability.shouldUseGroup = shouldUseGroup; │ │ │ │ │ +function schemaHasRulesForType({ │ │ │ │ │ + schema, │ │ │ │ │ + self │ │ │ │ │ +}, type) { │ │ │ │ │ + const group = self.RULES.types[type]; │ │ │ │ │ + return group && group !== true && shouldUseGroup(schema, group); │ │ │ │ │ +} │ │ │ │ │ +applicability.schemaHasRulesForType = schemaHasRulesForType; │ │ │ │ │ │ │ │ │ │ - function shouldUseRule(schema, rule) { │ │ │ │ │ - var _a; │ │ │ │ │ - return (schema[rule.keyword] !== undefined || │ │ │ │ │ - ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined))); │ │ │ │ │ - } │ │ │ │ │ - applicability.shouldUseRule = shouldUseRule; │ │ │ │ │ +function shouldUseGroup(schema, group) { │ │ │ │ │ + return group.rules.some((rule) => shouldUseRule(schema, rule)); │ │ │ │ │ +} │ │ │ │ │ +applicability.shouldUseGroup = shouldUseGroup; │ │ │ │ │ │ │ │ │ │ - return applicability; │ │ │ │ │ +function shouldUseRule(schema, rule) { │ │ │ │ │ + var _a; │ │ │ │ │ + return (schema[rule.keyword] !== undefined || │ │ │ │ │ + ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined))); │ │ │ │ │ } │ │ │ │ │ +applicability.shouldUseRule = shouldUseRule; │ │ │ │ │ │ │ │ │ │ (function(exports) { │ │ │ │ │ Object.defineProperty(exports, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0; │ │ │ │ │ const rules_1 = rules; │ │ │ │ │ - const applicability_1 = requireApplicability(); │ │ │ │ │ - const errors_1 = requireErrors(); │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ + const applicability_1 = applicability; │ │ │ │ │ + const errors_1 = errors; │ │ │ │ │ + const codegen_1 = codegen; │ │ │ │ │ const util_1 = util; │ │ │ │ │ var DataType; │ │ │ │ │ (function(DataType) { │ │ │ │ │ DataType[DataType["Correct"] = 0] = "Correct"; │ │ │ │ │ DataType[DataType["Wrong"] = 1] = "Wrong"; │ │ │ │ │ })(DataType = exports.DataType || (exports.DataType = {})); │ │ │ │ │ │ │ │ │ │ @@ -35858,562 +35806,530 @@ │ │ │ │ │ }; │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ }(dataType)); │ │ │ │ │ │ │ │ │ │ var defaults = {}; │ │ │ │ │ │ │ │ │ │ -var hasRequiredDefaults; │ │ │ │ │ - │ │ │ │ │ -function requireDefaults() { │ │ │ │ │ - if (hasRequiredDefaults) return defaults; │ │ │ │ │ - hasRequiredDefaults = 1; │ │ │ │ │ - Object.defineProperty(defaults, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - defaults.assignDefaults = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const util_1 = util; │ │ │ │ │ +Object.defineProperty(defaults, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +defaults.assignDefaults = void 0; │ │ │ │ │ +const codegen_1$r = codegen; │ │ │ │ │ +const util_1$p = util; │ │ │ │ │ │ │ │ │ │ - function assignDefaults(it, ty) { │ │ │ │ │ - const { │ │ │ │ │ - properties, │ │ │ │ │ - items │ │ │ │ │ - } = it.schema; │ │ │ │ │ - if (ty === "object" && properties) { │ │ │ │ │ - for (const key in properties) { │ │ │ │ │ - assignDefault(it, key, properties[key].default); │ │ │ │ │ - } │ │ │ │ │ - } else if (ty === "array" && Array.isArray(items)) { │ │ │ │ │ - items.forEach((sch, i) => assignDefault(it, i, sch.default)); │ │ │ │ │ +function assignDefaults(it, ty) { │ │ │ │ │ + const { │ │ │ │ │ + properties, │ │ │ │ │ + items │ │ │ │ │ + } = it.schema; │ │ │ │ │ + if (ty === "object" && properties) { │ │ │ │ │ + for (const key in properties) { │ │ │ │ │ + assignDefault(it, key, properties[key].default); │ │ │ │ │ } │ │ │ │ │ + } else if (ty === "array" && Array.isArray(items)) { │ │ │ │ │ + items.forEach((sch, i) => assignDefault(it, i, sch.default)); │ │ │ │ │ } │ │ │ │ │ - defaults.assignDefaults = assignDefaults; │ │ │ │ │ +} │ │ │ │ │ +defaults.assignDefaults = assignDefaults; │ │ │ │ │ │ │ │ │ │ - function assignDefault(it, prop, defaultValue) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - compositeRule, │ │ │ │ │ - data, │ │ │ │ │ - opts │ │ │ │ │ - } = it; │ │ │ │ │ - if (defaultValue === undefined) │ │ │ │ │ - return; │ │ │ │ │ - const childData = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(prop)}`; │ │ │ │ │ - if (compositeRule) { │ │ │ │ │ - (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`); │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ - let condition = (0, codegen_1._) `${childData} === undefined`; │ │ │ │ │ - if (opts.useDefaults === "empty") { │ │ │ │ │ - condition = (0, codegen_1._) `${condition} || ${childData} === null || ${childData} === ""`; │ │ │ │ │ - } │ │ │ │ │ - // `${childData} === undefined` + │ │ │ │ │ - // (opts.useDefaults === "empty" ? ` || ${childData} === null || ${childData} === ""` : "") │ │ │ │ │ - gen.if(condition, (0, codegen_1._) `${childData} = ${(0, codegen_1.stringify)(defaultValue)}`); │ │ │ │ │ +function assignDefault(it, prop, defaultValue) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + compositeRule, │ │ │ │ │ + data, │ │ │ │ │ + opts │ │ │ │ │ + } = it; │ │ │ │ │ + if (defaultValue === undefined) │ │ │ │ │ + return; │ │ │ │ │ + const childData = (0, codegen_1$r._) `${data}${(0, codegen_1$r.getProperty)(prop)}`; │ │ │ │ │ + if (compositeRule) { │ │ │ │ │ + (0, util_1$p.checkStrictMode)(it, `default is ignored for: ${childData}`); │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ - │ │ │ │ │ - return defaults; │ │ │ │ │ + let condition = (0, codegen_1$r._) `${childData} === undefined`; │ │ │ │ │ + if (opts.useDefaults === "empty") { │ │ │ │ │ + condition = (0, codegen_1$r._) `${condition} || ${childData} === null || ${childData} === ""`; │ │ │ │ │ + } │ │ │ │ │ + // `${childData} === undefined` + │ │ │ │ │ + // (opts.useDefaults === "empty" ? ` || ${childData} === null || ${childData} === ""` : "") │ │ │ │ │ + gen.if(condition, (0, codegen_1$r._) `${childData} = ${(0, codegen_1$r.stringify)(defaultValue)}`); │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ var keyword = {}; │ │ │ │ │ │ │ │ │ │ var code = {}; │ │ │ │ │ │ │ │ │ │ -var hasRequiredCode; │ │ │ │ │ - │ │ │ │ │ -function requireCode() { │ │ │ │ │ - if (hasRequiredCode) return code; │ │ │ │ │ - hasRequiredCode = 1; │ │ │ │ │ - Object.defineProperty(code, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const util_1 = util; │ │ │ │ │ - const names_1 = requireNames(); │ │ │ │ │ - const util_2 = util; │ │ │ │ │ - │ │ │ │ │ - function checkReportMissingProp(cxt, prop) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - data, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => { │ │ │ │ │ - cxt.setParams({ │ │ │ │ │ - missingProperty: (0, codegen_1._) `${prop}` │ │ │ │ │ - }, true); │ │ │ │ │ - cxt.error(); │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ - code.checkReportMissingProp = checkReportMissingProp; │ │ │ │ │ +Object.defineProperty(code, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0; │ │ │ │ │ +const codegen_1$q = codegen; │ │ │ │ │ +const util_1$o = util; │ │ │ │ │ +const names_1$5 = names$1; │ │ │ │ │ +const util_2$1 = util; │ │ │ │ │ │ │ │ │ │ - function checkMissingProp({ │ │ │ │ │ +function checkReportMissingProp(cxt, prop) { │ │ │ │ │ + const { │ │ │ │ │ gen, │ │ │ │ │ data, │ │ │ │ │ - it: { │ │ │ │ │ - opts │ │ │ │ │ - } │ │ │ │ │ - }, properties, missing) { │ │ │ │ │ - return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._) `${missing} = ${prop}`))); │ │ │ │ │ - } │ │ │ │ │ - code.checkMissingProp = checkMissingProp; │ │ │ │ │ - │ │ │ │ │ - function reportMissingProp(cxt, missing) { │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => { │ │ │ │ │ cxt.setParams({ │ │ │ │ │ - missingProperty: missing │ │ │ │ │ + missingProperty: (0, codegen_1$q._) `${prop}` │ │ │ │ │ }, true); │ │ │ │ │ cxt.error(); │ │ │ │ │ - } │ │ │ │ │ - code.reportMissingProp = reportMissingProp; │ │ │ │ │ + }); │ │ │ │ │ +} │ │ │ │ │ +code.checkReportMissingProp = checkReportMissingProp; │ │ │ │ │ │ │ │ │ │ - function hasPropFunc(gen) { │ │ │ │ │ - return gen.scopeValue("func", { │ │ │ │ │ - // eslint-disable-next-line @typescript-eslint/unbound-method │ │ │ │ │ - ref: Object.prototype.hasOwnProperty, │ │ │ │ │ - code: (0, codegen_1._) `Object.prototype.hasOwnProperty`, │ │ │ │ │ - }); │ │ │ │ │ +function checkMissingProp({ │ │ │ │ │ + gen, │ │ │ │ │ + data, │ │ │ │ │ + it: { │ │ │ │ │ + opts │ │ │ │ │ } │ │ │ │ │ - code.hasPropFunc = hasPropFunc; │ │ │ │ │ +}, properties, missing) { │ │ │ │ │ + return (0, codegen_1$q.or)(...properties.map((prop) => (0, codegen_1$q.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1$q._) `${missing} = ${prop}`))); │ │ │ │ │ +} │ │ │ │ │ +code.checkMissingProp = checkMissingProp; │ │ │ │ │ │ │ │ │ │ - function isOwnProperty(gen, data, property) { │ │ │ │ │ - return (0, codegen_1._) `${hasPropFunc(gen)}.call(${data}, ${property})`; │ │ │ │ │ - } │ │ │ │ │ - code.isOwnProperty = isOwnProperty; │ │ │ │ │ +function reportMissingProp(cxt, missing) { │ │ │ │ │ + cxt.setParams({ │ │ │ │ │ + missingProperty: missing │ │ │ │ │ + }, true); │ │ │ │ │ + cxt.error(); │ │ │ │ │ +} │ │ │ │ │ +code.reportMissingProp = reportMissingProp; │ │ │ │ │ + │ │ │ │ │ +function hasPropFunc(gen) { │ │ │ │ │ + return gen.scopeValue("func", { │ │ │ │ │ + // eslint-disable-next-line @typescript-eslint/unbound-method │ │ │ │ │ + ref: Object.prototype.hasOwnProperty, │ │ │ │ │ + code: (0, codegen_1$q._) `Object.prototype.hasOwnProperty`, │ │ │ │ │ + }); │ │ │ │ │ +} │ │ │ │ │ +code.hasPropFunc = hasPropFunc; │ │ │ │ │ │ │ │ │ │ - function propertyInData(gen, data, property, ownProperties) { │ │ │ │ │ - const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} !== undefined`; │ │ │ │ │ - return ownProperties ? (0, codegen_1._) `${cond} && ${isOwnProperty(gen, data, property)}` : cond; │ │ │ │ │ - } │ │ │ │ │ - code.propertyInData = propertyInData; │ │ │ │ │ +function isOwnProperty(gen, data, property) { │ │ │ │ │ + return (0, codegen_1$q._) `${hasPropFunc(gen)}.call(${data}, ${property})`; │ │ │ │ │ +} │ │ │ │ │ +code.isOwnProperty = isOwnProperty; │ │ │ │ │ │ │ │ │ │ - function noPropertyInData(gen, data, property, ownProperties) { │ │ │ │ │ - const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} === undefined`; │ │ │ │ │ - return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond; │ │ │ │ │ - } │ │ │ │ │ - code.noPropertyInData = noPropertyInData; │ │ │ │ │ +function propertyInData(gen, data, property, ownProperties) { │ │ │ │ │ + const cond = (0, codegen_1$q._) `${data}${(0, codegen_1$q.getProperty)(property)} !== undefined`; │ │ │ │ │ + return ownProperties ? (0, codegen_1$q._) `${cond} && ${isOwnProperty(gen, data, property)}` : cond; │ │ │ │ │ +} │ │ │ │ │ +code.propertyInData = propertyInData; │ │ │ │ │ │ │ │ │ │ - function allSchemaProperties(schemaMap) { │ │ │ │ │ - return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []; │ │ │ │ │ - } │ │ │ │ │ - code.allSchemaProperties = allSchemaProperties; │ │ │ │ │ +function noPropertyInData(gen, data, property, ownProperties) { │ │ │ │ │ + const cond = (0, codegen_1$q._) `${data}${(0, codegen_1$q.getProperty)(property)} === undefined`; │ │ │ │ │ + return ownProperties ? (0, codegen_1$q.or)(cond, (0, codegen_1$q.not)(isOwnProperty(gen, data, property))) : cond; │ │ │ │ │ +} │ │ │ │ │ +code.noPropertyInData = noPropertyInData; │ │ │ │ │ │ │ │ │ │ - function schemaProperties(it, schemaMap) { │ │ │ │ │ - return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p])); │ │ │ │ │ - } │ │ │ │ │ - code.schemaProperties = schemaProperties; │ │ │ │ │ +function allSchemaProperties(schemaMap) { │ │ │ │ │ + return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []; │ │ │ │ │ +} │ │ │ │ │ +code.allSchemaProperties = allSchemaProperties; │ │ │ │ │ │ │ │ │ │ - function callValidateCode({ │ │ │ │ │ - schemaCode, │ │ │ │ │ - data, │ │ │ │ │ - it: { │ │ │ │ │ - gen, │ │ │ │ │ - topSchemaRef, │ │ │ │ │ - schemaPath, │ │ │ │ │ - errorPath │ │ │ │ │ - }, │ │ │ │ │ - it │ │ │ │ │ - }, func, context, passSchema) { │ │ │ │ │ - const dataAndSchema = passSchema ? (0, codegen_1._) `${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data; │ │ │ │ │ - const valCxt = [ │ │ │ │ │ - [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)], │ │ │ │ │ - [names_1.default.parentData, it.parentData], │ │ │ │ │ - [names_1.default.parentDataProperty, it.parentDataProperty], │ │ │ │ │ - [names_1.default.rootData, names_1.default.rootData], │ │ │ │ │ - ]; │ │ │ │ │ - if (it.opts.dynamicRef) │ │ │ │ │ - valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]); │ │ │ │ │ - const args = (0, codegen_1._) `${dataAndSchema}, ${gen.object(...valCxt)}`; │ │ │ │ │ - return context !== codegen_1.nil ? (0, codegen_1._) `${func}.call(${context}, ${args})` : (0, codegen_1._) `${func}(${args})`; │ │ │ │ │ - } │ │ │ │ │ - code.callValidateCode = callValidateCode; │ │ │ │ │ - const newRegExp = (0, codegen_1._) `new RegExp`; │ │ │ │ │ +function schemaProperties(it, schemaMap) { │ │ │ │ │ + return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$o.alwaysValidSchema)(it, schemaMap[p])); │ │ │ │ │ +} │ │ │ │ │ +code.schemaProperties = schemaProperties; │ │ │ │ │ │ │ │ │ │ - function usePattern({ │ │ │ │ │ +function callValidateCode({ │ │ │ │ │ + schemaCode, │ │ │ │ │ + data, │ │ │ │ │ + it: { │ │ │ │ │ gen, │ │ │ │ │ - it: { │ │ │ │ │ - opts │ │ │ │ │ - } │ │ │ │ │ - }, pattern) { │ │ │ │ │ - const u = opts.unicodeRegExp ? "u" : ""; │ │ │ │ │ - const { │ │ │ │ │ - regExp │ │ │ │ │ - } = opts.code; │ │ │ │ │ - const rx = regExp(pattern, u); │ │ │ │ │ - return gen.scopeValue("pattern", { │ │ │ │ │ - key: rx.toString(), │ │ │ │ │ - ref: rx, │ │ │ │ │ - code: (0, codegen_1._) `${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`, │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ - code.usePattern = usePattern; │ │ │ │ │ - │ │ │ │ │ - function validateArray(cxt) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - data, │ │ │ │ │ - keyword, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - const valid = gen.name("valid"); │ │ │ │ │ - if (it.allErrors) { │ │ │ │ │ - const validArr = gen.let("valid", true); │ │ │ │ │ - validateItems(() => gen.assign(validArr, false)); │ │ │ │ │ - return validArr; │ │ │ │ │ - } │ │ │ │ │ - gen.var(valid, true); │ │ │ │ │ - validateItems(() => gen.break()); │ │ │ │ │ - return valid; │ │ │ │ │ - │ │ │ │ │ - function validateItems(notValid) { │ │ │ │ │ - const len = gen.const("len", (0, codegen_1._) `${data}.length`); │ │ │ │ │ - gen.forRange("i", 0, len, (i) => { │ │ │ │ │ - cxt.subschema({ │ │ │ │ │ - keyword, │ │ │ │ │ - dataProp: i, │ │ │ │ │ - dataPropType: util_1.Type.Num, │ │ │ │ │ - }, valid); │ │ │ │ │ - gen.if((0, codegen_1.not)(valid), notValid); │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ + topSchemaRef, │ │ │ │ │ + schemaPath, │ │ │ │ │ + errorPath │ │ │ │ │ + }, │ │ │ │ │ + it │ │ │ │ │ +}, func, context, passSchema) { │ │ │ │ │ + const dataAndSchema = passSchema ? (0, codegen_1$q._) `${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data; │ │ │ │ │ + const valCxt = [ │ │ │ │ │ + [names_1$5.default.instancePath, (0, codegen_1$q.strConcat)(names_1$5.default.instancePath, errorPath)], │ │ │ │ │ + [names_1$5.default.parentData, it.parentData], │ │ │ │ │ + [names_1$5.default.parentDataProperty, it.parentDataProperty], │ │ │ │ │ + [names_1$5.default.rootData, names_1$5.default.rootData], │ │ │ │ │ + ]; │ │ │ │ │ + if (it.opts.dynamicRef) │ │ │ │ │ + valCxt.push([names_1$5.default.dynamicAnchors, names_1$5.default.dynamicAnchors]); │ │ │ │ │ + const args = (0, codegen_1$q._) `${dataAndSchema}, ${gen.object(...valCxt)}`; │ │ │ │ │ + return context !== codegen_1$q.nil ? (0, codegen_1$q._) `${func}.call(${context}, ${args})` : (0, codegen_1$q._) `${func}(${args})`; │ │ │ │ │ +} │ │ │ │ │ +code.callValidateCode = callValidateCode; │ │ │ │ │ +const newRegExp = (0, codegen_1$q._) `new RegExp`; │ │ │ │ │ + │ │ │ │ │ +function usePattern({ │ │ │ │ │ + gen, │ │ │ │ │ + it: { │ │ │ │ │ + opts │ │ │ │ │ } │ │ │ │ │ - code.validateArray = validateArray; │ │ │ │ │ +}, pattern) { │ │ │ │ │ + const u = opts.unicodeRegExp ? "u" : ""; │ │ │ │ │ + const { │ │ │ │ │ + regExp │ │ │ │ │ + } = opts.code; │ │ │ │ │ + const rx = regExp(pattern, u); │ │ │ │ │ + return gen.scopeValue("pattern", { │ │ │ │ │ + key: rx.toString(), │ │ │ │ │ + ref: rx, │ │ │ │ │ + code: (0, codegen_1$q._) `${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern}, ${u})`, │ │ │ │ │ + }); │ │ │ │ │ +} │ │ │ │ │ +code.usePattern = usePattern; │ │ │ │ │ │ │ │ │ │ - function validateUnion(cxt) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - schema, │ │ │ │ │ - keyword, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - /* istanbul ignore if */ │ │ │ │ │ - if (!Array.isArray(schema)) │ │ │ │ │ - throw new Error("ajv implementation error"); │ │ │ │ │ - const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)); │ │ │ │ │ - if (alwaysValid && !it.opts.unevaluated) │ │ │ │ │ - return; │ │ │ │ │ - const valid = gen.let("valid", false); │ │ │ │ │ - const schValid = gen.name("_valid"); │ │ │ │ │ - gen.block(() => schema.forEach((_sch, i) => { │ │ │ │ │ - const schCxt = cxt.subschema({ │ │ │ │ │ +function validateArray(cxt) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + data, │ │ │ │ │ + keyword, │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + const valid = gen.name("valid"); │ │ │ │ │ + if (it.allErrors) { │ │ │ │ │ + const validArr = gen.let("valid", true); │ │ │ │ │ + validateItems(() => gen.assign(validArr, false)); │ │ │ │ │ + return validArr; │ │ │ │ │ + } │ │ │ │ │ + gen.var(valid, true); │ │ │ │ │ + validateItems(() => gen.break()); │ │ │ │ │ + return valid; │ │ │ │ │ + │ │ │ │ │ + function validateItems(notValid) { │ │ │ │ │ + const len = gen.const("len", (0, codegen_1$q._) `${data}.length`); │ │ │ │ │ + gen.forRange("i", 0, len, (i) => { │ │ │ │ │ + cxt.subschema({ │ │ │ │ │ keyword, │ │ │ │ │ - schemaProp: i, │ │ │ │ │ - compositeRule: true, │ │ │ │ │ - }, schValid); │ │ │ │ │ - gen.assign(valid, (0, codegen_1._) `${valid} || ${schValid}`); │ │ │ │ │ - const merged = cxt.mergeValidEvaluated(schCxt, schValid); │ │ │ │ │ - // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true) │ │ │ │ │ - // or if all properties and items were evaluated (it.props === true && it.items === true) │ │ │ │ │ - if (!merged) │ │ │ │ │ - gen.if((0, codegen_1.not)(valid)); │ │ │ │ │ - })); │ │ │ │ │ - cxt.result(valid, () => cxt.reset(), () => cxt.error(true)); │ │ │ │ │ + dataProp: i, │ │ │ │ │ + dataPropType: util_1$o.Type.Num, │ │ │ │ │ + }, valid); │ │ │ │ │ + gen.if((0, codegen_1$q.not)(valid), notValid); │ │ │ │ │ + }); │ │ │ │ │ } │ │ │ │ │ - code.validateUnion = validateUnion; │ │ │ │ │ - │ │ │ │ │ - return code; │ │ │ │ │ } │ │ │ │ │ +code.validateArray = validateArray; │ │ │ │ │ │ │ │ │ │ -var hasRequiredKeyword; │ │ │ │ │ - │ │ │ │ │ -function requireKeyword() { │ │ │ │ │ - if (hasRequiredKeyword) return keyword; │ │ │ │ │ - hasRequiredKeyword = 1; │ │ │ │ │ - Object.defineProperty(keyword, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const names_1 = requireNames(); │ │ │ │ │ - const code_1 = requireCode(); │ │ │ │ │ - const errors_1 = requireErrors(); │ │ │ │ │ - │ │ │ │ │ - function macroKeywordCode(cxt, def) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ +function validateUnion(cxt) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + schema, │ │ │ │ │ + keyword, │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + /* istanbul ignore if */ │ │ │ │ │ + if (!Array.isArray(schema)) │ │ │ │ │ + throw new Error("ajv implementation error"); │ │ │ │ │ + const alwaysValid = schema.some((sch) => (0, util_1$o.alwaysValidSchema)(it, sch)); │ │ │ │ │ + if (alwaysValid && !it.opts.unevaluated) │ │ │ │ │ + return; │ │ │ │ │ + const valid = gen.let("valid", false); │ │ │ │ │ + const schValid = gen.name("_valid"); │ │ │ │ │ + gen.block(() => schema.forEach((_sch, i) => { │ │ │ │ │ + const schCxt = cxt.subschema({ │ │ │ │ │ keyword, │ │ │ │ │ - schema, │ │ │ │ │ - parentSchema, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - const macroSchema = def.macro.call(it.self, schema, parentSchema, it); │ │ │ │ │ - const schemaRef = useKeyword(gen, keyword, macroSchema); │ │ │ │ │ - if (it.opts.validateSchema !== false) │ │ │ │ │ - it.self.validateSchema(macroSchema, true); │ │ │ │ │ - const valid = gen.name("valid"); │ │ │ │ │ - cxt.subschema({ │ │ │ │ │ - schema: macroSchema, │ │ │ │ │ - schemaPath: codegen_1.nil, │ │ │ │ │ - errSchemaPath: `${it.errSchemaPath}/${keyword}`, │ │ │ │ │ - topSchemaRef: schemaRef, │ │ │ │ │ + schemaProp: i, │ │ │ │ │ compositeRule: true, │ │ │ │ │ - }, valid); │ │ │ │ │ - cxt.pass(valid, () => cxt.error(true)); │ │ │ │ │ - } │ │ │ │ │ - keyword.macroKeywordCode = macroKeywordCode; │ │ │ │ │ - │ │ │ │ │ - function funcKeywordCode(cxt, def) { │ │ │ │ │ - var _a; │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - keyword, │ │ │ │ │ - schema, │ │ │ │ │ - parentSchema, │ │ │ │ │ - $data, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - checkAsyncKeyword(it, def); │ │ │ │ │ - const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate; │ │ │ │ │ - const validateRef = useKeyword(gen, keyword, validate); │ │ │ │ │ - const valid = gen.let("valid"); │ │ │ │ │ - cxt.block$data(valid, validateKeyword); │ │ │ │ │ - cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid); │ │ │ │ │ - │ │ │ │ │ - function validateKeyword() { │ │ │ │ │ - if (def.errors === false) { │ │ │ │ │ - assignValid(); │ │ │ │ │ - if (def.modifying) │ │ │ │ │ - modifyData(cxt); │ │ │ │ │ - reportErrs(() => cxt.error()); │ │ │ │ │ - } else { │ │ │ │ │ - const ruleErrs = def.async ? validateAsync() : validateSync(); │ │ │ │ │ - if (def.modifying) │ │ │ │ │ - modifyData(cxt); │ │ │ │ │ - reportErrs(() => addErrs(cxt, ruleErrs)); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function validateAsync() { │ │ │ │ │ - const ruleErrs = gen.let("ruleErrs", null); │ │ │ │ │ - gen.try(() => assignValid((0, codegen_1._) `await `), (e) => gen.assign(valid, false).if((0, codegen_1._) `${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._) `${e}.errors`), () => gen.throw(e))); │ │ │ │ │ - return ruleErrs; │ │ │ │ │ - } │ │ │ │ │ + }, schValid); │ │ │ │ │ + gen.assign(valid, (0, codegen_1$q._) `${valid} || ${schValid}`); │ │ │ │ │ + const merged = cxt.mergeValidEvaluated(schCxt, schValid); │ │ │ │ │ + // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true) │ │ │ │ │ + // or if all properties and items were evaluated (it.props === true && it.items === true) │ │ │ │ │ + if (!merged) │ │ │ │ │ + gen.if((0, codegen_1$q.not)(valid)); │ │ │ │ │ + })); │ │ │ │ │ + cxt.result(valid, () => cxt.reset(), () => cxt.error(true)); │ │ │ │ │ +} │ │ │ │ │ +code.validateUnion = validateUnion; │ │ │ │ │ │ │ │ │ │ - function validateSync() { │ │ │ │ │ - const validateErrs = (0, codegen_1._) `${validateRef}.errors`; │ │ │ │ │ - gen.assign(validateErrs, null); │ │ │ │ │ - assignValid(codegen_1.nil); │ │ │ │ │ - return validateErrs; │ │ │ │ │ - } │ │ │ │ │ +Object.defineProperty(keyword, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0; │ │ │ │ │ +const codegen_1$p = codegen; │ │ │ │ │ +const names_1$4 = names$1; │ │ │ │ │ +const code_1$9 = code; │ │ │ │ │ +const errors_1$1 = errors; │ │ │ │ │ │ │ │ │ │ - function assignValid(_await = def.async ? (0, codegen_1._) `await ` : codegen_1.nil) { │ │ │ │ │ - const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self; │ │ │ │ │ - const passSchema = !(("compile" in def && !$data) || def.schema === false); │ │ │ │ │ - gen.assign(valid, (0, codegen_1._) `${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying); │ │ │ │ │ - } │ │ │ │ │ +function macroKeywordCode(cxt, def) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + keyword, │ │ │ │ │ + schema, │ │ │ │ │ + parentSchema, │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + const macroSchema = def.macro.call(it.self, schema, parentSchema, it); │ │ │ │ │ + const schemaRef = useKeyword(gen, keyword, macroSchema); │ │ │ │ │ + if (it.opts.validateSchema !== false) │ │ │ │ │ + it.self.validateSchema(macroSchema, true); │ │ │ │ │ + const valid = gen.name("valid"); │ │ │ │ │ + cxt.subschema({ │ │ │ │ │ + schema: macroSchema, │ │ │ │ │ + schemaPath: codegen_1$p.nil, │ │ │ │ │ + errSchemaPath: `${it.errSchemaPath}/${keyword}`, │ │ │ │ │ + topSchemaRef: schemaRef, │ │ │ │ │ + compositeRule: true, │ │ │ │ │ + }, valid); │ │ │ │ │ + cxt.pass(valid, () => cxt.error(true)); │ │ │ │ │ +} │ │ │ │ │ +keyword.macroKeywordCode = macroKeywordCode; │ │ │ │ │ │ │ │ │ │ - function reportErrs(errors) { │ │ │ │ │ - var _a; │ │ │ │ │ - gen.if((0, codegen_1.not)((_a = def.valid) !== null && _a !== void 0 ? _a : valid), errors); │ │ │ │ │ +function funcKeywordCode(cxt, def) { │ │ │ │ │ + var _a; │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + keyword, │ │ │ │ │ + schema, │ │ │ │ │ + parentSchema, │ │ │ │ │ + $data, │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + checkAsyncKeyword(it, def); │ │ │ │ │ + const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate; │ │ │ │ │ + const validateRef = useKeyword(gen, keyword, validate); │ │ │ │ │ + const valid = gen.let("valid"); │ │ │ │ │ + cxt.block$data(valid, validateKeyword); │ │ │ │ │ + cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid); │ │ │ │ │ + │ │ │ │ │ + function validateKeyword() { │ │ │ │ │ + if (def.errors === false) { │ │ │ │ │ + assignValid(); │ │ │ │ │ + if (def.modifying) │ │ │ │ │ + modifyData(cxt); │ │ │ │ │ + reportErrs(() => cxt.error()); │ │ │ │ │ + } else { │ │ │ │ │ + const ruleErrs = def.async ? validateAsync() : validateSync(); │ │ │ │ │ + if (def.modifying) │ │ │ │ │ + modifyData(cxt); │ │ │ │ │ + reportErrs(() => addErrs(cxt, ruleErrs)); │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ - keyword.funcKeywordCode = funcKeywordCode; │ │ │ │ │ │ │ │ │ │ - function modifyData(cxt) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - data, │ │ │ │ │ - it │ │ │ │ │ - } = cxt; │ │ │ │ │ - gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._) `${it.parentData}[${it.parentDataProperty}]`)); │ │ │ │ │ + function validateAsync() { │ │ │ │ │ + const ruleErrs = gen.let("ruleErrs", null); │ │ │ │ │ + gen.try(() => assignValid((0, codegen_1$p._) `await `), (e) => gen.assign(valid, false).if((0, codegen_1$p._) `${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1$p._) `${e}.errors`), () => gen.throw(e))); │ │ │ │ │ + return ruleErrs; │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ - function addErrs(cxt, errs) { │ │ │ │ │ - const { │ │ │ │ │ - gen │ │ │ │ │ - } = cxt; │ │ │ │ │ - gen.if((0, codegen_1._) `Array.isArray(${errs})`, () => { │ │ │ │ │ - gen │ │ │ │ │ - .assign(names_1.default.vErrors, (0, codegen_1._) `${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`) │ │ │ │ │ - .assign(names_1.default.errors, (0, codegen_1._) `${names_1.default.vErrors}.length`); │ │ │ │ │ - (0, errors_1.extendErrors)(cxt); │ │ │ │ │ - }, () => cxt.error()); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function checkAsyncKeyword({ │ │ │ │ │ - schemaEnv │ │ │ │ │ - }, def) { │ │ │ │ │ - if (def.async && !schemaEnv.$async) │ │ │ │ │ - throw new Error("async keyword in sync schema"); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function useKeyword(gen, keyword, result) { │ │ │ │ │ - if (result === undefined) │ │ │ │ │ - throw new Error(`keyword "${keyword}" failed to compile`); │ │ │ │ │ - return gen.scopeValue("keyword", typeof result == "function" ? { │ │ │ │ │ - ref: result │ │ │ │ │ - } : { │ │ │ │ │ - ref: result, │ │ │ │ │ - code: (0, codegen_1.stringify)(result) │ │ │ │ │ - }); │ │ │ │ │ + function validateSync() { │ │ │ │ │ + const validateErrs = (0, codegen_1$p._) `${validateRef}.errors`; │ │ │ │ │ + gen.assign(validateErrs, null); │ │ │ │ │ + assignValid(codegen_1$p.nil); │ │ │ │ │ + return validateErrs; │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ - function validSchemaType(schema, schemaType, allowUndefined = false) { │ │ │ │ │ - // TODO add tests │ │ │ │ │ - return (!schemaType.length || │ │ │ │ │ - schemaType.some((st) => st === "array" ? │ │ │ │ │ - Array.isArray(schema) : │ │ │ │ │ - st === "object" ? │ │ │ │ │ - schema && typeof schema == "object" && !Array.isArray(schema) : │ │ │ │ │ - typeof schema == st || (allowUndefined && typeof schema == "undefined"))); │ │ │ │ │ + function assignValid(_await = def.async ? (0, codegen_1$p._) `await ` : codegen_1$p.nil) { │ │ │ │ │ + const passCxt = it.opts.passContext ? names_1$4.default.this : names_1$4.default.self; │ │ │ │ │ + const passSchema = !(("compile" in def && !$data) || def.schema === false); │ │ │ │ │ + gen.assign(valid, (0, codegen_1$p._) `${_await}${(0, code_1$9.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying); │ │ │ │ │ } │ │ │ │ │ - keyword.validSchemaType = validSchemaType; │ │ │ │ │ │ │ │ │ │ - function validateKeywordUsage({ │ │ │ │ │ - schema, │ │ │ │ │ - opts, │ │ │ │ │ - self, │ │ │ │ │ - errSchemaPath │ │ │ │ │ - }, def, keyword) { │ │ │ │ │ - /* istanbul ignore if */ │ │ │ │ │ - if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) { │ │ │ │ │ - throw new Error("ajv implementation error"); │ │ │ │ │ - } │ │ │ │ │ - const deps = def.dependencies; │ │ │ │ │ - if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) { │ │ │ │ │ - throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`); │ │ │ │ │ - } │ │ │ │ │ - if (def.validateSchema) { │ │ │ │ │ - const valid = def.validateSchema(schema[keyword]); │ │ │ │ │ - if (!valid) { │ │ │ │ │ - const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + │ │ │ │ │ - self.errorsText(def.validateSchema.errors); │ │ │ │ │ - if (opts.validateSchema === "log") │ │ │ │ │ - self.logger.error(msg); │ │ │ │ │ - else │ │ │ │ │ - throw new Error(msg); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ + function reportErrs(errors) { │ │ │ │ │ + var _a; │ │ │ │ │ + gen.if((0, codegen_1$p.not)((_a = def.valid) !== null && _a !== void 0 ? _a : valid), errors); │ │ │ │ │ } │ │ │ │ │ - keyword.validateKeywordUsage = validateKeywordUsage; │ │ │ │ │ - │ │ │ │ │ - return keyword; │ │ │ │ │ } │ │ │ │ │ +keyword.funcKeywordCode = funcKeywordCode; │ │ │ │ │ │ │ │ │ │ -var subschema = {}; │ │ │ │ │ - │ │ │ │ │ -var hasRequiredSubschema; │ │ │ │ │ +function modifyData(cxt) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + data, │ │ │ │ │ + it │ │ │ │ │ + } = cxt; │ │ │ │ │ + gen.if(it.parentData, () => gen.assign(data, (0, codegen_1$p._) `${it.parentData}[${it.parentDataProperty}]`)); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ -function requireSubschema() { │ │ │ │ │ - if (hasRequiredSubschema) return subschema; │ │ │ │ │ - hasRequiredSubschema = 1; │ │ │ │ │ - Object.defineProperty(subschema, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ +function addErrs(cxt, errs) { │ │ │ │ │ + const { │ │ │ │ │ + gen │ │ │ │ │ + } = cxt; │ │ │ │ │ + gen.if((0, codegen_1$p._) `Array.isArray(${errs})`, () => { │ │ │ │ │ + gen │ │ │ │ │ + .assign(names_1$4.default.vErrors, (0, codegen_1$p._) `${names_1$4.default.vErrors} === null ? ${errs} : ${names_1$4.default.vErrors}.concat(${errs})`) │ │ │ │ │ + .assign(names_1$4.default.errors, (0, codegen_1$p._) `${names_1$4.default.vErrors}.length`); │ │ │ │ │ + (0, errors_1$1.extendErrors)(cxt); │ │ │ │ │ + }, () => cxt.error()); │ │ │ │ │ +} │ │ │ │ │ + │ │ │ │ │ +function checkAsyncKeyword({ │ │ │ │ │ + schemaEnv │ │ │ │ │ +}, def) { │ │ │ │ │ + if (def.async && !schemaEnv.$async) │ │ │ │ │ + throw new Error("async keyword in sync schema"); │ │ │ │ │ +} │ │ │ │ │ + │ │ │ │ │ +function useKeyword(gen, keyword, result) { │ │ │ │ │ + if (result === undefined) │ │ │ │ │ + throw new Error(`keyword "${keyword}" failed to compile`); │ │ │ │ │ + return gen.scopeValue("keyword", typeof result == "function" ? { │ │ │ │ │ + ref: result │ │ │ │ │ + } : { │ │ │ │ │ + ref: result, │ │ │ │ │ + code: (0, codegen_1$p.stringify)(result) │ │ │ │ │ }); │ │ │ │ │ - subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const util_1 = util; │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function getSubschema(it, { │ │ │ │ │ - keyword, │ │ │ │ │ - schemaProp, │ │ │ │ │ - schema, │ │ │ │ │ - schemaPath, │ │ │ │ │ - errSchemaPath, │ │ │ │ │ - topSchemaRef │ │ │ │ │ - }) { │ │ │ │ │ - if (keyword !== undefined && schema !== undefined) { │ │ │ │ │ - throw new Error('both "keyword" and "schema" passed, only one allowed'); │ │ │ │ │ - } │ │ │ │ │ - if (keyword !== undefined) { │ │ │ │ │ - const sch = it.schema[keyword]; │ │ │ │ │ - return schemaProp === undefined ? │ │ │ │ │ - { │ │ │ │ │ - schema: sch, │ │ │ │ │ - schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`, │ │ │ │ │ - errSchemaPath: `${it.errSchemaPath}/${keyword}`, │ │ │ │ │ - } : │ │ │ │ │ - { │ │ │ │ │ - schema: sch[schemaProp], │ │ │ │ │ - schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`, │ │ │ │ │ - errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`, │ │ │ │ │ - }; │ │ │ │ │ +function validSchemaType(schema, schemaType, allowUndefined = false) { │ │ │ │ │ + // TODO add tests │ │ │ │ │ + return (!schemaType.length || │ │ │ │ │ + schemaType.some((st) => st === "array" ? │ │ │ │ │ + Array.isArray(schema) : │ │ │ │ │ + st === "object" ? │ │ │ │ │ + schema && typeof schema == "object" && !Array.isArray(schema) : │ │ │ │ │ + typeof schema == st || (allowUndefined && typeof schema == "undefined"))); │ │ │ │ │ +} │ │ │ │ │ +keyword.validSchemaType = validSchemaType; │ │ │ │ │ + │ │ │ │ │ +function validateKeywordUsage({ │ │ │ │ │ + schema, │ │ │ │ │ + opts, │ │ │ │ │ + self, │ │ │ │ │ + errSchemaPath │ │ │ │ │ +}, def, keyword) { │ │ │ │ │ + /* istanbul ignore if */ │ │ │ │ │ + if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) { │ │ │ │ │ + throw new Error("ajv implementation error"); │ │ │ │ │ + } │ │ │ │ │ + const deps = def.dependencies; │ │ │ │ │ + if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) { │ │ │ │ │ + throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`); │ │ │ │ │ + } │ │ │ │ │ + if (def.validateSchema) { │ │ │ │ │ + const valid = def.validateSchema(schema[keyword]); │ │ │ │ │ + if (!valid) { │ │ │ │ │ + const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + │ │ │ │ │ + self.errorsText(def.validateSchema.errors); │ │ │ │ │ + if (opts.validateSchema === "log") │ │ │ │ │ + self.logger.error(msg); │ │ │ │ │ + else │ │ │ │ │ + throw new Error(msg); │ │ │ │ │ } │ │ │ │ │ - if (schema !== undefined) { │ │ │ │ │ - if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) { │ │ │ │ │ - throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"'); │ │ │ │ │ - } │ │ │ │ │ - return { │ │ │ │ │ - schema, │ │ │ │ │ - schemaPath, │ │ │ │ │ - topSchemaRef, │ │ │ │ │ - errSchemaPath, │ │ │ │ │ + } │ │ │ │ │ +} │ │ │ │ │ +keyword.validateKeywordUsage = validateKeywordUsage; │ │ │ │ │ + │ │ │ │ │ +var subschema = {}; │ │ │ │ │ + │ │ │ │ │ +Object.defineProperty(subschema, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0; │ │ │ │ │ +const codegen_1$o = codegen; │ │ │ │ │ +const util_1$n = util; │ │ │ │ │ + │ │ │ │ │ +function getSubschema(it, { │ │ │ │ │ + keyword, │ │ │ │ │ + schemaProp, │ │ │ │ │ + schema, │ │ │ │ │ + schemaPath, │ │ │ │ │ + errSchemaPath, │ │ │ │ │ + topSchemaRef │ │ │ │ │ +}) { │ │ │ │ │ + if (keyword !== undefined && schema !== undefined) { │ │ │ │ │ + throw new Error('both "keyword" and "schema" passed, only one allowed'); │ │ │ │ │ + } │ │ │ │ │ + if (keyword !== undefined) { │ │ │ │ │ + const sch = it.schema[keyword]; │ │ │ │ │ + return schemaProp === undefined ? │ │ │ │ │ + { │ │ │ │ │ + schema: sch, │ │ │ │ │ + schemaPath: (0, codegen_1$o._) `${it.schemaPath}${(0, codegen_1$o.getProperty)(keyword)}`, │ │ │ │ │ + errSchemaPath: `${it.errSchemaPath}/${keyword}`, │ │ │ │ │ + } : │ │ │ │ │ + { │ │ │ │ │ + schema: sch[schemaProp], │ │ │ │ │ + schemaPath: (0, codegen_1$o._) `${it.schemaPath}${(0, codegen_1$o.getProperty)(keyword)}${(0, codegen_1$o.getProperty)(schemaProp)}`, │ │ │ │ │ + errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1$n.escapeFragment)(schemaProp)}`, │ │ │ │ │ }; │ │ │ │ │ + } │ │ │ │ │ + if (schema !== undefined) { │ │ │ │ │ + if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) { │ │ │ │ │ + throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"'); │ │ │ │ │ } │ │ │ │ │ - throw new Error('either "keyword" or "schema" must be passed'); │ │ │ │ │ + return { │ │ │ │ │ + schema, │ │ │ │ │ + schemaPath, │ │ │ │ │ + topSchemaRef, │ │ │ │ │ + errSchemaPath, │ │ │ │ │ + }; │ │ │ │ │ } │ │ │ │ │ - subschema.getSubschema = getSubschema; │ │ │ │ │ + throw new Error('either "keyword" or "schema" must be passed'); │ │ │ │ │ +} │ │ │ │ │ +subschema.getSubschema = getSubschema; │ │ │ │ │ │ │ │ │ │ - function extendSubschemaData(subschema, it, { │ │ │ │ │ - dataProp, │ │ │ │ │ - dataPropType: dpType, │ │ │ │ │ - data, │ │ │ │ │ - dataTypes, │ │ │ │ │ - propertyName │ │ │ │ │ - }) { │ │ │ │ │ - if (data !== undefined && dataProp !== undefined) { │ │ │ │ │ - throw new Error('both "data" and "dataProp" passed, only one allowed'); │ │ │ │ │ - } │ │ │ │ │ +function extendSubschemaData(subschema, it, { │ │ │ │ │ + dataProp, │ │ │ │ │ + dataPropType: dpType, │ │ │ │ │ + data, │ │ │ │ │ + dataTypes, │ │ │ │ │ + propertyName │ │ │ │ │ +}) { │ │ │ │ │ + if (data !== undefined && dataProp !== undefined) { │ │ │ │ │ + throw new Error('both "data" and "dataProp" passed, only one allowed'); │ │ │ │ │ + } │ │ │ │ │ + const { │ │ │ │ │ + gen │ │ │ │ │ + } = it; │ │ │ │ │ + if (dataProp !== undefined) { │ │ │ │ │ const { │ │ │ │ │ - gen │ │ │ │ │ + errorPath, │ │ │ │ │ + dataPathArr, │ │ │ │ │ + opts │ │ │ │ │ } = it; │ │ │ │ │ - if (dataProp !== undefined) { │ │ │ │ │ - const { │ │ │ │ │ - errorPath, │ │ │ │ │ - dataPathArr, │ │ │ │ │ - opts │ │ │ │ │ - } = it; │ │ │ │ │ - const nextData = gen.let("data", (0, codegen_1._) `${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true); │ │ │ │ │ - dataContextProps(nextData); │ │ │ │ │ - subschema.errorPath = (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`; │ │ │ │ │ - subschema.parentDataProperty = (0, codegen_1._) `${dataProp}`; │ │ │ │ │ - subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]; │ │ │ │ │ - } │ │ │ │ │ - if (data !== undefined) { │ │ │ │ │ - const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true); // replaceable if used once? │ │ │ │ │ - dataContextProps(nextData); │ │ │ │ │ - if (propertyName !== undefined) │ │ │ │ │ - subschema.propertyName = propertyName; │ │ │ │ │ - // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr │ │ │ │ │ - } │ │ │ │ │ - if (dataTypes) │ │ │ │ │ - subschema.dataTypes = dataTypes; │ │ │ │ │ - │ │ │ │ │ - function dataContextProps(_nextData) { │ │ │ │ │ - subschema.data = _nextData; │ │ │ │ │ - subschema.dataLevel = it.dataLevel + 1; │ │ │ │ │ - subschema.dataTypes = []; │ │ │ │ │ - it.definedProperties = new Set(); │ │ │ │ │ - subschema.parentData = it.data; │ │ │ │ │ - subschema.dataNames = [...it.dataNames, _nextData]; │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - subschema.extendSubschemaData = extendSubschemaData; │ │ │ │ │ - │ │ │ │ │ - function extendSubschemaMode(subschema, { │ │ │ │ │ - jtdDiscriminator, │ │ │ │ │ - jtdMetadata, │ │ │ │ │ - compositeRule, │ │ │ │ │ - createErrors, │ │ │ │ │ - allErrors │ │ │ │ │ - }) { │ │ │ │ │ - if (compositeRule !== undefined) │ │ │ │ │ - subschema.compositeRule = compositeRule; │ │ │ │ │ - if (createErrors !== undefined) │ │ │ │ │ - subschema.createErrors = createErrors; │ │ │ │ │ - if (allErrors !== undefined) │ │ │ │ │ - subschema.allErrors = allErrors; │ │ │ │ │ - subschema.jtdDiscriminator = jtdDiscriminator; // not inherited │ │ │ │ │ - subschema.jtdMetadata = jtdMetadata; // not inherited │ │ │ │ │ - } │ │ │ │ │ - subschema.extendSubschemaMode = extendSubschemaMode; │ │ │ │ │ - │ │ │ │ │ - return subschema; │ │ │ │ │ + const nextData = gen.let("data", (0, codegen_1$o._) `${it.data}${(0, codegen_1$o.getProperty)(dataProp)}`, true); │ │ │ │ │ + dataContextProps(nextData); │ │ │ │ │ + subschema.errorPath = (0, codegen_1$o.str) `${errorPath}${(0, util_1$n.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`; │ │ │ │ │ + subschema.parentDataProperty = (0, codegen_1$o._) `${dataProp}`; │ │ │ │ │ + subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]; │ │ │ │ │ + } │ │ │ │ │ + if (data !== undefined) { │ │ │ │ │ + const nextData = data instanceof codegen_1$o.Name ? data : gen.let("data", data, true); // replaceable if used once? │ │ │ │ │ + dataContextProps(nextData); │ │ │ │ │ + if (propertyName !== undefined) │ │ │ │ │ + subschema.propertyName = propertyName; │ │ │ │ │ + // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr │ │ │ │ │ + } │ │ │ │ │ + if (dataTypes) │ │ │ │ │ + subschema.dataTypes = dataTypes; │ │ │ │ │ + │ │ │ │ │ + function dataContextProps(_nextData) { │ │ │ │ │ + subschema.data = _nextData; │ │ │ │ │ + subschema.dataLevel = it.dataLevel + 1; │ │ │ │ │ + subschema.dataTypes = []; │ │ │ │ │ + it.definedProperties = new Set(); │ │ │ │ │ + subschema.parentData = it.data; │ │ │ │ │ + subschema.dataNames = [...it.dataNames, _nextData]; │ │ │ │ │ + } │ │ │ │ │ +} │ │ │ │ │ +subschema.extendSubschemaData = extendSubschemaData; │ │ │ │ │ + │ │ │ │ │ +function extendSubschemaMode(subschema, { │ │ │ │ │ + jtdDiscriminator, │ │ │ │ │ + jtdMetadata, │ │ │ │ │ + compositeRule, │ │ │ │ │ + createErrors, │ │ │ │ │ + allErrors │ │ │ │ │ +}) { │ │ │ │ │ + if (compositeRule !== undefined) │ │ │ │ │ + subschema.compositeRule = compositeRule; │ │ │ │ │ + if (createErrors !== undefined) │ │ │ │ │ + subschema.createErrors = createErrors; │ │ │ │ │ + if (allErrors !== undefined) │ │ │ │ │ + subschema.allErrors = allErrors; │ │ │ │ │ + subschema.jtdDiscriminator = jtdDiscriminator; // not inherited │ │ │ │ │ + subschema.jtdMetadata = jtdMetadata; // not inherited │ │ │ │ │ } │ │ │ │ │ +subschema.extendSubschemaMode = extendSubschemaMode; │ │ │ │ │ │ │ │ │ │ var resolve$1 = {}; │ │ │ │ │ │ │ │ │ │ // do not edit .js files directly - edit src/index.jst │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -36556,15 +36472,15 @@ │ │ │ │ │ │ │ │ │ │ var jsonSchemaTraverseExports = jsonSchemaTraverse.exports; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(resolve$1, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ resolve$1.getSchemaRefs = resolve$1.resolveUrl = resolve$1.normalizeId = resolve$1._getFullPath = resolve$1.getFullPath = resolve$1.inlineRef = void 0; │ │ │ │ │ -const util_1$l = util; │ │ │ │ │ +const util_1$m = util; │ │ │ │ │ const equal$2 = fastDeepEqual; │ │ │ │ │ const traverse = jsonSchemaTraverseExports; │ │ │ │ │ // TODO refactor to use keyword definitions │ │ │ │ │ const SIMPLE_INLINED = new Set([ │ │ │ │ │ "type", │ │ │ │ │ "format", │ │ │ │ │ "pattern", │ │ │ │ │ @@ -36619,15 +36535,15 @@ │ │ │ │ │ for (const key in schema) { │ │ │ │ │ if (key === "$ref") │ │ │ │ │ return Infinity; │ │ │ │ │ count++; │ │ │ │ │ if (SIMPLE_INLINED.has(key)) │ │ │ │ │ continue; │ │ │ │ │ if (typeof schema[key] == "object") { │ │ │ │ │ - (0, util_1$l.eachItem)(schema[key], (sch) => (count += countKeys(sch))); │ │ │ │ │ + (0, util_1$m.eachItem)(schema[key], (sch) => (count += countKeys(sch))); │ │ │ │ │ } │ │ │ │ │ if (count === Infinity) │ │ │ │ │ return Infinity; │ │ │ │ │ } │ │ │ │ │ return count; │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ @@ -36725,659 +36641,651 @@ │ │ │ │ │ │ │ │ │ │ function ambiguos(ref) { │ │ │ │ │ return new Error(`reference "${ref}" resolves to more than one schema`); │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ resolve$1.getSchemaRefs = getSchemaRefs; │ │ │ │ │ │ │ │ │ │ -var hasRequiredValidate; │ │ │ │ │ - │ │ │ │ │ -function requireValidate() { │ │ │ │ │ - if (hasRequiredValidate) return validate; │ │ │ │ │ - hasRequiredValidate = 1; │ │ │ │ │ - Object.defineProperty(validate, "__esModule", { │ │ │ │ │ - value: true │ │ │ │ │ - }); │ │ │ │ │ - validate.getData = validate.KeywordCxt = validate.validateFunctionCode = void 0; │ │ │ │ │ - const boolSchema_1 = requireBoolSchema(); │ │ │ │ │ - const dataType_1 = dataType; │ │ │ │ │ - const applicability_1 = requireApplicability(); │ │ │ │ │ - const dataType_2 = dataType; │ │ │ │ │ - const defaults_1 = requireDefaults(); │ │ │ │ │ - const keyword_1 = requireKeyword(); │ │ │ │ │ - const subschema_1 = requireSubschema(); │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ - const names_1 = requireNames(); │ │ │ │ │ - const resolve_1 = resolve$1; │ │ │ │ │ - const util_1 = util; │ │ │ │ │ - const errors_1 = requireErrors(); │ │ │ │ │ - // schema compilation - generates validation function, subschemaCode (below) is used for subschemas │ │ │ │ │ - function validateFunctionCode(it) { │ │ │ │ │ - if (isSchemaObj(it)) { │ │ │ │ │ - checkKeywords(it); │ │ │ │ │ - if (schemaCxtHasRules(it)) { │ │ │ │ │ - topSchemaObjCode(it); │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ +Object.defineProperty(validate, "__esModule", { │ │ │ │ │ + value: true │ │ │ │ │ +}); │ │ │ │ │ +validate.getData = validate.KeywordCxt = validate.validateFunctionCode = void 0; │ │ │ │ │ +const boolSchema_1 = boolSchema; │ │ │ │ │ +const dataType_1$1 = dataType; │ │ │ │ │ +const applicability_1 = applicability; │ │ │ │ │ +const dataType_2 = dataType; │ │ │ │ │ +const defaults_1 = defaults; │ │ │ │ │ +const keyword_1 = keyword; │ │ │ │ │ +const subschema_1 = subschema; │ │ │ │ │ +const codegen_1$n = codegen; │ │ │ │ │ +const names_1$3 = names$1; │ │ │ │ │ +const resolve_1$1 = resolve$1; │ │ │ │ │ +const util_1$l = util; │ │ │ │ │ +const errors_1 = errors; │ │ │ │ │ +// schema compilation - generates validation function, subschemaCode (below) is used for subschemas │ │ │ │ │ +function validateFunctionCode(it) { │ │ │ │ │ + if (isSchemaObj(it)) { │ │ │ │ │ + checkKeywords(it); │ │ │ │ │ + if (schemaCxtHasRules(it)) { │ │ │ │ │ + topSchemaObjCode(it); │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ - validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it)); │ │ │ │ │ } │ │ │ │ │ - validate.validateFunctionCode = validateFunctionCode; │ │ │ │ │ + validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it)); │ │ │ │ │ +} │ │ │ │ │ +validate.validateFunctionCode = validateFunctionCode; │ │ │ │ │ │ │ │ │ │ - function validateFunction({ │ │ │ │ │ - gen, │ │ │ │ │ - validateName, │ │ │ │ │ - schema, │ │ │ │ │ - schemaEnv, │ │ │ │ │ - opts │ │ │ │ │ - }, body) { │ │ │ │ │ - if (opts.code.es5) { │ │ │ │ │ - gen.func(validateName, (0, codegen_1._) `${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => { │ │ │ │ │ - gen.code((0, codegen_1._) `"use strict"; ${funcSourceUrl(schema, opts)}`); │ │ │ │ │ - destructureValCxtES5(gen, opts); │ │ │ │ │ - gen.code(body); │ │ │ │ │ - }); │ │ │ │ │ - } else { │ │ │ │ │ - gen.func(validateName, (0, codegen_1._) `${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body)); │ │ │ │ │ - } │ │ │ │ │ +function validateFunction({ │ │ │ │ │ + gen, │ │ │ │ │ + validateName, │ │ │ │ │ + schema, │ │ │ │ │ + schemaEnv, │ │ │ │ │ + opts │ │ │ │ │ +}, body) { │ │ │ │ │ + if (opts.code.es5) { │ │ │ │ │ + gen.func(validateName, (0, codegen_1$n._) `${names_1$3.default.data}, ${names_1$3.default.valCxt}`, schemaEnv.$async, () => { │ │ │ │ │ + gen.code((0, codegen_1$n._) `"use strict"; ${funcSourceUrl(schema, opts)}`); │ │ │ │ │ + destructureValCxtES5(gen, opts); │ │ │ │ │ + gen.code(body); │ │ │ │ │ + }); │ │ │ │ │ + } else { │ │ │ │ │ + gen.func(validateName, (0, codegen_1$n._) `${names_1$3.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body)); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function destructureValCxt(opts) { │ │ │ │ │ - return (0, codegen_1._) `{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._) `, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`; │ │ │ │ │ - } │ │ │ │ │ +function destructureValCxt(opts) { │ │ │ │ │ + return (0, codegen_1$n._) `{${names_1$3.default.instancePath}="", ${names_1$3.default.parentData}, ${names_1$3.default.parentDataProperty}, ${names_1$3.default.rootData}=${names_1$3.default.data}${opts.dynamicRef ? (0, codegen_1$n._) `, ${names_1$3.default.dynamicAnchors}={}` : codegen_1$n.nil}}={}`; │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function destructureValCxtES5(gen, opts) { │ │ │ │ │ - gen.if(names_1.default.valCxt, () => { │ │ │ │ │ - gen.var(names_1.default.instancePath, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.instancePath}`); │ │ │ │ │ - gen.var(names_1.default.parentData, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.parentData}`); │ │ │ │ │ - gen.var(names_1.default.parentDataProperty, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.parentDataProperty}`); │ │ │ │ │ - gen.var(names_1.default.rootData, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.rootData}`); │ │ │ │ │ - if (opts.dynamicRef) │ │ │ │ │ - gen.var(names_1.default.dynamicAnchors, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`); │ │ │ │ │ - }, () => { │ │ │ │ │ - gen.var(names_1.default.instancePath, (0, codegen_1._) `""`); │ │ │ │ │ - gen.var(names_1.default.parentData, (0, codegen_1._) `undefined`); │ │ │ │ │ - gen.var(names_1.default.parentDataProperty, (0, codegen_1._) `undefined`); │ │ │ │ │ - gen.var(names_1.default.rootData, names_1.default.data); │ │ │ │ │ - if (opts.dynamicRef) │ │ │ │ │ - gen.var(names_1.default.dynamicAnchors, (0, codegen_1._) `{}`); │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ +function destructureValCxtES5(gen, opts) { │ │ │ │ │ + gen.if(names_1$3.default.valCxt, () => { │ │ │ │ │ + gen.var(names_1$3.default.instancePath, (0, codegen_1$n._) `${names_1$3.default.valCxt}.${names_1$3.default.instancePath}`); │ │ │ │ │ + gen.var(names_1$3.default.parentData, (0, codegen_1$n._) `${names_1$3.default.valCxt}.${names_1$3.default.parentData}`); │ │ │ │ │ + gen.var(names_1$3.default.parentDataProperty, (0, codegen_1$n._) `${names_1$3.default.valCxt}.${names_1$3.default.parentDataProperty}`); │ │ │ │ │ + gen.var(names_1$3.default.rootData, (0, codegen_1$n._) `${names_1$3.default.valCxt}.${names_1$3.default.rootData}`); │ │ │ │ │ + if (opts.dynamicRef) │ │ │ │ │ + gen.var(names_1$3.default.dynamicAnchors, (0, codegen_1$n._) `${names_1$3.default.valCxt}.${names_1$3.default.dynamicAnchors}`); │ │ │ │ │ + }, () => { │ │ │ │ │ + gen.var(names_1$3.default.instancePath, (0, codegen_1$n._) `""`); │ │ │ │ │ + gen.var(names_1$3.default.parentData, (0, codegen_1$n._) `undefined`); │ │ │ │ │ + gen.var(names_1$3.default.parentDataProperty, (0, codegen_1$n._) `undefined`); │ │ │ │ │ + gen.var(names_1$3.default.rootData, names_1$3.default.data); │ │ │ │ │ + if (opts.dynamicRef) │ │ │ │ │ + gen.var(names_1$3.default.dynamicAnchors, (0, codegen_1$n._) `{}`); │ │ │ │ │ + }); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function topSchemaObjCode(it) { │ │ │ │ │ - const { │ │ │ │ │ - schema, │ │ │ │ │ - opts, │ │ │ │ │ - gen │ │ │ │ │ - } = it; │ │ │ │ │ - validateFunction(it, () => { │ │ │ │ │ - if (opts.$comment && schema.$comment) │ │ │ │ │ - commentKeyword(it); │ │ │ │ │ - checkNoDefault(it); │ │ │ │ │ - gen.let(names_1.default.vErrors, null); │ │ │ │ │ - gen.let(names_1.default.errors, 0); │ │ │ │ │ - if (opts.unevaluated) │ │ │ │ │ - resetEvaluated(it); │ │ │ │ │ - typeAndKeywords(it); │ │ │ │ │ - returnResults(it); │ │ │ │ │ - }); │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ +function topSchemaObjCode(it) { │ │ │ │ │ + const { │ │ │ │ │ + schema, │ │ │ │ │ + opts, │ │ │ │ │ + gen │ │ │ │ │ + } = it; │ │ │ │ │ + validateFunction(it, () => { │ │ │ │ │ + if (opts.$comment && schema.$comment) │ │ │ │ │ + commentKeyword(it); │ │ │ │ │ + checkNoDefault(it); │ │ │ │ │ + gen.let(names_1$3.default.vErrors, null); │ │ │ │ │ + gen.let(names_1$3.default.errors, 0); │ │ │ │ │ + if (opts.unevaluated) │ │ │ │ │ + resetEvaluated(it); │ │ │ │ │ + typeAndKeywords(it); │ │ │ │ │ + returnResults(it); │ │ │ │ │ + }); │ │ │ │ │ + return; │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function resetEvaluated(it) { │ │ │ │ │ - // TODO maybe some hook to execute it in the end to check whether props/items are Name, as in assignEvaluated │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - validateName │ │ │ │ │ - } = it; │ │ │ │ │ - it.evaluated = gen.const("evaluated", (0, codegen_1._) `${validateName}.evaluated`); │ │ │ │ │ - gen.if((0, codegen_1._) `${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._) `${it.evaluated}.props`, (0, codegen_1._) `undefined`)); │ │ │ │ │ - gen.if((0, codegen_1._) `${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._) `${it.evaluated}.items`, (0, codegen_1._) `undefined`)); │ │ │ │ │ - } │ │ │ │ │ +function resetEvaluated(it) { │ │ │ │ │ + // TODO maybe some hook to execute it in the end to check whether props/items are Name, as in assignEvaluated │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + validateName │ │ │ │ │ + } = it; │ │ │ │ │ + it.evaluated = gen.const("evaluated", (0, codegen_1$n._) `${validateName}.evaluated`); │ │ │ │ │ + gen.if((0, codegen_1$n._) `${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1$n._) `${it.evaluated}.props`, (0, codegen_1$n._) `undefined`)); │ │ │ │ │ + gen.if((0, codegen_1$n._) `${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1$n._) `${it.evaluated}.items`, (0, codegen_1$n._) `undefined`)); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function funcSourceUrl(schema, opts) { │ │ │ │ │ - const schId = typeof schema == "object" && schema[opts.schemaId]; │ │ │ │ │ - return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._) `/*# sourceURL=${schId} */` : codegen_1.nil; │ │ │ │ │ - } │ │ │ │ │ - // schema compilation - this function is used recursively to generate code for sub-schemas │ │ │ │ │ - function subschemaCode(it, valid) { │ │ │ │ │ - if (isSchemaObj(it)) { │ │ │ │ │ - checkKeywords(it); │ │ │ │ │ - if (schemaCxtHasRules(it)) { │ │ │ │ │ - subSchemaObjCode(it, valid); │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ +function funcSourceUrl(schema, opts) { │ │ │ │ │ + const schId = typeof schema == "object" && schema[opts.schemaId]; │ │ │ │ │ + return schId && (opts.code.source || opts.code.process) ? (0, codegen_1$n._) `/*# sourceURL=${schId} */` : codegen_1$n.nil; │ │ │ │ │ +} │ │ │ │ │ +// schema compilation - this function is used recursively to generate code for sub-schemas │ │ │ │ │ +function subschemaCode(it, valid) { │ │ │ │ │ + if (isSchemaObj(it)) { │ │ │ │ │ + checkKeywords(it); │ │ │ │ │ + if (schemaCxtHasRules(it)) { │ │ │ │ │ + subSchemaObjCode(it, valid); │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ - (0, boolSchema_1.boolOrEmptySchema)(it, valid); │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function schemaCxtHasRules({ │ │ │ │ │ - schema, │ │ │ │ │ - self │ │ │ │ │ - }) { │ │ │ │ │ - if (typeof schema == "boolean") │ │ │ │ │ - return !schema; │ │ │ │ │ - for (const key in schema) │ │ │ │ │ - if (self.RULES.all[key]) │ │ │ │ │ - return true; │ │ │ │ │ - return false; │ │ │ │ │ } │ │ │ │ │ + (0, boolSchema_1.boolOrEmptySchema)(it, valid); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function isSchemaObj(it) { │ │ │ │ │ - return typeof it.schema != "boolean"; │ │ │ │ │ - } │ │ │ │ │ +function schemaCxtHasRules({ │ │ │ │ │ + schema, │ │ │ │ │ + self │ │ │ │ │ +}) { │ │ │ │ │ + if (typeof schema == "boolean") │ │ │ │ │ + return !schema; │ │ │ │ │ + for (const key in schema) │ │ │ │ │ + if (self.RULES.all[key]) │ │ │ │ │ + return true; │ │ │ │ │ + return false; │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function subSchemaObjCode(it, valid) { │ │ │ │ │ - const { │ │ │ │ │ - schema, │ │ │ │ │ - gen, │ │ │ │ │ - opts │ │ │ │ │ - } = it; │ │ │ │ │ - if (opts.$comment && schema.$comment) │ │ │ │ │ - commentKeyword(it); │ │ │ │ │ - updateContext(it); │ │ │ │ │ - checkAsyncSchema(it); │ │ │ │ │ - const errsCount = gen.const("_errs", names_1.default.errors); │ │ │ │ │ - typeAndKeywords(it, errsCount); │ │ │ │ │ - // TODO var │ │ │ │ │ - gen.var(valid, (0, codegen_1._) `${errsCount} === ${names_1.default.errors}`); │ │ │ │ │ - } │ │ │ │ │ +function isSchemaObj(it) { │ │ │ │ │ + return typeof it.schema != "boolean"; │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkKeywords(it) { │ │ │ │ │ - (0, util_1.checkUnknownRules)(it); │ │ │ │ │ - checkRefsAndKeywords(it); │ │ │ │ │ - } │ │ │ │ │ +function subSchemaObjCode(it, valid) { │ │ │ │ │ + const { │ │ │ │ │ + schema, │ │ │ │ │ + gen, │ │ │ │ │ + opts │ │ │ │ │ + } = it; │ │ │ │ │ + if (opts.$comment && schema.$comment) │ │ │ │ │ + commentKeyword(it); │ │ │ │ │ + updateContext(it); │ │ │ │ │ + checkAsyncSchema(it); │ │ │ │ │ + const errsCount = gen.const("_errs", names_1$3.default.errors); │ │ │ │ │ + typeAndKeywords(it, errsCount); │ │ │ │ │ + // TODO var │ │ │ │ │ + gen.var(valid, (0, codegen_1$n._) `${errsCount} === ${names_1$3.default.errors}`); │ │ │ │ │ +} │ │ │ │ │ + │ │ │ │ │ +function checkKeywords(it) { │ │ │ │ │ + (0, util_1$l.checkUnknownRules)(it); │ │ │ │ │ + checkRefsAndKeywords(it); │ │ │ │ │ +} │ │ │ │ │ + │ │ │ │ │ +function typeAndKeywords(it, errsCount) { │ │ │ │ │ + if (it.opts.jtd) │ │ │ │ │ + return schemaKeywords(it, [], false, errsCount); │ │ │ │ │ + const types = (0, dataType_1$1.getSchemaTypes)(it.schema); │ │ │ │ │ + const checkedTypes = (0, dataType_1$1.coerceAndCheckDataType)(it, types); │ │ │ │ │ + schemaKeywords(it, types, !checkedTypes, errsCount); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function typeAndKeywords(it, errsCount) { │ │ │ │ │ - if (it.opts.jtd) │ │ │ │ │ - return schemaKeywords(it, [], false, errsCount); │ │ │ │ │ - const types = (0, dataType_1.getSchemaTypes)(it.schema); │ │ │ │ │ - const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types); │ │ │ │ │ - schemaKeywords(it, types, !checkedTypes, errsCount); │ │ │ │ │ +function checkRefsAndKeywords(it) { │ │ │ │ │ + const { │ │ │ │ │ + schema, │ │ │ │ │ + errSchemaPath, │ │ │ │ │ + opts, │ │ │ │ │ + self │ │ │ │ │ + } = it; │ │ │ │ │ + if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1$l.schemaHasRulesButRef)(schema, self.RULES)) { │ │ │ │ │ + self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkRefsAndKeywords(it) { │ │ │ │ │ - const { │ │ │ │ │ - schema, │ │ │ │ │ - errSchemaPath, │ │ │ │ │ - opts, │ │ │ │ │ - self │ │ │ │ │ - } = it; │ │ │ │ │ - if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) { │ │ │ │ │ - self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`); │ │ │ │ │ - } │ │ │ │ │ +function checkNoDefault(it) { │ │ │ │ │ + const { │ │ │ │ │ + schema, │ │ │ │ │ + opts │ │ │ │ │ + } = it; │ │ │ │ │ + if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) { │ │ │ │ │ + (0, util_1$l.checkStrictMode)(it, "default is ignored in the schema root"); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkNoDefault(it) { │ │ │ │ │ - const { │ │ │ │ │ - schema, │ │ │ │ │ - opts │ │ │ │ │ - } = it; │ │ │ │ │ - if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) { │ │ │ │ │ - (0, util_1.checkStrictMode)(it, "default is ignored in the schema root"); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ +function updateContext(it) { │ │ │ │ │ + const schId = it.schema[it.opts.schemaId]; │ │ │ │ │ + if (schId) │ │ │ │ │ + it.baseId = (0, resolve_1$1.resolveUrl)(it.opts.uriResolver, it.baseId, schId); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function updateContext(it) { │ │ │ │ │ - const schId = it.schema[it.opts.schemaId]; │ │ │ │ │ - if (schId) │ │ │ │ │ - it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId); │ │ │ │ │ - } │ │ │ │ │ +function checkAsyncSchema(it) { │ │ │ │ │ + if (it.schema.$async && !it.schemaEnv.$async) │ │ │ │ │ + throw new Error("async schema in sync schema"); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkAsyncSchema(it) { │ │ │ │ │ - if (it.schema.$async && !it.schemaEnv.$async) │ │ │ │ │ - throw new Error("async schema in sync schema"); │ │ │ │ │ +function commentKeyword({ │ │ │ │ │ + gen, │ │ │ │ │ + schemaEnv, │ │ │ │ │ + schema, │ │ │ │ │ + errSchemaPath, │ │ │ │ │ + opts │ │ │ │ │ +}) { │ │ │ │ │ + const msg = schema.$comment; │ │ │ │ │ + if (opts.$comment === true) { │ │ │ │ │ + gen.code((0, codegen_1$n._) `${names_1$3.default.self}.logger.log(${msg})`); │ │ │ │ │ + } else if (typeof opts.$comment == "function") { │ │ │ │ │ + const schemaPath = (0, codegen_1$n.str) `${errSchemaPath}/$comment`; │ │ │ │ │ + const rootName = gen.scopeValue("root", { │ │ │ │ │ + ref: schemaEnv.root │ │ │ │ │ + }); │ │ │ │ │ + gen.code((0, codegen_1$n._) `${names_1$3.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function commentKeyword({ │ │ │ │ │ +function returnResults(it) { │ │ │ │ │ + const { │ │ │ │ │ gen, │ │ │ │ │ schemaEnv, │ │ │ │ │ - schema, │ │ │ │ │ - errSchemaPath, │ │ │ │ │ + validateName, │ │ │ │ │ + ValidationError, │ │ │ │ │ opts │ │ │ │ │ - }) { │ │ │ │ │ - const msg = schema.$comment; │ │ │ │ │ - if (opts.$comment === true) { │ │ │ │ │ - gen.code((0, codegen_1._) `${names_1.default.self}.logger.log(${msg})`); │ │ │ │ │ - } else if (typeof opts.$comment == "function") { │ │ │ │ │ - const schemaPath = (0, codegen_1.str) `${errSchemaPath}/$comment`; │ │ │ │ │ - const rootName = gen.scopeValue("root", { │ │ │ │ │ - ref: schemaEnv.root │ │ │ │ │ - }); │ │ │ │ │ - gen.code((0, codegen_1._) `${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`); │ │ │ │ │ - } │ │ │ │ │ + } = it; │ │ │ │ │ + if (schemaEnv.$async) { │ │ │ │ │ + // TODO assign unevaluated │ │ │ │ │ + gen.if((0, codegen_1$n._) `${names_1$3.default.errors} === 0`, () => gen.return(names_1$3.default.data), () => gen.throw((0, codegen_1$n._) `new ${ValidationError}(${names_1$3.default.vErrors})`)); │ │ │ │ │ + } else { │ │ │ │ │ + gen.assign((0, codegen_1$n._) `${validateName}.errors`, names_1$3.default.vErrors); │ │ │ │ │ + if (opts.unevaluated) │ │ │ │ │ + assignEvaluated(it); │ │ │ │ │ + gen.return((0, codegen_1$n._) `${names_1$3.default.errors} === 0`); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function returnResults(it) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - schemaEnv, │ │ │ │ │ - validateName, │ │ │ │ │ - ValidationError, │ │ │ │ │ - opts │ │ │ │ │ - } = it; │ │ │ │ │ - if (schemaEnv.$async) { │ │ │ │ │ - // TODO assign unevaluated │ │ │ │ │ - gen.if((0, codegen_1._) `${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._) `new ${ValidationError}(${names_1.default.vErrors})`)); │ │ │ │ │ - } else { │ │ │ │ │ - gen.assign((0, codegen_1._) `${validateName}.errors`, names_1.default.vErrors); │ │ │ │ │ - if (opts.unevaluated) │ │ │ │ │ - assignEvaluated(it); │ │ │ │ │ - gen.return((0, codegen_1._) `${names_1.default.errors} === 0`); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ +function assignEvaluated({ │ │ │ │ │ + gen, │ │ │ │ │ + evaluated, │ │ │ │ │ + props, │ │ │ │ │ + items │ │ │ │ │ +}) { │ │ │ │ │ + if (props instanceof codegen_1$n.Name) │ │ │ │ │ + gen.assign((0, codegen_1$n._) `${evaluated}.props`, props); │ │ │ │ │ + if (items instanceof codegen_1$n.Name) │ │ │ │ │ + gen.assign((0, codegen_1$n._) `${evaluated}.items`, items); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function assignEvaluated({ │ │ │ │ │ +function schemaKeywords(it, types, typeErrors, errsCount) { │ │ │ │ │ + const { │ │ │ │ │ gen, │ │ │ │ │ - evaluated, │ │ │ │ │ - props, │ │ │ │ │ - items │ │ │ │ │ - }) { │ │ │ │ │ - if (props instanceof codegen_1.Name) │ │ │ │ │ - gen.assign((0, codegen_1._) `${evaluated}.props`, props); │ │ │ │ │ - if (items instanceof codegen_1.Name) │ │ │ │ │ - gen.assign((0, codegen_1._) `${evaluated}.items`, items); │ │ │ │ │ + schema, │ │ │ │ │ + data, │ │ │ │ │ + allErrors, │ │ │ │ │ + opts, │ │ │ │ │ + self │ │ │ │ │ + } = it; │ │ │ │ │ + const { │ │ │ │ │ + RULES │ │ │ │ │ + } = self; │ │ │ │ │ + if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1$l.schemaHasRulesButRef)(schema, RULES))) { │ │ │ │ │ + gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition)); // TODO typecast │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ + if (!opts.jtd) │ │ │ │ │ + checkStrictTypes(it, types); │ │ │ │ │ + gen.block(() => { │ │ │ │ │ + for (const group of RULES.rules) │ │ │ │ │ + groupKeywords(group); │ │ │ │ │ + groupKeywords(RULES.post); │ │ │ │ │ + }); │ │ │ │ │ │ │ │ │ │ - function schemaKeywords(it, types, typeErrors, errsCount) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - schema, │ │ │ │ │ - data, │ │ │ │ │ - allErrors, │ │ │ │ │ - opts, │ │ │ │ │ - self │ │ │ │ │ - } = it; │ │ │ │ │ - const { │ │ │ │ │ - RULES │ │ │ │ │ - } = self; │ │ │ │ │ - if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) { │ │ │ │ │ - gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition)); // TODO typecast │ │ │ │ │ + function groupKeywords(group) { │ │ │ │ │ + if (!(0, applicability_1.shouldUseGroup)(schema, group)) │ │ │ │ │ return; │ │ │ │ │ - } │ │ │ │ │ - if (!opts.jtd) │ │ │ │ │ - checkStrictTypes(it, types); │ │ │ │ │ - gen.block(() => { │ │ │ │ │ - for (const group of RULES.rules) │ │ │ │ │ - groupKeywords(group); │ │ │ │ │ - groupKeywords(RULES.post); │ │ │ │ │ - }); │ │ │ │ │ - │ │ │ │ │ - function groupKeywords(group) { │ │ │ │ │ - if (!(0, applicability_1.shouldUseGroup)(schema, group)) │ │ │ │ │ - return; │ │ │ │ │ - if (group.type) { │ │ │ │ │ - gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers)); │ │ │ │ │ - iterateKeywords(it, group); │ │ │ │ │ - if (types.length === 1 && types[0] === group.type && typeErrors) { │ │ │ │ │ - gen.else(); │ │ │ │ │ - (0, dataType_2.reportTypeError)(it); │ │ │ │ │ - } │ │ │ │ │ - gen.endIf(); │ │ │ │ │ - } else { │ │ │ │ │ - iterateKeywords(it, group); │ │ │ │ │ + if (group.type) { │ │ │ │ │ + gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers)); │ │ │ │ │ + iterateKeywords(it, group); │ │ │ │ │ + if (types.length === 1 && types[0] === group.type && typeErrors) { │ │ │ │ │ + gen.else(); │ │ │ │ │ + (0, dataType_2.reportTypeError)(it); │ │ │ │ │ } │ │ │ │ │ - // TODO make it "ok" call? │ │ │ │ │ - if (!allErrors) │ │ │ │ │ - gen.if((0, codegen_1._) `${names_1.default.errors} === ${errsCount || 0}`); │ │ │ │ │ + gen.endIf(); │ │ │ │ │ + } else { │ │ │ │ │ + iterateKeywords(it, group); │ │ │ │ │ } │ │ │ │ │ + // TODO make it "ok" call? │ │ │ │ │ + if (!allErrors) │ │ │ │ │ + gen.if((0, codegen_1$n._) `${names_1$3.default.errors} === ${errsCount || 0}`); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function iterateKeywords(it, group) { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - schema, │ │ │ │ │ - opts: { │ │ │ │ │ - useDefaults │ │ │ │ │ - }, │ │ │ │ │ - } = it; │ │ │ │ │ - if (useDefaults) │ │ │ │ │ - (0, defaults_1.assignDefaults)(it, group.type); │ │ │ │ │ - gen.block(() => { │ │ │ │ │ - for (const rule of group.rules) { │ │ │ │ │ - if ((0, applicability_1.shouldUseRule)(schema, rule)) { │ │ │ │ │ - keywordCode(it, rule.keyword, rule.definition, group.type); │ │ │ │ │ - } │ │ │ │ │ +function iterateKeywords(it, group) { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + schema, │ │ │ │ │ + opts: { │ │ │ │ │ + useDefaults │ │ │ │ │ + }, │ │ │ │ │ + } = it; │ │ │ │ │ + if (useDefaults) │ │ │ │ │ + (0, defaults_1.assignDefaults)(it, group.type); │ │ │ │ │ + gen.block(() => { │ │ │ │ │ + for (const rule of group.rules) { │ │ │ │ │ + if ((0, applicability_1.shouldUseRule)(schema, rule)) { │ │ │ │ │ + keywordCode(it, rule.keyword, rule.definition, group.type); │ │ │ │ │ } │ │ │ │ │ - }); │ │ │ │ │ - } │ │ │ │ │ + } │ │ │ │ │ + }); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkStrictTypes(it, types) { │ │ │ │ │ - if (it.schemaEnv.meta || !it.opts.strictTypes) │ │ │ │ │ - return; │ │ │ │ │ - checkContextTypes(it, types); │ │ │ │ │ - if (!it.opts.allowUnionTypes) │ │ │ │ │ - checkMultipleTypes(it, types); │ │ │ │ │ - checkKeywordTypes(it, it.dataTypes); │ │ │ │ │ - } │ │ │ │ │ +function checkStrictTypes(it, types) { │ │ │ │ │ + if (it.schemaEnv.meta || !it.opts.strictTypes) │ │ │ │ │ + return; │ │ │ │ │ + checkContextTypes(it, types); │ │ │ │ │ + if (!it.opts.allowUnionTypes) │ │ │ │ │ + checkMultipleTypes(it, types); │ │ │ │ │ + checkKeywordTypes(it, it.dataTypes); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkContextTypes(it, types) { │ │ │ │ │ - if (!types.length) │ │ │ │ │ - return; │ │ │ │ │ - if (!it.dataTypes.length) { │ │ │ │ │ - it.dataTypes = types; │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ - types.forEach((t) => { │ │ │ │ │ - if (!includesType(it.dataTypes, t)) { │ │ │ │ │ - strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`); │ │ │ │ │ - } │ │ │ │ │ - }); │ │ │ │ │ - narrowSchemaTypes(it, types); │ │ │ │ │ +function checkContextTypes(it, types) { │ │ │ │ │ + if (!types.length) │ │ │ │ │ + return; │ │ │ │ │ + if (!it.dataTypes.length) { │ │ │ │ │ + it.dataTypes = types; │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ - │ │ │ │ │ - function checkMultipleTypes(it, ts) { │ │ │ │ │ - if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) { │ │ │ │ │ - strictTypesError(it, "use allowUnionTypes to allow union type keyword"); │ │ │ │ │ + types.forEach((t) => { │ │ │ │ │ + if (!includesType(it.dataTypes, t)) { │ │ │ │ │ + strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`); │ │ │ │ │ } │ │ │ │ │ + }); │ │ │ │ │ + narrowSchemaTypes(it, types); │ │ │ │ │ +} │ │ │ │ │ + │ │ │ │ │ +function checkMultipleTypes(it, ts) { │ │ │ │ │ + if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) { │ │ │ │ │ + strictTypesError(it, "use allowUnionTypes to allow union type keyword"); │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function checkKeywordTypes(it, ts) { │ │ │ │ │ - const rules = it.self.RULES.all; │ │ │ │ │ - for (const keyword in rules) { │ │ │ │ │ - const rule = rules[keyword]; │ │ │ │ │ - if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) { │ │ │ │ │ - const { │ │ │ │ │ - type │ │ │ │ │ - } = rule.definition; │ │ │ │ │ - if (type.length && !type.some((t) => hasApplicableType(ts, t))) { │ │ │ │ │ - strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`); │ │ │ │ │ - } │ │ │ │ │ +function checkKeywordTypes(it, ts) { │ │ │ │ │ + const rules = it.self.RULES.all; │ │ │ │ │ + for (const keyword in rules) { │ │ │ │ │ + const rule = rules[keyword]; │ │ │ │ │ + if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) { │ │ │ │ │ + const { │ │ │ │ │ + type │ │ │ │ │ + } = rule.definition; │ │ │ │ │ + if (type.length && !type.some((t) => hasApplicableType(ts, t))) { │ │ │ │ │ + strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`); │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function hasApplicableType(schTs, kwdT) { │ │ │ │ │ - return schTs.includes(kwdT) || (kwdT === "number" && schTs.includes("integer")); │ │ │ │ │ - } │ │ │ │ │ +function hasApplicableType(schTs, kwdT) { │ │ │ │ │ + return schTs.includes(kwdT) || (kwdT === "number" && schTs.includes("integer")); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function includesType(ts, t) { │ │ │ │ │ - return ts.includes(t) || (t === "integer" && ts.includes("number")); │ │ │ │ │ - } │ │ │ │ │ +function includesType(ts, t) { │ │ │ │ │ + return ts.includes(t) || (t === "integer" && ts.includes("number")); │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function narrowSchemaTypes(it, withTypes) { │ │ │ │ │ - const ts = []; │ │ │ │ │ - for (const t of it.dataTypes) { │ │ │ │ │ - if (includesType(withTypes, t)) │ │ │ │ │ - ts.push(t); │ │ │ │ │ - else if (withTypes.includes("integer") && t === "number") │ │ │ │ │ - ts.push("integer"); │ │ │ │ │ - } │ │ │ │ │ - it.dataTypes = ts; │ │ │ │ │ +function narrowSchemaTypes(it, withTypes) { │ │ │ │ │ + const ts = []; │ │ │ │ │ + for (const t of it.dataTypes) { │ │ │ │ │ + if (includesType(withTypes, t)) │ │ │ │ │ + ts.push(t); │ │ │ │ │ + else if (withTypes.includes("integer") && t === "number") │ │ │ │ │ + ts.push("integer"); │ │ │ │ │ } │ │ │ │ │ + it.dataTypes = ts; │ │ │ │ │ +} │ │ │ │ │ │ │ │ │ │ - function strictTypesError(it, msg) { │ │ │ │ │ - const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; │ │ │ │ │ - msg += ` at "${schemaPath}" (strictTypes)`; │ │ │ │ │ - (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes); │ │ │ │ │ - } │ │ │ │ │ - class KeywordCxt { │ │ │ │ │ - constructor(it, def, keyword) { │ │ │ │ │ - (0, keyword_1.validateKeywordUsage)(it, def, keyword); │ │ │ │ │ - this.gen = it.gen; │ │ │ │ │ - this.allErrors = it.allErrors; │ │ │ │ │ - this.keyword = keyword; │ │ │ │ │ - this.data = it.data; │ │ │ │ │ - this.schema = it.schema[keyword]; │ │ │ │ │ - this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data; │ │ │ │ │ - this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data); │ │ │ │ │ - this.schemaType = def.schemaType; │ │ │ │ │ - this.parentSchema = it.schema; │ │ │ │ │ - this.params = {}; │ │ │ │ │ - this.it = it; │ │ │ │ │ - this.def = def; │ │ │ │ │ - if (this.$data) { │ │ │ │ │ - this.schemaCode = it.gen.const("vSchema", getData(this.$data, it)); │ │ │ │ │ - } else { │ │ │ │ │ - this.schemaCode = this.schemaValue; │ │ │ │ │ - if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) { │ │ │ │ │ - throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - if ("code" in def ? def.trackErrors : def.errors !== false) { │ │ │ │ │ - this.errsCount = it.gen.const("_errs", names_1.default.errors); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - result(condition, successAction, failAction) { │ │ │ │ │ - this.failResult((0, codegen_1.not)(condition), successAction, failAction); │ │ │ │ │ - } │ │ │ │ │ - failResult(condition, successAction, failAction) { │ │ │ │ │ - this.gen.if(condition); │ │ │ │ │ - if (failAction) │ │ │ │ │ - failAction(); │ │ │ │ │ - else │ │ │ │ │ - this.error(); │ │ │ │ │ - if (successAction) { │ │ │ │ │ - this.gen.else(); │ │ │ │ │ - successAction(); │ │ │ │ │ - if (this.allErrors) │ │ │ │ │ - this.gen.endIf(); │ │ │ │ │ - } else { │ │ │ │ │ - if (this.allErrors) │ │ │ │ │ - this.gen.endIf(); │ │ │ │ │ - else │ │ │ │ │ - this.gen.else(); │ │ │ │ │ +function strictTypesError(it, msg) { │ │ │ │ │ + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; │ │ │ │ │ + msg += ` at "${schemaPath}" (strictTypes)`; │ │ │ │ │ + (0, util_1$l.checkStrictMode)(it, msg, it.opts.strictTypes); │ │ │ │ │ +} │ │ │ │ │ +class KeywordCxt { │ │ │ │ │ + constructor(it, def, keyword) { │ │ │ │ │ + (0, keyword_1.validateKeywordUsage)(it, def, keyword); │ │ │ │ │ + this.gen = it.gen; │ │ │ │ │ + this.allErrors = it.allErrors; │ │ │ │ │ + this.keyword = keyword; │ │ │ │ │ + this.data = it.data; │ │ │ │ │ + this.schema = it.schema[keyword]; │ │ │ │ │ + this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data; │ │ │ │ │ + this.schemaValue = (0, util_1$l.schemaRefOrVal)(it, this.schema, keyword, this.$data); │ │ │ │ │ + this.schemaType = def.schemaType; │ │ │ │ │ + this.parentSchema = it.schema; │ │ │ │ │ + this.params = {}; │ │ │ │ │ + this.it = it; │ │ │ │ │ + this.def = def; │ │ │ │ │ + if (this.$data) { │ │ │ │ │ + this.schemaCode = it.gen.const("vSchema", getData(this.$data, it)); │ │ │ │ │ + } else { │ │ │ │ │ + this.schemaCode = this.schemaValue; │ │ │ │ │ + if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) { │ │ │ │ │ + throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`); │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ - pass(condition, failAction) { │ │ │ │ │ - this.failResult((0, codegen_1.not)(condition), undefined, failAction); │ │ │ │ │ + if ("code" in def ? def.trackErrors : def.errors !== false) { │ │ │ │ │ + this.errsCount = it.gen.const("_errs", names_1$3.default.errors); │ │ │ │ │ } │ │ │ │ │ - fail(condition) { │ │ │ │ │ - if (condition === undefined) { │ │ │ │ │ - this.error(); │ │ │ │ │ - if (!this.allErrors) │ │ │ │ │ - this.gen.if(false); // this branch will be removed by gen.optimize │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ - this.gen.if(condition); │ │ │ │ │ + } │ │ │ │ │ + result(condition, successAction, failAction) { │ │ │ │ │ + this.failResult((0, codegen_1$n.not)(condition), successAction, failAction); │ │ │ │ │ + } │ │ │ │ │ + failResult(condition, successAction, failAction) { │ │ │ │ │ + this.gen.if(condition); │ │ │ │ │ + if (failAction) │ │ │ │ │ + failAction(); │ │ │ │ │ + else │ │ │ │ │ this.error(); │ │ │ │ │ + if (successAction) { │ │ │ │ │ + this.gen.else(); │ │ │ │ │ + successAction(); │ │ │ │ │ + if (this.allErrors) │ │ │ │ │ + this.gen.endIf(); │ │ │ │ │ + } else { │ │ │ │ │ if (this.allErrors) │ │ │ │ │ this.gen.endIf(); │ │ │ │ │ else │ │ │ │ │ this.gen.else(); │ │ │ │ │ } │ │ │ │ │ - fail$data(condition) { │ │ │ │ │ - if (!this.$data) │ │ │ │ │ - return this.fail(condition); │ │ │ │ │ - const { │ │ │ │ │ - schemaCode │ │ │ │ │ - } = this; │ │ │ │ │ - this.fail((0, codegen_1._) `${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`); │ │ │ │ │ - } │ │ │ │ │ - error(append, errorParams, errorPaths) { │ │ │ │ │ - if (errorParams) { │ │ │ │ │ - this.setParams(errorParams); │ │ │ │ │ - this._error(append, errorPaths); │ │ │ │ │ - this.setParams({}); │ │ │ │ │ - return; │ │ │ │ │ - } │ │ │ │ │ - this._error(append, errorPaths); │ │ │ │ │ - } │ │ │ │ │ - _error(append, errorPaths) { │ │ │ │ │ - (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths); │ │ │ │ │ - } │ │ │ │ │ - $dataError() { │ │ │ │ │ - (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError); │ │ │ │ │ - } │ │ │ │ │ - reset() { │ │ │ │ │ - if (this.errsCount === undefined) │ │ │ │ │ - throw new Error('add "trackErrors" to keyword definition'); │ │ │ │ │ - (0, errors_1.resetErrorsCount)(this.gen, this.errsCount); │ │ │ │ │ - } │ │ │ │ │ - ok(cond) { │ │ │ │ │ + } │ │ │ │ │ + pass(condition, failAction) { │ │ │ │ │ + this.failResult((0, codegen_1$n.not)(condition), undefined, failAction); │ │ │ │ │ + } │ │ │ │ │ + fail(condition) { │ │ │ │ │ + if (condition === undefined) { │ │ │ │ │ + this.error(); │ │ │ │ │ if (!this.allErrors) │ │ │ │ │ - this.gen.if(cond); │ │ │ │ │ - } │ │ │ │ │ - setParams(obj, assign) { │ │ │ │ │ - if (assign) │ │ │ │ │ - Object.assign(this.params, obj); │ │ │ │ │ - else │ │ │ │ │ - this.params = obj; │ │ │ │ │ + this.gen.if(false); // this branch will be removed by gen.optimize │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ - block$data(valid, codeBlock, $dataValid = codegen_1.nil) { │ │ │ │ │ - this.gen.block(() => { │ │ │ │ │ - this.check$data(valid, $dataValid); │ │ │ │ │ - codeBlock(); │ │ │ │ │ - }); │ │ │ │ │ + this.gen.if(condition); │ │ │ │ │ + this.error(); │ │ │ │ │ + if (this.allErrors) │ │ │ │ │ + this.gen.endIf(); │ │ │ │ │ + else │ │ │ │ │ + this.gen.else(); │ │ │ │ │ + } │ │ │ │ │ + fail$data(condition) { │ │ │ │ │ + if (!this.$data) │ │ │ │ │ + return this.fail(condition); │ │ │ │ │ + const { │ │ │ │ │ + schemaCode │ │ │ │ │ + } = this; │ │ │ │ │ + this.fail((0, codegen_1$n._) `${schemaCode} !== undefined && (${(0, codegen_1$n.or)(this.invalid$data(), condition)})`); │ │ │ │ │ + } │ │ │ │ │ + error(append, errorParams, errorPaths) { │ │ │ │ │ + if (errorParams) { │ │ │ │ │ + this.setParams(errorParams); │ │ │ │ │ + this._error(append, errorPaths); │ │ │ │ │ + this.setParams({}); │ │ │ │ │ + return; │ │ │ │ │ } │ │ │ │ │ - check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) { │ │ │ │ │ - if (!this.$data) │ │ │ │ │ - return; │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - schemaCode, │ │ │ │ │ - schemaType, │ │ │ │ │ - def │ │ │ │ │ - } = this; │ │ │ │ │ - gen.if((0, codegen_1.or)((0, codegen_1._) `${schemaCode} === undefined`, $dataValid)); │ │ │ │ │ - if (valid !== codegen_1.nil) │ │ │ │ │ - gen.assign(valid, true); │ │ │ │ │ - if (schemaType.length || def.validateSchema) { │ │ │ │ │ - gen.elseIf(this.invalid$data()); │ │ │ │ │ - this.$dataError(); │ │ │ │ │ - if (valid !== codegen_1.nil) │ │ │ │ │ - gen.assign(valid, false); │ │ │ │ │ - } │ │ │ │ │ - gen.else(); │ │ │ │ │ + this._error(append, errorPaths); │ │ │ │ │ + } │ │ │ │ │ + _error(append, errorPaths) { │ │ │ │ │ + (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths); │ │ │ │ │ + } │ │ │ │ │ + $dataError() { │ │ │ │ │ + (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError); │ │ │ │ │ + } │ │ │ │ │ + reset() { │ │ │ │ │ + if (this.errsCount === undefined) │ │ │ │ │ + throw new Error('add "trackErrors" to keyword definition'); │ │ │ │ │ + (0, errors_1.resetErrorsCount)(this.gen, this.errsCount); │ │ │ │ │ + } │ │ │ │ │ + ok(cond) { │ │ │ │ │ + if (!this.allErrors) │ │ │ │ │ + this.gen.if(cond); │ │ │ │ │ + } │ │ │ │ │ + setParams(obj, assign) { │ │ │ │ │ + if (assign) │ │ │ │ │ + Object.assign(this.params, obj); │ │ │ │ │ + else │ │ │ │ │ + this.params = obj; │ │ │ │ │ + } │ │ │ │ │ + block$data(valid, codeBlock, $dataValid = codegen_1$n.nil) { │ │ │ │ │ + this.gen.block(() => { │ │ │ │ │ + this.check$data(valid, $dataValid); │ │ │ │ │ + codeBlock(); │ │ │ │ │ + }); │ │ │ │ │ + } │ │ │ │ │ + check$data(valid = codegen_1$n.nil, $dataValid = codegen_1$n.nil) { │ │ │ │ │ + if (!this.$data) │ │ │ │ │ + return; │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + schemaCode, │ │ │ │ │ + schemaType, │ │ │ │ │ + def │ │ │ │ │ + } = this; │ │ │ │ │ + gen.if((0, codegen_1$n.or)((0, codegen_1$n._) `${schemaCode} === undefined`, $dataValid)); │ │ │ │ │ + if (valid !== codegen_1$n.nil) │ │ │ │ │ + gen.assign(valid, true); │ │ │ │ │ + if (schemaType.length || def.validateSchema) { │ │ │ │ │ + gen.elseIf(this.invalid$data()); │ │ │ │ │ + this.$dataError(); │ │ │ │ │ + if (valid !== codegen_1$n.nil) │ │ │ │ │ + gen.assign(valid, false); │ │ │ │ │ } │ │ │ │ │ - invalid$data() { │ │ │ │ │ - const { │ │ │ │ │ - gen, │ │ │ │ │ - schemaCode, │ │ │ │ │ - schemaType, │ │ │ │ │ - def, │ │ │ │ │ - it │ │ │ │ │ - } = this; │ │ │ │ │ - return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema()); │ │ │ │ │ + gen.else(); │ │ │ │ │ + } │ │ │ │ │ + invalid$data() { │ │ │ │ │ + const { │ │ │ │ │ + gen, │ │ │ │ │ + schemaCode, │ │ │ │ │ + schemaType, │ │ │ │ │ + def, │ │ │ │ │ + it │ │ │ │ │ + } = this; │ │ │ │ │ + return (0, codegen_1$n.or)(wrong$DataType(), invalid$DataSchema()); │ │ │ │ │ │ │ │ │ │ - function wrong$DataType() { │ │ │ │ │ - if (schemaType.length) { │ │ │ │ │ - /* istanbul ignore if */ │ │ │ │ │ - if (!(schemaCode instanceof codegen_1.Name)) │ │ │ │ │ - throw new Error("ajv implementation error"); │ │ │ │ │ - const st = Array.isArray(schemaType) ? schemaType : [schemaType]; │ │ │ │ │ - return (0, codegen_1._) `${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`; │ │ │ │ │ - } │ │ │ │ │ - return codegen_1.nil; │ │ │ │ │ - } │ │ │ │ │ - │ │ │ │ │ - function invalid$DataSchema() { │ │ │ │ │ - if (def.validateSchema) { │ │ │ │ │ - const validateSchemaRef = gen.scopeValue("validate$data", { │ │ │ │ │ - ref: def.validateSchema │ │ │ │ │ - }); // TODO value.code for standalone │ │ │ │ │ - return (0, codegen_1._) `!${validateSchemaRef}(${schemaCode})`; │ │ │ │ │ - } │ │ │ │ │ - return codegen_1.nil; │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - subschema(appl, valid) { │ │ │ │ │ - const subschema = (0, subschema_1.getSubschema)(this.it, appl); │ │ │ │ │ - (0, subschema_1.extendSubschemaData)(subschema, this.it, appl); │ │ │ │ │ - (0, subschema_1.extendSubschemaMode)(subschema, appl); │ │ │ │ │ - const nextContext = { │ │ │ │ │ - ...this.it, │ │ │ │ │ - ...subschema, │ │ │ │ │ - items: undefined, │ │ │ │ │ - props: undefined │ │ │ │ │ - }; │ │ │ │ │ - subschemaCode(nextContext, valid); │ │ │ │ │ - return nextContext; │ │ │ │ │ + function wrong$DataType() { │ │ │ │ │ + if (schemaType.length) { │ │ │ │ │ + /* istanbul ignore if */ │ │ │ │ │ + if (!(schemaCode instanceof codegen_1$n.Name)) │ │ │ │ │ + throw new Error("ajv implementation error"); │ │ │ │ │ + const st = Array.isArray(schemaType) ? schemaType : [schemaType]; │ │ │ │ │ + return (0, codegen_1$n._) `${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`; │ │ │ │ │ + } │ │ │ │ │ + return codegen_1$n.nil; │ │ │ │ │ + } │ │ │ │ │ + │ │ │ │ │ + function invalid$DataSchema() { │ │ │ │ │ + if (def.validateSchema) { │ │ │ │ │ + const validateSchemaRef = gen.scopeValue("validate$data", { │ │ │ │ │ + ref: def.validateSchema │ │ │ │ │ + }); // TODO value.code for standalone │ │ │ │ │ + return (0, codegen_1$n._) `!${validateSchemaRef}(${schemaCode})`; │ │ │ │ │ + } │ │ │ │ │ + return codegen_1$n.nil; │ │ │ │ │ + } │ │ │ │ │ + } │ │ │ │ │ + subschema(appl, valid) { │ │ │ │ │ + const subschema = (0, subschema_1.getSubschema)(this.it, appl); │ │ │ │ │ + (0, subschema_1.extendSubschemaData)(subschema, this.it, appl); │ │ │ │ │ + (0, subschema_1.extendSubschemaMode)(subschema, appl); │ │ │ │ │ + const nextContext = { │ │ │ │ │ + ...this.it, │ │ │ │ │ + ...subschema, │ │ │ │ │ + items: undefined, │ │ │ │ │ + props: undefined │ │ │ │ │ + }; │ │ │ │ │ + subschemaCode(nextContext, valid); │ │ │ │ │ + return nextContext; │ │ │ │ │ + } │ │ │ │ │ + mergeEvaluated(schemaCxt, toName) { │ │ │ │ │ + const { │ │ │ │ │ + it, │ │ │ │ │ + gen │ │ │ │ │ + } = this; │ │ │ │ │ + if (!it.opts.unevaluated) │ │ │ │ │ + return; │ │ │ │ │ + if (it.props !== true && schemaCxt.props !== undefined) { │ │ │ │ │ + it.props = util_1$l.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName); │ │ │ │ │ } │ │ │ │ │ - mergeEvaluated(schemaCxt, toName) { │ │ │ │ │ - const { │ │ │ │ │ - it, │ │ │ │ │ - gen │ │ │ │ │ - } = this; │ │ │ │ │ - if (!it.opts.unevaluated) │ │ │ │ │ - return; │ │ │ │ │ - if (it.props !== true && schemaCxt.props !== undefined) { │ │ │ │ │ - it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName); │ │ │ │ │ - } │ │ │ │ │ - if (it.items !== true && schemaCxt.items !== undefined) { │ │ │ │ │ - it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - mergeValidEvaluated(schemaCxt, valid) { │ │ │ │ │ - const { │ │ │ │ │ - it, │ │ │ │ │ - gen │ │ │ │ │ - } = this; │ │ │ │ │ - if (it.opts.unevaluated && (it.props !== true || it.items !== true)) { │ │ │ │ │ - gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name)); │ │ │ │ │ - return true; │ │ │ │ │ - } │ │ │ │ │ + if (it.items !== true && schemaCxt.items !== undefined) { │ │ │ │ │ + it.items = util_1$l.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName); │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ - validate.KeywordCxt = KeywordCxt; │ │ │ │ │ - │ │ │ │ │ - function keywordCode(it, keyword, def, ruleType) { │ │ │ │ │ - const cxt = new KeywordCxt(it, def, keyword); │ │ │ │ │ - if ("code" in def) { │ │ │ │ │ - def.code(cxt, ruleType); │ │ │ │ │ - } else if (cxt.$data && def.validate) { │ │ │ │ │ - (0, keyword_1.funcKeywordCode)(cxt, def); │ │ │ │ │ - } else if ("macro" in def) { │ │ │ │ │ - (0, keyword_1.macroKeywordCode)(cxt, def); │ │ │ │ │ - } else if (def.compile || def.validate) { │ │ │ │ │ - (0, keyword_1.funcKeywordCode)(cxt, def); │ │ │ │ │ - } │ │ │ │ │ - } │ │ │ │ │ - const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; │ │ │ │ │ - const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; │ │ │ │ │ - │ │ │ │ │ - function getData($data, { │ │ │ │ │ - dataLevel, │ │ │ │ │ - dataNames, │ │ │ │ │ - dataPathArr │ │ │ │ │ - }) { │ │ │ │ │ - let jsonPointer; │ │ │ │ │ - let data; │ │ │ │ │ - if ($data === "") │ │ │ │ │ - return names_1.default.rootData; │ │ │ │ │ - if ($data[0] === "/") { │ │ │ │ │ - if (!JSON_POINTER.test($data)) │ │ │ │ │ - throw new Error(`Invalid JSON-pointer: ${$data}`); │ │ │ │ │ - jsonPointer = $data; │ │ │ │ │ - data = names_1.default.rootData; │ │ │ │ │ - } else { │ │ │ │ │ - const matches = RELATIVE_JSON_POINTER.exec($data); │ │ │ │ │ - if (!matches) │ │ │ │ │ - throw new Error(`Invalid JSON-pointer: ${$data}`); │ │ │ │ │ - const up = +matches[1]; │ │ │ │ │ - jsonPointer = matches[2]; │ │ │ │ │ - if (jsonPointer === "#") { │ │ │ │ │ - if (up >= dataLevel) │ │ │ │ │ - throw new Error(errorMsg("property/index", up)); │ │ │ │ │ - return dataPathArr[dataLevel - up]; │ │ │ │ │ - } │ │ │ │ │ - if (up > dataLevel) │ │ │ │ │ - throw new Error(errorMsg("data", up)); │ │ │ │ │ - data = dataNames[dataLevel - up]; │ │ │ │ │ - if (!jsonPointer) │ │ │ │ │ - return data; │ │ │ │ │ - } │ │ │ │ │ - let expr = data; │ │ │ │ │ - const segments = jsonPointer.split("/"); │ │ │ │ │ - for (const segment of segments) { │ │ │ │ │ - if (segment) { │ │ │ │ │ - data = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`; │ │ │ │ │ - expr = (0, codegen_1._) `${expr} && ${data}`; │ │ │ │ │ - } │ │ │ │ │ + mergeValidEvaluated(schemaCxt, valid) { │ │ │ │ │ + const { │ │ │ │ │ + it, │ │ │ │ │ + gen │ │ │ │ │ + } = this; │ │ │ │ │ + if (it.opts.unevaluated && (it.props !== true || it.items !== true)) { │ │ │ │ │ + gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1$n.Name)); │ │ │ │ │ + return true; │ │ │ │ │ } │ │ │ │ │ - return expr; │ │ │ │ │ + } │ │ │ │ │ +} │ │ │ │ │ +validate.KeywordCxt = KeywordCxt; │ │ │ │ │ │ │ │ │ │ - function errorMsg(pointerType, up) { │ │ │ │ │ - return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`; │ │ │ │ │ +function keywordCode(it, keyword, def, ruleType) { │ │ │ │ │ + const cxt = new KeywordCxt(it, def, keyword); │ │ │ │ │ + if ("code" in def) { │ │ │ │ │ + def.code(cxt, ruleType); │ │ │ │ │ + } else if (cxt.$data && def.validate) { │ │ │ │ │ + (0, keyword_1.funcKeywordCode)(cxt, def); │ │ │ │ │ + } else if ("macro" in def) { │ │ │ │ │ + (0, keyword_1.macroKeywordCode)(cxt, def); │ │ │ │ │ + } else if (def.compile || def.validate) { │ │ │ │ │ + (0, keyword_1.funcKeywordCode)(cxt, def); │ │ │ │ │ + } │ │ │ │ │ +} │ │ │ │ │ +const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; │ │ │ │ │ +const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; │ │ │ │ │ + │ │ │ │ │ +function getData($data, { │ │ │ │ │ + dataLevel, │ │ │ │ │ + dataNames, │ │ │ │ │ + dataPathArr │ │ │ │ │ +}) { │ │ │ │ │ + let jsonPointer; │ │ │ │ │ + let data; │ │ │ │ │ + if ($data === "") │ │ │ │ │ + return names_1$3.default.rootData; │ │ │ │ │ + if ($data[0] === "/") { │ │ │ │ │ + if (!JSON_POINTER.test($data)) │ │ │ │ │ + throw new Error(`Invalid JSON-pointer: ${$data}`); │ │ │ │ │ + jsonPointer = $data; │ │ │ │ │ + data = names_1$3.default.rootData; │ │ │ │ │ + } else { │ │ │ │ │ + const matches = RELATIVE_JSON_POINTER.exec($data); │ │ │ │ │ + if (!matches) │ │ │ │ │ + throw new Error(`Invalid JSON-pointer: ${$data}`); │ │ │ │ │ + const up = +matches[1]; │ │ │ │ │ + jsonPointer = matches[2]; │ │ │ │ │ + if (jsonPointer === "#") { │ │ │ │ │ + if (up >= dataLevel) │ │ │ │ │ + throw new Error(errorMsg("property/index", up)); │ │ │ │ │ + return dataPathArr[dataLevel - up]; │ │ │ │ │ + } │ │ │ │ │ + if (up > dataLevel) │ │ │ │ │ + throw new Error(errorMsg("data", up)); │ │ │ │ │ + data = dataNames[dataLevel - up]; │ │ │ │ │ + if (!jsonPointer) │ │ │ │ │ + return data; │ │ │ │ │ + } │ │ │ │ │ + let expr = data; │ │ │ │ │ + const segments = jsonPointer.split("/"); │ │ │ │ │ + for (const segment of segments) { │ │ │ │ │ + if (segment) { │ │ │ │ │ + data = (0, codegen_1$n._) `${data}${(0, codegen_1$n.getProperty)((0, util_1$l.unescapeJsonPointer)(segment))}`; │ │ │ │ │ + expr = (0, codegen_1$n._) `${expr} && ${data}`; │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ - validate.getData = getData; │ │ │ │ │ + return expr; │ │ │ │ │ │ │ │ │ │ - return validate; │ │ │ │ │ + function errorMsg(pointerType, up) { │ │ │ │ │ + return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`; │ │ │ │ │ + } │ │ │ │ │ } │ │ │ │ │ +validate.getData = getData; │ │ │ │ │ │ │ │ │ │ var validation_error = {}; │ │ │ │ │ │ │ │ │ │ var hasRequiredValidation_error; │ │ │ │ │ │ │ │ │ │ function requireValidation_error() { │ │ │ │ │ if (hasRequiredValidation_error) return validation_error; │ │ │ │ │ @@ -37422,20 +37330,20 @@ │ │ │ │ │ │ │ │ │ │ var compile = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(compile, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ compile.resolveSchema = compile.getCompilingSchema = compile.resolveRef = compile.compileSchema = compile.SchemaEnv = void 0; │ │ │ │ │ -const codegen_1$m = requireCodegen(); │ │ │ │ │ +const codegen_1$m = codegen; │ │ │ │ │ const validation_error_1 = requireValidation_error(); │ │ │ │ │ -const names_1$2 = requireNames(); │ │ │ │ │ +const names_1$2 = names$1; │ │ │ │ │ const resolve_1 = resolve$1; │ │ │ │ │ const util_1$k = util; │ │ │ │ │ -const validate_1$1 = requireValidate(); │ │ │ │ │ +const validate_1$1 = validate; │ │ │ │ │ class SchemaEnv { │ │ │ │ │ constructor(env) { │ │ │ │ │ var _a; │ │ │ │ │ this.refs = {}; │ │ │ │ │ this.dynamicAnchors = {}; │ │ │ │ │ let schema; │ │ │ │ │ if (typeof env.schema == "object") │ │ │ │ │ @@ -39025,22 +38933,22 @@ │ │ │ │ │ uri$1.default = uri; │ │ │ │ │ │ │ │ │ │ (function(exports) { │ │ │ │ │ Object.defineProperty(exports, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0; │ │ │ │ │ - var validate_1 = requireValidate(); │ │ │ │ │ + var validate_1 = validate; │ │ │ │ │ Object.defineProperty(exports, "KeywordCxt", { │ │ │ │ │ enumerable: true, │ │ │ │ │ get: function() { │ │ │ │ │ return validate_1.KeywordCxt; │ │ │ │ │ } │ │ │ │ │ }); │ │ │ │ │ - var codegen_1 = requireCodegen(); │ │ │ │ │ + var codegen_1 = codegen; │ │ │ │ │ Object.defineProperty(exports, "_", { │ │ │ │ │ enumerable: true, │ │ │ │ │ get: function() { │ │ │ │ │ return codegen_1._; │ │ │ │ │ } │ │ │ │ │ }); │ │ │ │ │ Object.defineProperty(exports, "str", { │ │ │ │ │ @@ -39073,15 +38981,15 @@ │ │ │ │ │ return codegen_1.CodeGen; │ │ │ │ │ } │ │ │ │ │ }); │ │ │ │ │ const validation_error_1 = requireValidation_error(); │ │ │ │ │ const ref_error_1 = requireRef_error(); │ │ │ │ │ const rules_1 = rules; │ │ │ │ │ const compile_1 = compile; │ │ │ │ │ - const codegen_2 = requireCodegen(); │ │ │ │ │ + const codegen_2 = codegen; │ │ │ │ │ const resolve_1 = resolve$1; │ │ │ │ │ const dataType_1 = dataType; │ │ │ │ │ const util_1 = util; │ │ │ │ │ const $dataRefSchema = require$$9; │ │ │ │ │ const uri_1 = uri$1; │ │ │ │ │ const defaultRegExp = (str, flags) => new RegExp(str, flags); │ │ │ │ │ defaultRegExp.code = "new RegExp"; │ │ │ │ │ @@ -39779,17 +39687,17 @@ │ │ │ │ │ var ref = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(ref, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ ref.callRef = ref.getValidate = void 0; │ │ │ │ │ const ref_error_1 = requireRef_error(); │ │ │ │ │ -const code_1$8 = requireCode(); │ │ │ │ │ -const codegen_1$l = requireCodegen(); │ │ │ │ │ -const names_1$1 = requireNames(); │ │ │ │ │ +const code_1$8 = code; │ │ │ │ │ +const codegen_1$l = codegen; │ │ │ │ │ +const names_1$1 = names$1; │ │ │ │ │ const compile_1$1 = compile; │ │ │ │ │ const util_1$j = util; │ │ │ │ │ const def$r = { │ │ │ │ │ keyword: "$ref", │ │ │ │ │ schemaType: "string", │ │ │ │ │ code(cxt) { │ │ │ │ │ const { │ │ │ │ │ @@ -39959,15 +39867,15 @@ │ │ │ │ │ var validation$1 = {}; │ │ │ │ │ │ │ │ │ │ var limitNumber = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(limitNumber, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$k = requireCodegen(); │ │ │ │ │ +const codegen_1$k = codegen; │ │ │ │ │ const ops = codegen_1$k.operators; │ │ │ │ │ const KWDs = { │ │ │ │ │ maximum: { │ │ │ │ │ okStr: "<=", │ │ │ │ │ ok: ops.LTE, │ │ │ │ │ fail: ops.GT │ │ │ │ │ }, │ │ │ │ │ @@ -40015,15 +39923,15 @@ │ │ │ │ │ limitNumber.default = def$q; │ │ │ │ │ │ │ │ │ │ var multipleOf = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(multipleOf, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$j = requireCodegen(); │ │ │ │ │ +const codegen_1$j = codegen; │ │ │ │ │ const error$h = { │ │ │ │ │ message: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$j.str) `must be multiple of ${schemaCode}`, │ │ │ │ │ params: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$j._) `{multipleOf: ${schemaCode}}`, │ │ │ │ │ @@ -40080,15 +39988,15 @@ │ │ │ │ │ } │ │ │ │ │ ucs2length$1.default = ucs2length; │ │ │ │ │ ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default'; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(limitLength, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$i = requireCodegen(); │ │ │ │ │ +const codegen_1$i = codegen; │ │ │ │ │ const util_1$i = util; │ │ │ │ │ const ucs2length_1 = ucs2length$1; │ │ │ │ │ const error$g = { │ │ │ │ │ message({ │ │ │ │ │ keyword, │ │ │ │ │ schemaCode │ │ │ │ │ }) { │ │ │ │ │ @@ -40120,16 +40028,16 @@ │ │ │ │ │ limitLength.default = def$o; │ │ │ │ │ │ │ │ │ │ var pattern = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(pattern, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const code_1$7 = requireCode(); │ │ │ │ │ -const codegen_1$h = requireCodegen(); │ │ │ │ │ +const code_1$7 = code; │ │ │ │ │ +const codegen_1$h = codegen; │ │ │ │ │ const error$f = { │ │ │ │ │ message: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$h.str) `must match pattern "${schemaCode}"`, │ │ │ │ │ params: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$h._) `{pattern: ${schemaCode}}`, │ │ │ │ │ @@ -40157,15 +40065,15 @@ │ │ │ │ │ pattern.default = def$n; │ │ │ │ │ │ │ │ │ │ var limitProperties = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(limitProperties, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$g = requireCodegen(); │ │ │ │ │ +const codegen_1$g = codegen; │ │ │ │ │ const error$e = { │ │ │ │ │ message({ │ │ │ │ │ keyword, │ │ │ │ │ schemaCode │ │ │ │ │ }) { │ │ │ │ │ const comp = keyword === "maxProperties" ? "more" : "fewer"; │ │ │ │ │ return (0, codegen_1$g.str) `must NOT have ${comp} than ${schemaCode} properties`; │ │ │ │ │ @@ -40193,16 +40101,16 @@ │ │ │ │ │ limitProperties.default = def$m; │ │ │ │ │ │ │ │ │ │ var required = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(required, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const code_1$6 = requireCode(); │ │ │ │ │ -const codegen_1$f = requireCodegen(); │ │ │ │ │ +const code_1$6 = code; │ │ │ │ │ +const codegen_1$f = codegen; │ │ │ │ │ const util_1$h = util; │ │ │ │ │ const error$d = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ missingProperty │ │ │ │ │ } │ │ │ │ │ }) => (0, codegen_1$f.str) `must have required property '${missingProperty}'`, │ │ │ │ │ @@ -40300,15 +40208,15 @@ │ │ │ │ │ required.default = def$l; │ │ │ │ │ │ │ │ │ │ var limitItems = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(limitItems, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$e = requireCodegen(); │ │ │ │ │ +const codegen_1$e = codegen; │ │ │ │ │ const error$c = { │ │ │ │ │ message({ │ │ │ │ │ keyword, │ │ │ │ │ schemaCode │ │ │ │ │ }) { │ │ │ │ │ const comp = keyword === "maxItems" ? "more" : "fewer"; │ │ │ │ │ return (0, codegen_1$e.str) `must NOT have ${comp} than ${schemaCode} items`; │ │ │ │ │ @@ -40347,15 +40255,15 @@ │ │ │ │ │ equal.code = 'require("ajv/dist/runtime/equal").default'; │ │ │ │ │ equal$1.default = equal; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(uniqueItems, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ const dataType_1 = dataType; │ │ │ │ │ -const codegen_1$d = requireCodegen(); │ │ │ │ │ +const codegen_1$d = codegen; │ │ │ │ │ const util_1$g = util; │ │ │ │ │ const equal_1$2 = equal$1; │ │ │ │ │ const error$b = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ i, │ │ │ │ │ j │ │ │ │ │ @@ -40438,15 +40346,15 @@ │ │ │ │ │ uniqueItems.default = def$j; │ │ │ │ │ │ │ │ │ │ var _const = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(_const, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$c = requireCodegen(); │ │ │ │ │ +const codegen_1$c = codegen; │ │ │ │ │ const util_1$f = util; │ │ │ │ │ const equal_1$1 = equal$1; │ │ │ │ │ const error$a = { │ │ │ │ │ message: "must be equal to constant", │ │ │ │ │ params: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$c._) `{allowedValue: ${schemaCode}}`, │ │ │ │ │ @@ -40473,15 +40381,15 @@ │ │ │ │ │ _const.default = def$i; │ │ │ │ │ │ │ │ │ │ var _enum = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(_enum, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$b = requireCodegen(); │ │ │ │ │ +const codegen_1$b = codegen; │ │ │ │ │ const util_1$e = util; │ │ │ │ │ const equal_1 = equal$1; │ │ │ │ │ const error$9 = { │ │ │ │ │ message: "must be equal to one of the allowed values", │ │ │ │ │ params: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$b._) `{allowedValues: ${schemaCode}}`, │ │ │ │ │ @@ -40576,15 +40484,15 @@ │ │ │ │ │ │ │ │ │ │ var additionalItems = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(additionalItems, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ additionalItems.validateAdditionalItems = void 0; │ │ │ │ │ -const codegen_1$a = requireCodegen(); │ │ │ │ │ +const codegen_1$a = codegen; │ │ │ │ │ const util_1$d = util; │ │ │ │ │ const error$8 = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ len │ │ │ │ │ } │ │ │ │ │ }) => (0, codegen_1$a.str) `must NOT have more than ${len} items`, │ │ │ │ │ @@ -40656,17 +40564,17 @@ │ │ │ │ │ │ │ │ │ │ var items = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(items, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ items.validateTuple = void 0; │ │ │ │ │ -const codegen_1$9 = requireCodegen(); │ │ │ │ │ +const codegen_1$9 = codegen; │ │ │ │ │ const util_1$c = util; │ │ │ │ │ -const code_1$5 = requireCode(); │ │ │ │ │ +const code_1$5 = code; │ │ │ │ │ const def$f = { │ │ │ │ │ keyword: "items", │ │ │ │ │ type: "array", │ │ │ │ │ schemaType: ["object", "array", "boolean"], │ │ │ │ │ before: "uniqueItems", │ │ │ │ │ code(cxt) { │ │ │ │ │ const { │ │ │ │ │ @@ -40737,17 +40645,17 @@ │ │ │ │ │ prefixItems.default = def$e; │ │ │ │ │ │ │ │ │ │ var items2020 = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(items2020, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$8 = requireCodegen(); │ │ │ │ │ +const codegen_1$8 = codegen; │ │ │ │ │ const util_1$b = util; │ │ │ │ │ -const code_1$4 = requireCode(); │ │ │ │ │ +const code_1$4 = code; │ │ │ │ │ const additionalItems_1$1 = additionalItems; │ │ │ │ │ const error$7 = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ len │ │ │ │ │ } │ │ │ │ │ }) => (0, codegen_1$8.str) `must NOT have more than ${len} items`, │ │ │ │ │ @@ -40784,15 +40692,15 @@ │ │ │ │ │ items2020.default = def$d; │ │ │ │ │ │ │ │ │ │ var contains = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(contains, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$7 = requireCodegen(); │ │ │ │ │ +const codegen_1$7 = codegen; │ │ │ │ │ const util_1$a = util; │ │ │ │ │ const error$6 = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ min, │ │ │ │ │ max │ │ │ │ │ } │ │ │ │ │ @@ -40905,17 +40813,17 @@ │ │ │ │ │ var dependencies = {}; │ │ │ │ │ │ │ │ │ │ (function(exports) { │ │ │ │ │ Object.defineProperty(exports, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0; │ │ │ │ │ - const codegen_1 = requireCodegen(); │ │ │ │ │ + const codegen_1 = codegen; │ │ │ │ │ const util_1 = util; │ │ │ │ │ - const code_1 = requireCode(); │ │ │ │ │ + const code_1 = code; │ │ │ │ │ exports.error = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ property, │ │ │ │ │ depsCount, │ │ │ │ │ deps │ │ │ │ │ } │ │ │ │ │ @@ -41023,15 +40931,15 @@ │ │ │ │ │ }(dependencies)); │ │ │ │ │ │ │ │ │ │ var propertyNames = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(propertyNames, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$6 = requireCodegen(); │ │ │ │ │ +const codegen_1$6 = codegen; │ │ │ │ │ const util_1$9 = util; │ │ │ │ │ const error$5 = { │ │ │ │ │ message: "property name must be valid", │ │ │ │ │ params: ({ │ │ │ │ │ params │ │ │ │ │ }) => (0, codegen_1$6._) `{propertyName: ${params.propertyName}}`, │ │ │ │ │ }; │ │ │ │ │ @@ -41073,17 +40981,17 @@ │ │ │ │ │ propertyNames.default = def$b; │ │ │ │ │ │ │ │ │ │ var additionalProperties = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(additionalProperties, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const code_1$3 = requireCode(); │ │ │ │ │ -const codegen_1$5 = requireCodegen(); │ │ │ │ │ -const names_1 = requireNames(); │ │ │ │ │ +const code_1$3 = code; │ │ │ │ │ +const codegen_1$5 = codegen; │ │ │ │ │ +const names_1 = names$1; │ │ │ │ │ const util_1$8 = util; │ │ │ │ │ const error$4 = { │ │ │ │ │ message: "must NOT have additional properties", │ │ │ │ │ params: ({ │ │ │ │ │ params │ │ │ │ │ }) => (0, codegen_1$5._) `{additionalProperty: ${params.additionalProperty}}`, │ │ │ │ │ }; │ │ │ │ │ @@ -41198,16 +41106,16 @@ │ │ │ │ │ additionalProperties.default = def$a; │ │ │ │ │ │ │ │ │ │ var properties$1 = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(properties$1, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const validate_1 = requireValidate(); │ │ │ │ │ -const code_1$2 = requireCode(); │ │ │ │ │ +const validate_1 = validate; │ │ │ │ │ +const code_1$2 = code; │ │ │ │ │ const util_1$7 = util; │ │ │ │ │ const additionalProperties_1$1 = additionalProperties; │ │ │ │ │ const def$9 = { │ │ │ │ │ keyword: "properties", │ │ │ │ │ type: "object", │ │ │ │ │ schemaType: "object", │ │ │ │ │ code(cxt) { │ │ │ │ │ @@ -41262,16 +41170,16 @@ │ │ │ │ │ properties$1.default = def$9; │ │ │ │ │ │ │ │ │ │ var patternProperties = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(patternProperties, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const code_1$1 = requireCode(); │ │ │ │ │ -const codegen_1$4 = requireCodegen(); │ │ │ │ │ +const code_1$1 = code; │ │ │ │ │ +const codegen_1$4 = codegen; │ │ │ │ │ const util_1$6 = util; │ │ │ │ │ const util_2 = util; │ │ │ │ │ const def$8 = { │ │ │ │ │ keyword: "patternProperties", │ │ │ │ │ type: "object", │ │ │ │ │ schemaType: "object", │ │ │ │ │ code(cxt) { │ │ │ │ │ @@ -41386,15 +41294,15 @@ │ │ │ │ │ not.default = def$7; │ │ │ │ │ │ │ │ │ │ var anyOf = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(anyOf, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const code_1 = requireCode(); │ │ │ │ │ +const code_1 = code; │ │ │ │ │ const def$6 = { │ │ │ │ │ keyword: "anyOf", │ │ │ │ │ schemaType: "array", │ │ │ │ │ trackErrors: true, │ │ │ │ │ code: code_1.validateUnion, │ │ │ │ │ error: { │ │ │ │ │ message: "must match a schema in anyOf" │ │ │ │ │ @@ -41403,15 +41311,15 @@ │ │ │ │ │ anyOf.default = def$6; │ │ │ │ │ │ │ │ │ │ var oneOf = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(oneOf, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$3 = requireCodegen(); │ │ │ │ │ +const codegen_1$3 = codegen; │ │ │ │ │ const util_1$4 = util; │ │ │ │ │ const error$3 = { │ │ │ │ │ message: "must match exactly one schema in oneOf", │ │ │ │ │ params: ({ │ │ │ │ │ params │ │ │ │ │ }) => (0, codegen_1$3._) `{passingSchemas: ${params.passing}}`, │ │ │ │ │ }; │ │ │ │ │ @@ -41508,15 +41416,15 @@ │ │ │ │ │ allOf.default = def$4; │ │ │ │ │ │ │ │ │ │ var _if = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(_if, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$2 = requireCodegen(); │ │ │ │ │ +const codegen_1$2 = codegen; │ │ │ │ │ const util_1$2 = util; │ │ │ │ │ const error$2 = { │ │ │ │ │ message: ({ │ │ │ │ │ params │ │ │ │ │ }) => (0, codegen_1$2.str) `must match "${params.ifClause}" schema`, │ │ │ │ │ params: ({ │ │ │ │ │ params │ │ │ │ │ @@ -41660,15 +41568,15 @@ │ │ │ │ │ var format$2 = {}; │ │ │ │ │ │ │ │ │ │ var format$1 = {}; │ │ │ │ │ │ │ │ │ │ Object.defineProperty(format$1, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1$1 = requireCodegen(); │ │ │ │ │ +const codegen_1$1 = codegen; │ │ │ │ │ const error$1 = { │ │ │ │ │ message: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$1.str) `must match format "${schemaCode}"`, │ │ │ │ │ params: ({ │ │ │ │ │ schemaCode │ │ │ │ │ }) => (0, codegen_1$1._) `{format: ${schemaCode}}`, │ │ │ │ │ @@ -41843,15 +41751,15 @@ │ │ │ │ │ })(exports.DiscrError || (exports.DiscrError = {})); │ │ │ │ │ │ │ │ │ │ }(types)); │ │ │ │ │ │ │ │ │ │ Object.defineProperty(discriminator, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ -const codegen_1 = requireCodegen(); │ │ │ │ │ +const codegen_1 = codegen; │ │ │ │ │ const types_1 = types; │ │ │ │ │ const compile_1 = compile; │ │ │ │ │ const util_1 = util; │ │ │ │ │ const error = { │ │ │ │ │ message: ({ │ │ │ │ │ params: { │ │ │ │ │ discrError, │ │ │ │ │ @@ -42251,22 +42159,22 @@ │ │ │ │ │ } │ │ │ │ │ } │ │ │ │ │ module.exports = exports = Ajv; │ │ │ │ │ Object.defineProperty(exports, "__esModule", { │ │ │ │ │ value: true │ │ │ │ │ }); │ │ │ │ │ exports.default = Ajv; │ │ │ │ │ - var validate_1 = requireValidate(); │ │ │ │ │ + var validate_1 = validate; │ │ │ │ │ Object.defineProperty(exports, "KeywordCxt", { │ │ │ │ │ enumerable: true, │ │ │ │ │ get: function() { │ │ │ │ │ return validate_1.KeywordCxt; │ │ │ │ │ } │ │ │ │ │ }); │ │ │ │ │ - var codegen_1 = requireCodegen(); │ │ │ │ │ + var codegen_1 = codegen; │ │ │ │ │ Object.defineProperty(exports, "_", { │ │ │ │ │ enumerable: true, │ │ │ │ │ get: function() { │ │ │ │ │ return codegen_1._; │ │ │ │ │ } │ │ │ │ │ }); │ │ │ │ │ Object.defineProperty(exports, "str", {