{"version":3,"sources":["webpack://web/./node_modules/ajv/dist/ajv.js","webpack://web/./node_modules/ajv/dist/compile/codegen/code.js","webpack://web/./node_modules/ajv/dist/compile/codegen/index.js","webpack://web/./node_modules/ajv/dist/compile/codegen/scope.js","webpack://web/./node_modules/ajv/dist/compile/errors.js","webpack://web/./node_modules/ajv/dist/compile/index.js","webpack://web/./node_modules/ajv/dist/compile/names.js","webpack://web/./node_modules/ajv/dist/compile/ref_error.js","webpack://web/./node_modules/ajv/dist/compile/resolve.js","webpack://web/./node_modules/ajv/dist/compile/rules.js","webpack://web/./node_modules/ajv/dist/compile/util.js","webpack://web/./node_modules/ajv/dist/compile/validate/applicability.js","webpack://web/./node_modules/ajv/dist/compile/validate/boolSchema.js","webpack://web/./node_modules/ajv/dist/compile/validate/dataType.js","webpack://web/./node_modules/ajv/dist/compile/validate/defaults.js","webpack://web/./node_modules/ajv/dist/compile/validate/index.js","webpack://web/./node_modules/ajv/dist/compile/validate/keyword.js","webpack://web/./node_modules/ajv/dist/compile/validate/subschema.js","webpack://web/./node_modules/ajv/dist/core.js","webpack://web/./node_modules/ajv/dist/runtime/equal.js","webpack://web/./node_modules/ajv/dist/runtime/ucs2length.js","webpack://web/./node_modules/ajv/dist/runtime/uri.js","webpack://web/./node_modules/ajv/dist/runtime/validation_error.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/additionalItems.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/allOf.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/anyOf.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/contains.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/dependencies.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/if.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/index.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/items.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/items2020.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/not.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/oneOf.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/patternProperties.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/prefixItems.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/properties.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/propertyNames.js","webpack://web/./node_modules/ajv/dist/vocabularies/applicator/thenElse.js","webpack://web/./node_modules/ajv/dist/vocabularies/code.js","webpack://web/./node_modules/ajv/dist/vocabularies/core/id.js","webpack://web/./node_modules/ajv/dist/vocabularies/core/index.js","webpack://web/./node_modules/ajv/dist/vocabularies/core/ref.js","webpack://web/./node_modules/ajv/dist/vocabularies/discriminator/index.js","webpack://web/./node_modules/ajv/dist/vocabularies/discriminator/types.js","webpack://web/./node_modules/ajv/dist/vocabularies/draft7.js","webpack://web/./node_modules/ajv/dist/vocabularies/format/format.js","webpack://web/./node_modules/ajv/dist/vocabularies/format/index.js","webpack://web/./node_modules/ajv/dist/vocabularies/metadata.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/const.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/enum.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/index.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/limitItems.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/limitLength.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/limitNumber.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/limitProperties.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/multipleOf.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/pattern.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/required.js","webpack://web/./node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"],"names":["Object","defineProperty","exports","value","CodeGen","Name","nil","stringify","str","_","KeywordCxt","core_1","draft7_1","discriminator_1","draft7MetaSchema","META_SUPPORT_DATA","META_SCHEMA_ID","Ajv","default","_addVocabularies","super","forEach","v","this","addVocabulary","opts","discriminator","addKeyword","_addDefaultMetaSchema","meta","metaSchema","$data","$dataMetaSchema","addMetaSchema","refs","defaultMeta","getSchema","undefined","module","validate_1","enumerable","get","codegen_1","regexpCode","getEsmExportName","getProperty","safeStringify","strConcat","addCodeArg","_Code","IDENTIFIER","_CodeOrName","constructor","s","test","Error","toString","emptyStr","code","_items","length","item","_a","_str","reduce","c","_names","names","strs","args","i","push","plus","expr","res","mergeExprItems","splice","optimize","arg","x","Array","isArray","join","a","b","slice","JSON","replace","c1","c2","key","rx","or","and","not","operators","varKinds","ValueScopeName","ValueScope","Scope","code_1","scope_1","code_2","scope_2","GT","GTE","LT","LTE","EQ","NEQ","NOT","OR","AND","ADD","Node","optimizeNodes","optimizeNames","_constants","Def","varKind","name","rhs","render","es5","_n","var","constants","optimizeExpr","Assign","lhs","sideEffects","addExprNames","AssignOp","op","Label","label","Break","Throw","error","AnyCode","ParentNode","nodes","n","subtractNames","addNames","BlockNode","Root","Else","kind","If","condition","else","cond","e","ns","For","ForLoop","iteration","ForRange","from","to","ForIter","loop","iterable","Func","async","Return","Try","catch","finally","_b","Catch","Finally","replaceName","some","items","par","extScope","_values","_blockStarts","lines","_extScope","_scope","parent","_nodes","_root","prefix","scopeName","scopeValue","prefixOrName","Set","add","getScopeValue","keyOrRef","getValue","scopeRefs","scopeCode","_def","nameOrPrefix","constant","toName","_leafNode","const","_constant","let","assign","object","keyValues","if","thenBody","elseBody","_blockNode","endIf","elseIf","_elseNode","_endBlockNode","_for","node","forBody","endFor","for","forRange","forOf","arr","forIn","obj","ownProperties","break","return","try","tryBody","catchCode","finallyCode","_currNode","throw","block","body","nodeCount","endBlock","len","pop","toClose","func","funcBody","endFunc","N1","N2","andCode","mappend","orCode","y","UsedValueState","ValueError","prefixes","_prefixes","_parent","_newName","_nameGroup","index","has","nameStr","setValue","property","itemIndex","scopePath","line","scope","ref","valueKey","vs","_name","Map","set","values","_reduceValues","usedValues","getCode","valueCode","nameSet","Started","def","Completed","extendErrors","resetErrorsCount","reportExtraError","reportError","keyword$DataError","keywordError","util_1","names_1","addError","gen","errObj","err","vErrors","errors","returnErrors","it","errs","validateName","schemaEnv","$async","ValidationError","message","keyword","schemaType","cxt","errorPaths","overrideAllErrors","compositeRule","allErrors","errorObjectCode","errsCount","schemaValue","data","instancePath","errorPath","errSchemaPath","verbose","E","schemaPath","params","propertyName","schema","parentSchema","createErrors","errorInstancePath","errorSchemaPath","topSchemaRef","messages","extraErrorProps","errorObject","instPath","getErrorPath","Type","Str","schPath","resolveSchema","getCompilingSchema","resolveRef","compileSchema","SchemaEnv","validation_error_1","resolve_1","env","dynamicAnchors","schemaId","root","baseId","normalizeId","localRefs","sch","_sch","call","rootId","getFullPath","uriResolver","_ValidationError","schemaCxt","parentData","parentDataProperty","dataNames","dataPathArr","dataLevel","dataTypes","definedProperties","source","jtd","self","sourceCode","_compilations","validateFunctionCode","validateCode","process","validate","Function","makeValidate","scopeValues","unevaluated","props","evaluated","dynamicProps","dynamicItems","logger","delete","inlineOrCompile","inlineRef","inlineRefs","schEnv","s2","s1","resolve","schemas","p","parse","refPath","_getFullPath","keys","getJsonPointer","id","schOrRef","schId","resolveUrl","schOrFunc","PREVENT_SCOPE_CHANGE","parsedRef","fragment","part","split","partSchema","unescapeFragment","$ref","schemaHasRulesButRef","RULES","valCxt","rootData","json","jsonPos","jsonLen","jsonPart","MissingRefError","resolver","msg","missingRef","missingSchema","getSchemaRefs","equal","traverse","SIMPLE_INLINED","limit","hasRef","countKeys","REF_KEYWORDS","count","Infinity","eachItem","normalize","serialize","TRAILING_SLASH_HASH","ANCHOR","baseIds","pathPrefix","schemaRefs","allKeys","jsonPtr","parentJsonPtr","fullPath","addRef","_resolve","ambiguos","checkAmbiguosRef","addAnchor","anchor","$anchor","$dynamicAnchor","sch1","sch2","getRules","isJSONType","jsonTypes","groups","number","type","rules","string","array","types","integer","boolean","null","post","all","keywords","checkStrictMode","useFunc","setEvaluated","evaluatedPropsToName","mergeEvaluated","unescapeJsonPointer","escapeJsonPointer","escapeFragment","schemaRefOrVal","schemaHasRules","checkUnknownRules","alwaysValidSchema","toHash","strictSchema","makeMergeEvaluated","mergeNames","mergeToName","mergeValues","resultToName","ps","hash","decodeURIComponent","encodeURIComponent","xs","f","Math","max","snippets","mode","warn","dataProp","dataPropType","jsPropertySyntax","isNumber","Num","shouldUseGroup","group","rule","shouldUseRule","definition","implements","kwd","schemaHasRulesForType","boolOrEmptySchema","topBoolOrEmptySchema","errors_1","boolError","falseSchemaError","schemaCode","valid","reportTypeError","checkDataTypes","checkDataType","coerceAndCheckDataType","getJSONTypes","getSchemaTypes","DataType","rules_1","applicability_1","ts","every","includes","nullable","coerceTo","coerceTypes","filter","t","COERCIBLE","coerceToTypes","checkTypes","wrongType","strictNumbers","Wrong","dataType","coerced","coerceSpecificType","assignParentData","coerceData","strictNums","correct","Correct","numCond","_cond","notObj","typeError","getTypeErrorContext","assignDefaults","assignDefault","prop","defaultValue","childData","useDefaults","ty","properties","getData","boolSchema_1","dataType_1","dataType_2","defaults_1","keyword_1","subschema_1","validateFunction","funcSourceUrl","dynamicRef","destructureValCxtES5","destructureValCxt","schemaCxtHasRules","isSchemaObj","checkKeywords","ignoreKeywordsWithRef","checkRefsAndKeywords","typeAndKeywords","schemaKeywords","commentKeyword","$comment","rootName","typeErrors","groupKeywords","iterateKeywords","strictTypes","includesType","strictTypesError","checkContextTypes","allowUnionTypes","checkMultipleTypes","hasApplicableType","kwdT","schTs","checkKeywordTypes","checkStrictTypes","keywordCode","checkNoDefault","resetEvaluated","assignEvaluated","returnResults","topSchemaObjCode","validateKeywordUsage","validSchemaType","allowUndefined","trackErrors","result","successAction","failAction","failResult","pass","fail","fail$data","invalid$data","append","errorParams","setParams","_error","$dataError","reset","ok","block$data","codeBlock","$dataValid","check$data","validateSchema","st","wrong$DataType","validateSchemaRef","invalid$DataSchema","subschema","appl","getSubschema","extendSubschemaData","extendSubschemaMode","nextContext","updateContext","checkAsyncSchema","subSchemaObjCode","subschemaCode","mergeValidEvaluated","ruleType","funcKeywordCode","macroKeywordCode","compile","JSON_POINTER","RELATIVE_JSON_POINTER","jsonPointer","matches","exec","up","errorMsg","segments","segment","pointerType","modifyData","useKeyword","macroSchema","macro","schemaRef","checkAsyncKeyword","validateRef","assignValid","_await","passCxt","passContext","passSchema","callValidateCode","modifying","reportErrs","ruleErrs","validateAsync","validateErrs","validateSync","addErrs","deps","dependencies","prototype","hasOwnProperty","errorsText","schemaProp","dpType","dataContextProps","_nextData","jtdDiscriminator","jtdMetadata","ref_error_1","compile_1","codegen_2","$dataRefSchema","uri_1","defaultRegExp","flags","RegExp","META_IGNORE_OPTIONS","EXT_SCOPE_NAMES","removedOptions","errorDataPath","format","jsonPointers","extendRefs","missingRefs","processCode","strictDefaults","strictKeywords","uniqueItems","unknownFormats","cache","ajvErrors","deprecatedOptions","unicode","requiredOptions","o","_c","_d","_e","_f","_g","_h","_j","_k","_l","_m","_o","_p","_q","_r","_s","_t","_u","_v","_w","_x","_y","_z","_0","strict","_optz","regExp","strictTuples","strictRequired","loopRequired","loopEnum","addUsedSchema","validateFormats","unicodeRegExp","int32range","formats","_loading","_cache","noLogs","console","log","getLogger","formatOpt","checkOptions","_metaOpts","getMetaSchemaOptions","addInitialFormats","addInitialKeywords","addInitialSchemas","_dataRefSchema","$id","schemaKeyRef","_meta","_addSchema","_compileSchemaEnv","compileAsync","loadSchema","runCompileAsync","_schema","loadMetaSchema","$schema","_compileAsync","checkLoaded","loadMissingSchema","_loadSchema","addSchema","_validateSchema","_checkUnique","throwOrLogError","keyRef","getSchEnv","removeSchema","_removeAllSchemas","clear","cacheKey","definitions","kwdOrDef","checkKeyword","addRule","keywordMetaschema","k","getKeyword","removeKeyword","findIndex","addFormat","separator","dataVar","map","text","keywordsJsonPointers","seg","schemaOrData","regex","startsWith","_compileMetaSchema","currentOpts","checkOpts","options","opt","optsSchemas","defs","metaOpts","KEYWORD_NAME","ruleGroup","find","before","addBeforeRule","_rule","$dataRef","anyOf","ucs2length","pos","charCodeAt","uri","ajv","validation","validateAdditionalItems","validateItems","additionalProperty","removeAdditional","allSchemaProperties","patProps","patternProperties","deleteAdditional","additionalPropertyCode","applyAdditionalSchema","definedProp","propsSchema","isOwnProperty","usePattern","isAdditional","schCxt","validateUnion","min","minContains","maxContains","next","validateItemsWithCount","schValid","checkLimits","_valid","validateSchemaDeps","validatePropertyDeps","depsCount","property_ies","missingProperty","propDeps","schDeps","propertyDeps","schemaDeps","splitDependencies","missing","hasProperty","propertyInData","depProp","checkReportMissingProp","checkMissingProp","reportMissingProp","ifClause","then","hasThen","hasSchema","hasElse","validateIf","validateClause","additionalItems_1","prefixItems_1","items_1","items2020_1","contains_1","dependencies_1","propertyNames_1","additionalProperties_1","properties_1","patternProperties_1","not_1","anyOf_1","oneOf_1","allOf_1","if_1","thenElse_1","draft2020","applicator","validateTuple","validateArray","extraItems","schArr","l","fullTuple","minItems","maxItems","checkStrictTuple","prefixItems","passing","util_2","patterns","alwaysValidPatterns","checkProperties","allowMatchingProperties","checkMatchingProperties","pat","validateProperties","alwaysValid","validatePatternProperties","additionalProperties","allProps","hasDefault","applyPropertySchema","schemaProperties","noPropertyInData","hasPropFunc","schemaMap","context","dataAndSchema","newRegExp","pattern","u","validArr","notValid","id_1","ref_1","core","callRef","getValidate","callRootRef","schOrEnv","callValidate","schName","inlineRefSchema","addErrorsFrom","addEvaluatedFrom","schEvaluated","callAsyncRef","types_1","discrError","tagName","DiscrError","Tag","tag","oneOf","mapping","applyTagSchema","oneOfMapping","topRequired","hasRequired","tagRequired","propSch","addMappings","required","addMapping","enum","tagValue","getMapping","Mapping","validateMapping","validation_1","applicator_1","format_1","metadata_1","draft7Vocabularies","metadataVocabulary","contentVocabulary","fmts","fDef","fType","callFormat","validData","invalidFmt","validate$DataFormat","formatDef","unknownMsg","unknownFormat","fmtType","fmtRef","fmtDef","fmt","getFormat","validCondition","validateFormat","equal_1","useLoop","eql","getEql","vSchema","equalCode","limitNumber_1","multipleOf_1","limitLength_1","pattern_1","limitProperties_1","required_1","limitItems_1","uniqueItems_1","const_1","enum_1","comp","ucs2length_1","ops","KWDs","maximum","okStr","minimum","exclusiveMaximum","exclusiveMinimum","prec","multipleOfPrecision","invalid","loopAllRequired","allErrorsMode","loopUntilMissing","exitOnErrorMode","requiredKey","j","itemTypes","loopN","indices","loopN2","outer"],"mappings":"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","file":"npm.ajv.f377289a9627442aa3db.react.bundle.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;\nconst core_1 = require(\"./core\");\nconst draft7_1 = require(\"./vocabularies/draft7\");\nconst discriminator_1 = require(\"./vocabularies/discriminator\");\nconst draft7MetaSchema = require(\"./refs/json-schema-draft-07.json\");\nconst META_SUPPORT_DATA = [\"/properties\"];\nconst META_SCHEMA_ID = \"http://json-schema.org/draft-07/schema\";\nclass Ajv extends core_1.default {\n    _addVocabularies() {\n        super._addVocabularies();\n        draft7_1.default.forEach((v) => this.addVocabulary(v));\n        if (this.opts.discriminator)\n            this.addKeyword(discriminator_1.default);\n    }\n    _addDefaultMetaSchema() {\n        super._addDefaultMetaSchema();\n        if (!this.opts.meta)\n            return;\n        const metaSchema = this.opts.$data\n            ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)\n            : draft7MetaSchema;\n        this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);\n        this.refs[\"http://json-schema.org/schema\"] = META_SCHEMA_ID;\n    }\n    defaultMeta() {\n        return (this.opts.defaultMeta =\n            super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined));\n    }\n}\nmodule.exports = exports = Ajv;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = Ajv;\nvar validate_1 = require(\"./compile/validate\");\nObject.defineProperty(exports, \"KeywordCxt\", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });\nvar codegen_1 = require(\"./compile/codegen\");\nObject.defineProperty(exports, \"_\", { enumerable: true, get: function () { return codegen_1._; } });\nObject.defineProperty(exports, \"str\", { enumerable: true, get: function () { return codegen_1.str; } });\nObject.defineProperty(exports, \"stringify\", { enumerable: true, get: function () { return codegen_1.stringify; } });\nObject.defineProperty(exports, \"nil\", { enumerable: true, get: function () { return codegen_1.nil; } });\nObject.defineProperty(exports, \"Name\", { enumerable: true, get: function () { return codegen_1.Name; } });\nObject.defineProperty(exports, \"CodeGen\", { enumerable: true, get: function () { return codegen_1.CodeGen; } });\n//# sourceMappingURL=ajv.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nclass _CodeOrName {\n}\nexports._CodeOrName = _CodeOrName;\nexports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;\nclass Name extends _CodeOrName {\n    constructor(s) {\n        super();\n        if (!exports.IDENTIFIER.test(s))\n            throw new Error(\"CodeGen: name must be a valid identifier\");\n        this.str = s;\n    }\n    toString() {\n        return this.str;\n    }\n    emptyStr() {\n        return false;\n    }\n    get names() {\n        return { [this.str]: 1 };\n    }\n}\nexports.Name = Name;\nclass _Code extends _CodeOrName {\n    constructor(code) {\n        super();\n        this._items = typeof code === \"string\" ? [code] : code;\n    }\n    toString() {\n        return this.str;\n    }\n    emptyStr() {\n        if (this._items.length > 1)\n            return false;\n        const item = this._items[0];\n        return item === \"\" || item === '\"\"';\n    }\n    get str() {\n        var _a;\n        return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, \"\")));\n    }\n    get names() {\n        var _a;\n        return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => {\n            if (c instanceof Name)\n                names[c.str] = (names[c.str] || 0) + 1;\n            return names;\n        }, {})));\n    }\n}\nexports._Code = _Code;\nexports.nil = new _Code(\"\");\nfunction _(strs, ...args) {\n    const code = [strs[0]];\n    let i = 0;\n    while (i < args.length) {\n        addCodeArg(code, args[i]);\n        code.push(strs[++i]);\n    }\n    return new _Code(code);\n}\nexports._ = _;\nconst plus = new _Code(\"+\");\nfunction str(strs, ...args) {\n    const expr = [safeStringify(strs[0])];\n    let i = 0;\n    while (i < args.length) {\n        expr.push(plus);\n        addCodeArg(expr, args[i]);\n        expr.push(plus, safeStringify(strs[++i]));\n    }\n    optimize(expr);\n    return new _Code(expr);\n}\nexports.str = str;\nfunction addCodeArg(code, arg) {\n    if (arg instanceof _Code)\n        code.push(...arg._items);\n    else if (arg instanceof Name)\n        code.push(arg);\n    else\n        code.push(interpolate(arg));\n}\nexports.addCodeArg = addCodeArg;\nfunction optimize(expr) {\n    let i = 1;\n    while (i < expr.length - 1) {\n        if (expr[i] === plus) {\n            const res = mergeExprItems(expr[i - 1], expr[i + 1]);\n            if (res !== undefined) {\n                expr.splice(i - 1, 3, res);\n                continue;\n            }\n            expr[i++] = \"+\";\n        }\n        i++;\n    }\n}\nfunction mergeExprItems(a, b) {\n    if (b === '\"\"')\n        return a;\n    if (a === '\"\"')\n        return b;\n    if (typeof a == \"string\") {\n        if (b instanceof Name || a[a.length - 1] !== '\"')\n            return;\n        if (typeof b != \"string\")\n            return `${a.slice(0, -1)}${b}\"`;\n        if (b[0] === '\"')\n            return a.slice(0, -1) + b.slice(1);\n        return;\n    }\n    if (typeof b == \"string\" && b[0] === '\"' && !(a instanceof Name))\n        return `\"${a}${b.slice(1)}`;\n    return;\n}\nfunction strConcat(c1, c2) {\n    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`;\n}\nexports.strConcat = strConcat;\n// TODO do not allow arrays here\nfunction interpolate(x) {\n    return typeof x == \"number\" || typeof x == \"boolean\" || x === null\n        ? x\n        : safeStringify(Array.isArray(x) ? x.join(\",\") : x);\n}\nfunction stringify(x) {\n    return new _Code(safeStringify(x));\n}\nexports.stringify = stringify;\nfunction safeStringify(x) {\n    return JSON.stringify(x)\n        .replace(/\\u2028/g, \"\\\\u2028\")\n        .replace(/\\u2029/g, \"\\\\u2029\");\n}\nexports.safeStringify = safeStringify;\nfunction getProperty(key) {\n    return typeof key == \"string\" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`;\n}\nexports.getProperty = getProperty;\n//Does best effort to format the name properly\nfunction getEsmExportName(key) {\n    if (typeof key == \"string\" && exports.IDENTIFIER.test(key)) {\n        return new _Code(`${key}`);\n    }\n    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);\n}\nexports.getEsmExportName = getEsmExportName;\nfunction regexpCode(rx) {\n    return new _Code(rx.toString());\n}\nexports.regexpCode = regexpCode;\n//# sourceMappingURL=code.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst code_1 = require(\"./code\");\nconst scope_1 = require(\"./scope\");\nvar code_2 = require(\"./code\");\nObject.defineProperty(exports, \"_\", { enumerable: true, get: function () { return code_2._; } });\nObject.defineProperty(exports, \"str\", { enumerable: true, get: function () { return code_2.str; } });\nObject.defineProperty(exports, \"strConcat\", { enumerable: true, get: function () { return code_2.strConcat; } });\nObject.defineProperty(exports, \"nil\", { enumerable: true, get: function () { return code_2.nil; } });\nObject.defineProperty(exports, \"getProperty\", { enumerable: true, get: function () { return code_2.getProperty; } });\nObject.defineProperty(exports, \"stringify\", { enumerable: true, get: function () { return code_2.stringify; } });\nObject.defineProperty(exports, \"regexpCode\", { enumerable: true, get: function () { return code_2.regexpCode; } });\nObject.defineProperty(exports, \"Name\", { enumerable: true, get: function () { return code_2.Name; } });\nvar scope_2 = require(\"./scope\");\nObject.defineProperty(exports, \"Scope\", { enumerable: true, get: function () { return scope_2.Scope; } });\nObject.defineProperty(exports, \"ValueScope\", { enumerable: true, get: function () { return scope_2.ValueScope; } });\nObject.defineProperty(exports, \"ValueScopeName\", { enumerable: true, get: function () { return scope_2.ValueScopeName; } });\nObject.defineProperty(exports, \"varKinds\", { enumerable: true, get: function () { return scope_2.varKinds; } });\nexports.operators = {\n    GT: new code_1._Code(\">\"),\n    GTE: new code_1._Code(\">=\"),\n    LT: new code_1._Code(\"<\"),\n    LTE: new code_1._Code(\"<=\"),\n    EQ: new code_1._Code(\"===\"),\n    NEQ: new code_1._Code(\"!==\"),\n    NOT: new code_1._Code(\"!\"),\n    OR: new code_1._Code(\"||\"),\n    AND: new code_1._Code(\"&&\"),\n    ADD: new code_1._Code(\"+\"),\n};\nclass Node {\n    optimizeNodes() {\n        return this;\n    }\n    optimizeNames(_names, _constants) {\n        return this;\n    }\n}\nclass Def extends Node {\n    constructor(varKind, name, rhs) {\n        super();\n        this.varKind = varKind;\n        this.name = name;\n        this.rhs = rhs;\n    }\n    render({ es5, _n }) {\n        const varKind = es5 ? scope_1.varKinds.var : this.varKind;\n        const rhs = this.rhs === undefined ? \"\" : ` = ${this.rhs}`;\n        return `${varKind} ${this.name}${rhs};` + _n;\n    }\n    optimizeNames(names, constants) {\n        if (!names[this.name.str])\n            return;\n        if (this.rhs)\n            this.rhs = optimizeExpr(this.rhs, names, constants);\n        return this;\n    }\n    get names() {\n        return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};\n    }\n}\nclass Assign extends Node {\n    constructor(lhs, rhs, sideEffects) {\n        super();\n        this.lhs = lhs;\n        this.rhs = rhs;\n        this.sideEffects = sideEffects;\n    }\n    render({ _n }) {\n        return `${this.lhs} = ${this.rhs};` + _n;\n    }\n    optimizeNames(names, constants) {\n        if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)\n            return;\n        this.rhs = optimizeExpr(this.rhs, names, constants);\n        return this;\n    }\n    get names() {\n        const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };\n        return addExprNames(names, this.rhs);\n    }\n}\nclass AssignOp extends Assign {\n    constructor(lhs, op, rhs, sideEffects) {\n        super(lhs, rhs, sideEffects);\n        this.op = op;\n    }\n    render({ _n }) {\n        return `${this.lhs} ${this.op}= ${this.rhs};` + _n;\n    }\n}\nclass Label extends Node {\n    constructor(label) {\n        super();\n        this.label = label;\n        this.names = {};\n    }\n    render({ _n }) {\n        return `${this.label}:` + _n;\n    }\n}\nclass Break extends Node {\n    constructor(label) {\n        super();\n        this.label = label;\n        this.names = {};\n    }\n    render({ _n }) {\n        const label = this.label ? ` ${this.label}` : \"\";\n        return `break${label};` + _n;\n    }\n}\nclass Throw extends Node {\n    constructor(error) {\n        super();\n        this.error = error;\n    }\n    render({ _n }) {\n        return `throw ${this.error};` + _n;\n    }\n    get names() {\n        return this.error.names;\n    }\n}\nclass AnyCode extends Node {\n    constructor(code) {\n        super();\n        this.code = code;\n    }\n    render({ _n }) {\n        return `${this.code};` + _n;\n    }\n    optimizeNodes() {\n        return `${this.code}` ? this : undefined;\n    }\n    optimizeNames(names, constants) {\n        this.code = optimizeExpr(this.code, names, constants);\n        return this;\n    }\n    get names() {\n        return this.code instanceof code_1._CodeOrName ? this.code.names : {};\n    }\n}\nclass ParentNode extends Node {\n    constructor(nodes = []) {\n        super();\n        this.nodes = nodes;\n    }\n    render(opts) {\n        return this.nodes.reduce((code, n) => code + n.render(opts), \"\");\n    }\n    optimizeNodes() {\n        const { nodes } = this;\n        let i = nodes.length;\n        while (i--) {\n            const n = nodes[i].optimizeNodes();\n            if (Array.isArray(n))\n                nodes.splice(i, 1, ...n);\n            else if (n)\n                nodes[i] = n;\n            else\n                nodes.splice(i, 1);\n        }\n        return nodes.length > 0 ? this : undefined;\n    }\n    optimizeNames(names, constants) {\n        const { nodes } = this;\n        let i = nodes.length;\n        while (i--) {\n            // iterating backwards improves 1-pass optimization\n            const n = nodes[i];\n            if (n.optimizeNames(names, constants))\n                continue;\n            subtractNames(names, n.names);\n            nodes.splice(i, 1);\n        }\n        return nodes.length > 0 ? this : undefined;\n    }\n    get names() {\n        return this.nodes.reduce((names, n) => addNames(names, n.names), {});\n    }\n}\nclass BlockNode extends ParentNode {\n    render(opts) {\n        return \"{\" + opts._n + super.render(opts) + \"}\" + opts._n;\n    }\n}\nclass Root extends ParentNode {\n}\nclass Else extends BlockNode {\n}\nElse.kind = \"else\";\nclass If extends BlockNode {\n    constructor(condition, nodes) {\n        super(nodes);\n        this.condition = condition;\n    }\n    render(opts) {\n        let code = `if(${this.condition})` + super.render(opts);\n        if (this.else)\n            code += \"else \" + this.else.render(opts);\n        return code;\n    }\n    optimizeNodes() {\n        super.optimizeNodes();\n        const cond = this.condition;\n        if (cond === true)\n            return this.nodes; // else is ignored here\n        let e = this.else;\n        if (e) {\n            const ns = e.optimizeNodes();\n            e = this.else = Array.isArray(ns) ? new Else(ns) : ns;\n        }\n        if (e) {\n            if (cond === false)\n                return e instanceof If ? e : e.nodes;\n            if (this.nodes.length)\n                return this;\n            return new If(not(cond), e instanceof If ? [e] : e.nodes);\n        }\n        if (cond === false || !this.nodes.length)\n            return undefined;\n        return this;\n    }\n    optimizeNames(names, constants) {\n        var _a;\n        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);\n        if (!(super.optimizeNames(names, constants) || this.else))\n            return;\n        this.condition = optimizeExpr(this.condition, names, constants);\n        return this;\n    }\n    get names() {\n        const names = super.names;\n        addExprNames(names, this.condition);\n        if (this.else)\n            addNames(names, this.else.names);\n        return names;\n    }\n}\nIf.kind = \"if\";\nclass For extends BlockNode {\n}\nFor.kind = \"for\";\nclass ForLoop extends For {\n    constructor(iteration) {\n        super();\n        this.iteration = iteration;\n    }\n    render(opts) {\n        return `for(${this.iteration})` + super.render(opts);\n    }\n    optimizeNames(names, constants) {\n        if (!super.optimizeNames(names, constants))\n            return;\n        this.iteration = optimizeExpr(this.iteration, names, constants);\n        return this;\n    }\n    get names() {\n        return addNames(super.names, this.iteration.names);\n    }\n}\nclass ForRange extends For {\n    constructor(varKind, name, from, to) {\n        super();\n        this.varKind = varKind;\n        this.name = name;\n        this.from = from;\n        this.to = to;\n    }\n    render(opts) {\n        const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;\n        const { name, from, to } = this;\n        return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);\n    }\n    get names() {\n        const names = addExprNames(super.names, this.from);\n        return addExprNames(names, this.to);\n    }\n}\nclass ForIter extends For {\n    constructor(loop, varKind, name, iterable) {\n        super();\n        this.loop = loop;\n        this.varKind = varKind;\n        this.name = name;\n        this.iterable = iterable;\n    }\n    render(opts) {\n        return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);\n    }\n    optimizeNames(names, constants) {\n        if (!super.optimizeNames(names, constants))\n            return;\n        this.iterable = optimizeExpr(this.iterable, names, constants);\n        return this;\n    }\n    get names() {\n        return addNames(super.names, this.iterable.names);\n    }\n}\nclass Func extends BlockNode {\n    constructor(name, args, async) {\n        super();\n        this.name = name;\n        this.args = args;\n        this.async = async;\n    }\n    render(opts) {\n        const _async = this.async ? \"async \" : \"\";\n        return `${_async}function ${this.name}(${this.args})` + super.render(opts);\n    }\n}\nFunc.kind = \"func\";\nclass Return extends ParentNode {\n    render(opts) {\n        return \"return \" + super.render(opts);\n    }\n}\nReturn.kind = \"return\";\nclass Try extends BlockNode {\n    render(opts) {\n        let code = \"try\" + super.render(opts);\n        if (this.catch)\n            code += this.catch.render(opts);\n        if (this.finally)\n            code += this.finally.render(opts);\n        return code;\n    }\n    optimizeNodes() {\n        var _a, _b;\n        super.optimizeNodes();\n        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes();\n        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();\n        return this;\n    }\n    optimizeNames(names, constants) {\n        var _a, _b;\n        super.optimizeNames(names, constants);\n        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);\n        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);\n        return this;\n    }\n    get names() {\n        const names = super.names;\n        if (this.catch)\n            addNames(names, this.catch.names);\n        if (this.finally)\n            addNames(names, this.finally.names);\n        return names;\n    }\n}\nclass Catch extends BlockNode {\n    constructor(error) {\n        super();\n        this.error = error;\n    }\n    render(opts) {\n        return `catch(${this.error})` + super.render(opts);\n    }\n}\nCatch.kind = \"catch\";\nclass Finally extends BlockNode {\n    render(opts) {\n        return \"finally\" + super.render(opts);\n    }\n}\nFinally.kind = \"finally\";\nclass CodeGen {\n    constructor(extScope, opts = {}) {\n        this._values = {};\n        this._blockStarts = [];\n        this._constants = {};\n        this.opts = { ...opts, _n: opts.lines ? \"\\n\" : \"\" };\n        this._extScope = extScope;\n        this._scope = new scope_1.Scope({ parent: extScope });\n        this._nodes = [new Root()];\n    }\n    toString() {\n        return this._root.render(this.opts);\n    }\n    // returns unique name in the internal scope\n    name(prefix) {\n        return this._scope.name(prefix);\n    }\n    // reserves unique name in the external scope\n    scopeName(prefix) {\n        return this._extScope.name(prefix);\n    }\n    // reserves unique name in the external scope and assigns value to it\n    scopeValue(prefixOrName, value) {\n        const name = this._extScope.value(prefixOrName, value);\n        const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set());\n        vs.add(name);\n        return name;\n    }\n    getScopeValue(prefix, keyOrRef) {\n        return this._extScope.getValue(prefix, keyOrRef);\n    }\n    // return code that assigns values in the external scope to the names that are used internally\n    // (same names that were returned by gen.scopeName or gen.scopeValue)\n    scopeRefs(scopeName) {\n        return this._extScope.scopeRefs(scopeName, this._values);\n    }\n    scopeCode() {\n        return this._extScope.scopeCode(this._values);\n    }\n    _def(varKind, nameOrPrefix, rhs, constant) {\n        const name = this._scope.toName(nameOrPrefix);\n        if (rhs !== undefined && constant)\n            this._constants[name.str] = rhs;\n        this._leafNode(new Def(varKind, name, rhs));\n        return name;\n    }\n    // `const` declaration (`var` in es5 mode)\n    const(nameOrPrefix, rhs, _constant) {\n        return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);\n    }\n    // `let` declaration with optional assignment (`var` in es5 mode)\n    let(nameOrPrefix, rhs, _constant) {\n        return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);\n    }\n    // `var` declaration with optional assignment\n    var(nameOrPrefix, rhs, _constant) {\n        return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);\n    }\n    // assignment code\n    assign(lhs, rhs, sideEffects) {\n        return this._leafNode(new Assign(lhs, rhs, sideEffects));\n    }\n    // `+=` code\n    add(lhs, rhs) {\n        return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));\n    }\n    // appends passed SafeExpr to code or executes Block\n    code(c) {\n        if (typeof c == \"function\")\n            c();\n        else if (c !== code_1.nil)\n            this._leafNode(new AnyCode(c));\n        return this;\n    }\n    // returns code for object literal for the passed argument list of key-value pairs\n    object(...keyValues) {\n        const code = [\"{\"];\n        for (const [key, value] of keyValues) {\n            if (code.length > 1)\n                code.push(\",\");\n            code.push(key);\n            if (key !== value || this.opts.es5) {\n                code.push(\":\");\n                (0, code_1.addCodeArg)(code, value);\n            }\n        }\n        code.push(\"}\");\n        return new code_1._Code(code);\n    }\n    // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)\n    if(condition, thenBody, elseBody) {\n        this._blockNode(new If(condition));\n        if (thenBody && elseBody) {\n            this.code(thenBody).else().code(elseBody).endIf();\n        }\n        else if (thenBody) {\n            this.code(thenBody).endIf();\n        }\n        else if (elseBody) {\n            throw new Error('CodeGen: \"else\" body without \"then\" body');\n        }\n        return this;\n    }\n    // `else if` clause - invalid without `if` or after `else` clauses\n    elseIf(condition) {\n        return this._elseNode(new If(condition));\n    }\n    // `else` clause - only valid after `if` or `else if` clauses\n    else() {\n        return this._elseNode(new Else());\n    }\n    // end `if` statement (needed if gen.if was used only with condition)\n    endIf() {\n        return this._endBlockNode(If, Else);\n    }\n    _for(node, forBody) {\n        this._blockNode(node);\n        if (forBody)\n            this.code(forBody).endFor();\n        return this;\n    }\n    // a generic `for` clause (or statement if `forBody` is passed)\n    for(iteration, forBody) {\n        return this._for(new ForLoop(iteration), forBody);\n    }\n    // `for` statement for a range of values\n    forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {\n        const name = this._scope.toName(nameOrPrefix);\n        return this._for(new ForRange(varKind, name, from, to), () => forBody(name));\n    }\n    // `for-of` statement (in es5 mode replace with a normal for loop)\n    forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {\n        const name = this._scope.toName(nameOrPrefix);\n        if (this.opts.es5) {\n            const arr = iterable instanceof code_1.Name ? iterable : this.var(\"_arr\", iterable);\n            return this.forRange(\"_i\", 0, (0, code_1._) `${arr}.length`, (i) => {\n                this.var(name, (0, code_1._) `${arr}[${i}]`);\n                forBody(name);\n            });\n        }\n        return this._for(new ForIter(\"of\", varKind, name, iterable), () => forBody(name));\n    }\n    // `for-in` statement.\n    // With option `ownProperties` replaced with a `for-of` loop for object keys\n    forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {\n        if (this.opts.ownProperties) {\n            return this.forOf(nameOrPrefix, (0, code_1._) `Object.keys(${obj})`, forBody);\n        }\n        const name = this._scope.toName(nameOrPrefix);\n        return this._for(new ForIter(\"in\", varKind, name, obj), () => forBody(name));\n    }\n    // end `for` loop\n    endFor() {\n        return this._endBlockNode(For);\n    }\n    // `label` statement\n    label(label) {\n        return this._leafNode(new Label(label));\n    }\n    // `break` statement\n    break(label) {\n        return this._leafNode(new Break(label));\n    }\n    // `return` statement\n    return(value) {\n        const node = new Return();\n        this._blockNode(node);\n        this.code(value);\n        if (node.nodes.length !== 1)\n            throw new Error('CodeGen: \"return\" should have one node');\n        return this._endBlockNode(Return);\n    }\n    // `try` statement\n    try(tryBody, catchCode, finallyCode) {\n        if (!catchCode && !finallyCode)\n            throw new Error('CodeGen: \"try\" without \"catch\" and \"finally\"');\n        const node = new Try();\n        this._blockNode(node);\n        this.code(tryBody);\n        if (catchCode) {\n            const error = this.name(\"e\");\n            this._currNode = node.catch = new Catch(error);\n            catchCode(error);\n        }\n        if (finallyCode) {\n            this._currNode = node.finally = new Finally();\n            this.code(finallyCode);\n        }\n        return this._endBlockNode(Catch, Finally);\n    }\n    // `throw` statement\n    throw(error) {\n        return this._leafNode(new Throw(error));\n    }\n    // start self-balancing block\n    block(body, nodeCount) {\n        this._blockStarts.push(this._nodes.length);\n        if (body)\n            this.code(body).endBlock(nodeCount);\n        return this;\n    }\n    // end the current self-balancing block\n    endBlock(nodeCount) {\n        const len = this._blockStarts.pop();\n        if (len === undefined)\n            throw new Error(\"CodeGen: not in self-balancing block\");\n        const toClose = this._nodes.length - len;\n        if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) {\n            throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);\n        }\n        this._nodes.length = len;\n        return this;\n    }\n    // `function` heading (or definition if funcBody is passed)\n    func(name, args = code_1.nil, async, funcBody) {\n        this._blockNode(new Func(name, args, async));\n        if (funcBody)\n            this.code(funcBody).endFunc();\n        return this;\n    }\n    // end function definition\n    endFunc() {\n        return this._endBlockNode(Func);\n    }\n    optimize(n = 1) {\n        while (n-- > 0) {\n            this._root.optimizeNodes();\n            this._root.optimizeNames(this._root.names, this._constants);\n        }\n    }\n    _leafNode(node) {\n        this._currNode.nodes.push(node);\n        return this;\n    }\n    _blockNode(node) {\n        this._currNode.nodes.push(node);\n        this._nodes.push(node);\n    }\n    _endBlockNode(N1, N2) {\n        const n = this._currNode;\n        if (n instanceof N1 || (N2 && n instanceof N2)) {\n            this._nodes.pop();\n            return this;\n        }\n        throw new Error(`CodeGen: not in block \"${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}\"`);\n    }\n    _elseNode(node) {\n        const n = this._currNode;\n        if (!(n instanceof If)) {\n            throw new Error('CodeGen: \"else\" without \"if\"');\n        }\n        this._currNode = n.else = node;\n        return this;\n    }\n    get _root() {\n        return this._nodes[0];\n    }\n    get _currNode() {\n        const ns = this._nodes;\n        return ns[ns.length - 1];\n    }\n    set _currNode(node) {\n        const ns = this._nodes;\n        ns[ns.length - 1] = node;\n    }\n}\nexports.CodeGen = CodeGen;\nfunction addNames(names, from) {\n    for (const n in from)\n        names[n] = (names[n] || 0) + (from[n] || 0);\n    return names;\n}\nfunction addExprNames(names, from) {\n    return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;\n}\nfunction optimizeExpr(expr, names, constants) {\n    if (expr instanceof code_1.Name)\n        return replaceName(expr);\n    if (!canOptimize(expr))\n        return expr;\n    return new code_1._Code(expr._items.reduce((items, c) => {\n        if (c instanceof code_1.Name)\n            c = replaceName(c);\n        if (c instanceof code_1._Code)\n            items.push(...c._items);\n        else\n            items.push(c);\n        return items;\n    }, []));\n    function replaceName(n) {\n        const c = constants[n.str];\n        if (c === undefined || names[n.str] !== 1)\n            return n;\n        delete names[n.str];\n        return c;\n    }\n    function canOptimize(e) {\n        return (e instanceof code_1._Code &&\n            e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined));\n    }\n}\nfunction subtractNames(names, from) {\n    for (const n in from)\n        names[n] = (names[n] || 0) - (from[n] || 0);\n}\nfunction not(x) {\n    return typeof x == \"boolean\" || typeof x == \"number\" || x === null ? !x : (0, code_1._) `!${par(x)}`;\n}\nexports.not = not;\nconst andCode = mappend(exports.operators.AND);\n// boolean AND (&&) expression with the passed arguments\nfunction and(...args) {\n    return args.reduce(andCode);\n}\nexports.and = and;\nconst orCode = mappend(exports.operators.OR);\n// boolean OR (||) expression with the passed arguments\nfunction or(...args) {\n    return args.reduce(orCode);\n}\nexports.or = or;\nfunction mappend(op) {\n    return (x, y) => (x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._) `${par(x)} ${op} ${par(y)}`);\n}\nfunction par(x) {\n    return x instanceof code_1.Name ? x : (0, code_1._) `(${x})`;\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;\nconst code_1 = require(\"./code\");\nclass ValueError extends Error {\n    constructor(name) {\n        super(`CodeGen: \"code\" for ${name} not defined`);\n        this.value = name.value;\n    }\n}\nvar UsedValueState;\n(function (UsedValueState) {\n    UsedValueState[UsedValueState[\"Started\"] = 0] = \"Started\";\n    UsedValueState[UsedValueState[\"Completed\"] = 1] = \"Completed\";\n})(UsedValueState = exports.UsedValueState || (exports.UsedValueState = {}));\nexports.varKinds = {\n    const: new code_1.Name(\"const\"),\n    let: new code_1.Name(\"let\"),\n    var: new code_1.Name(\"var\"),\n};\nclass Scope {\n    constructor({ prefixes, parent } = {}) {\n        this._names = {};\n        this._prefixes = prefixes;\n        this._parent = parent;\n    }\n    toName(nameOrPrefix) {\n        return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);\n    }\n    name(prefix) {\n        return new code_1.Name(this._newName(prefix));\n    }\n    _newName(prefix) {\n        const ng = this._names[prefix] || this._nameGroup(prefix);\n        return `${prefix}${ng.index++}`;\n    }\n    _nameGroup(prefix) {\n        var _a, _b;\n        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))) {\n            throw new Error(`CodeGen: prefix \"${prefix}\" is not allowed in this scope`);\n        }\n        return (this._names[prefix] = { prefix, index: 0 });\n    }\n}\nexports.Scope = Scope;\nclass ValueScopeName extends code_1.Name {\n    constructor(prefix, nameStr) {\n        super(nameStr);\n        this.prefix = prefix;\n    }\n    setValue(value, { property, itemIndex }) {\n        this.value = value;\n        this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`;\n    }\n}\nexports.ValueScopeName = ValueScopeName;\nconst line = (0, code_1._) `\\n`;\nclass ValueScope extends Scope {\n    constructor(opts) {\n        super(opts);\n        this._values = {};\n        this._scope = opts.scope;\n        this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };\n    }\n    get() {\n        return this._scope;\n    }\n    name(prefix) {\n        return new ValueScopeName(prefix, this._newName(prefix));\n    }\n    value(nameOrPrefix, value) {\n        var _a;\n        if (value.ref === undefined)\n            throw new Error(\"CodeGen: ref must be passed in value\");\n        const name = this.toName(nameOrPrefix);\n        const { prefix } = name;\n        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;\n        let vs = this._values[prefix];\n        if (vs) {\n            const _name = vs.get(valueKey);\n            if (_name)\n                return _name;\n        }\n        else {\n            vs = this._values[prefix] = new Map();\n        }\n        vs.set(valueKey, name);\n        const s = this._scope[prefix] || (this._scope[prefix] = []);\n        const itemIndex = s.length;\n        s[itemIndex] = value.ref;\n        name.setValue(value, { property: prefix, itemIndex });\n        return name;\n    }\n    getValue(prefix, keyOrRef) {\n        const vs = this._values[prefix];\n        if (!vs)\n            return;\n        return vs.get(keyOrRef);\n    }\n    scopeRefs(scopeName, values = this._values) {\n        return this._reduceValues(values, (name) => {\n            if (name.scopePath === undefined)\n                throw new Error(`CodeGen: name \"${name}\" has no value`);\n            return (0, code_1._) `${scopeName}${name.scopePath}`;\n        });\n    }\n    scopeCode(values = this._values, usedValues, getCode) {\n        return this._reduceValues(values, (name) => {\n            if (name.value === undefined)\n                throw new Error(`CodeGen: name \"${name}\" has no value`);\n            return name.value.code;\n        }, usedValues, getCode);\n    }\n    _reduceValues(values, valueCode, usedValues = {}, getCode) {\n        let code = code_1.nil;\n        for (const prefix in values) {\n            const vs = values[prefix];\n            if (!vs)\n                continue;\n            const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map());\n            vs.forEach((name) => {\n                if (nameSet.has(name))\n                    return;\n                nameSet.set(name, UsedValueState.Started);\n                let c = valueCode(name);\n                if (c) {\n                    const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;\n                    code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`;\n                }\n                else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) {\n                    code = (0, code_1._) `${code}${c}${this.opts._n}`;\n                }\n                else {\n                    throw new ValueError(name);\n                }\n                nameSet.set(name, UsedValueState.Completed);\n            });\n        }\n        return code;\n    }\n}\nexports.ValueScope = ValueScope;\n//# sourceMappingURL=scope.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;\nconst codegen_1 = require(\"./codegen\");\nconst util_1 = require(\"./util\");\nconst names_1 = require(\"./names\");\nexports.keywordError = {\n    message: ({ keyword }) => (0, codegen_1.str) `must pass \"${keyword}\" keyword validation`,\n};\nexports.keyword$DataError = {\n    message: ({ keyword, schemaType }) => schemaType\n        ? (0, codegen_1.str) `\"${keyword}\" keyword must be ${schemaType} ($data)`\n        : (0, codegen_1.str) `\"${keyword}\" keyword is invalid ($data)`,\n};\nfunction reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {\n    const { it } = cxt;\n    const { gen, compositeRule, allErrors } = it;\n    const errObj = errorObjectCode(cxt, error, errorPaths);\n    if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : (compositeRule || allErrors)) {\n        addError(gen, errObj);\n    }\n    else {\n        returnErrors(it, (0, codegen_1._) `[${errObj}]`);\n    }\n}\nexports.reportError = reportError;\nfunction reportExtraError(cxt, error = exports.keywordError, errorPaths) {\n    const { it } = cxt;\n    const { gen, compositeRule, allErrors } = it;\n    const errObj = errorObjectCode(cxt, error, errorPaths);\n    addError(gen, errObj);\n    if (!(compositeRule || allErrors)) {\n        returnErrors(it, names_1.default.vErrors);\n    }\n}\nexports.reportExtraError = reportExtraError;\nfunction resetErrorsCount(gen, errsCount) {\n    gen.assign(names_1.default.errors, errsCount);\n    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)));\n}\nexports.resetErrorsCount = resetErrorsCount;\nfunction extendErrors({ gen, keyword, schemaValue, data, errsCount, it, }) {\n    /* istanbul ignore if */\n    if (errsCount === undefined)\n        throw new Error(\"ajv implementation error\");\n    const err = gen.name(\"err\");\n    gen.forRange(\"i\", errsCount, names_1.default.errors, (i) => {\n        gen.const(err, (0, codegen_1._) `${names_1.default.vErrors}[${i}]`);\n        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)));\n        gen.assign((0, codegen_1._) `${err}.schemaPath`, (0, codegen_1.str) `${it.errSchemaPath}/${keyword}`);\n        if (it.opts.verbose) {\n            gen.assign((0, codegen_1._) `${err}.schema`, schemaValue);\n            gen.assign((0, codegen_1._) `${err}.data`, data);\n        }\n    });\n}\nexports.extendErrors = extendErrors;\nfunction addError(gen, errObj) {\n    const err = gen.const(\"err\", errObj);\n    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})`);\n    gen.code((0, codegen_1._) `${names_1.default.errors}++`);\n}\nfunction returnErrors(it, errs) {\n    const { gen, validateName, schemaEnv } = it;\n    if (schemaEnv.$async) {\n        gen.throw((0, codegen_1._) `new ${it.ValidationError}(${errs})`);\n    }\n    else {\n        gen.assign((0, codegen_1._) `${validateName}.errors`, errs);\n        gen.return(false);\n    }\n}\nconst E = {\n    keyword: new codegen_1.Name(\"keyword\"),\n    schemaPath: new codegen_1.Name(\"schemaPath\"),\n    params: new codegen_1.Name(\"params\"),\n    propertyName: new codegen_1.Name(\"propertyName\"),\n    message: new codegen_1.Name(\"message\"),\n    schema: new codegen_1.Name(\"schema\"),\n    parentSchema: new codegen_1.Name(\"parentSchema\"),\n};\nfunction errorObjectCode(cxt, error, errorPaths) {\n    const { createErrors } = cxt.it;\n    if (createErrors === false)\n        return (0, codegen_1._) `{}`;\n    return errorObject(cxt, error, errorPaths);\n}\nfunction errorObject(cxt, error, errorPaths = {}) {\n    const { gen, it } = cxt;\n    const keyValues = [\n        errorInstancePath(it, errorPaths),\n        errorSchemaPath(cxt, errorPaths),\n    ];\n    extraErrorProps(cxt, error, keyValues);\n    return gen.object(...keyValues);\n}\nfunction errorInstancePath({ errorPath }, { instancePath }) {\n    const instPath = instancePath\n        ? (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`\n        : errorPath;\n    return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];\n}\nfunction errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {\n    let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str) `${errSchemaPath}/${keyword}`;\n    if (schemaPath) {\n        schPath = (0, codegen_1.str) `${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;\n    }\n    return [E.schemaPath, schPath];\n}\nfunction extraErrorProps(cxt, { params, message }, keyValues) {\n    const { keyword, data, schemaValue, it } = cxt;\n    const { opts, propertyName, topSchemaRef, schemaPath } = it;\n    keyValues.push([E.keyword, keyword], [E.params, typeof params == \"function\" ? params(cxt) : params || (0, codegen_1._) `{}`]);\n    if (opts.messages) {\n        keyValues.push([E.message, typeof message == \"function\" ? message(cxt) : message]);\n    }\n    if (opts.verbose) {\n        keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._) `${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);\n    }\n    if (propertyName)\n        keyValues.push([E.propertyName, propertyName]);\n}\n//# sourceMappingURL=errors.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;\nconst codegen_1 = require(\"./codegen\");\nconst validation_error_1 = require(\"../runtime/validation_error\");\nconst names_1 = require(\"./names\");\nconst resolve_1 = require(\"./resolve\");\nconst util_1 = require(\"./util\");\nconst validate_1 = require(\"./validate\");\nclass SchemaEnv {\n    constructor(env) {\n        var _a;\n        this.refs = {};\n        this.dynamicAnchors = {};\n        let schema;\n        if (typeof env.schema == \"object\")\n            schema = env.schema;\n        this.schema = env.schema;\n        this.schemaId = env.schemaId;\n        this.root = env.root || this;\n        this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || \"$id\"]);\n        this.schemaPath = env.schemaPath;\n        this.localRefs = env.localRefs;\n        this.meta = env.meta;\n        this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;\n        this.refs = {};\n    }\n}\nexports.SchemaEnv = SchemaEnv;\n// let codeSize = 0\n// let nodeCount = 0\n// Compiles schema in SchemaEnv\nfunction compileSchema(sch) {\n    // TODO refactor - remove compilations\n    const _sch = getCompilingSchema.call(this, sch);\n    if (_sch)\n        return _sch;\n    const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId); // TODO if getFullPath removed 1 tests fails\n    const { es5, lines } = this.opts.code;\n    const { ownProperties } = this.opts;\n    const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });\n    let _ValidationError;\n    if (sch.$async) {\n        _ValidationError = gen.scopeValue(\"Error\", {\n            ref: validation_error_1.default,\n            code: (0, codegen_1._) `require(\"ajv/dist/runtime/validation_error\").default`,\n        });\n    }\n    const validateName = gen.scopeName(\"validate\");\n    sch.validateName = validateName;\n    const schemaCxt = {\n        gen,\n        allErrors: this.opts.allErrors,\n        data: names_1.default.data,\n        parentData: names_1.default.parentData,\n        parentDataProperty: names_1.default.parentDataProperty,\n        dataNames: [names_1.default.data],\n        dataPathArr: [codegen_1.nil],\n        dataLevel: 0,\n        dataTypes: [],\n        definedProperties: new Set(),\n        topSchemaRef: gen.scopeValue(\"schema\", this.opts.code.source === true\n            ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) }\n            : { ref: sch.schema }),\n        validateName,\n        ValidationError: _ValidationError,\n        schema: sch.schema,\n        schemaEnv: sch,\n        rootId,\n        baseId: sch.baseId || rootId,\n        schemaPath: codegen_1.nil,\n        errSchemaPath: sch.schemaPath || (this.opts.jtd ? \"\" : \"#\"),\n        errorPath: (0, codegen_1._) `\"\"`,\n        opts: this.opts,\n        self: this,\n    };\n    let sourceCode;\n    try {\n        this._compilations.add(sch);\n        (0, validate_1.validateFunctionCode)(schemaCxt);\n        gen.optimize(this.opts.code.optimize);\n        // gen.optimize(1)\n        const validateCode = gen.toString();\n        sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;\n        // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))\n        if (this.opts.code.process)\n            sourceCode = this.opts.code.process(sourceCode, sch);\n        // console.log(\"\\n\\n\\n *** \\n\", sourceCode)\n        const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);\n        const validate = makeValidate(this, this.scope.get());\n        this.scope.value(validateName, { ref: validate });\n        validate.errors = null;\n        validate.schema = sch.schema;\n        validate.schemaEnv = sch;\n        if (sch.$async)\n            validate.$async = true;\n        if (this.opts.code.source === true) {\n            validate.source = { validateName, validateCode, scopeValues: gen._values };\n        }\n        if (this.opts.unevaluated) {\n            const { props, items } = schemaCxt;\n            validate.evaluated = {\n                props: props instanceof codegen_1.Name ? undefined : props,\n                items: items instanceof codegen_1.Name ? undefined : items,\n                dynamicProps: props instanceof codegen_1.Name,\n                dynamicItems: items instanceof codegen_1.Name,\n            };\n            if (validate.source)\n                validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);\n        }\n        sch.validate = validate;\n        return sch;\n    }\n    catch (e) {\n        delete sch.validate;\n        delete sch.validateName;\n        if (sourceCode)\n            this.logger.error(\"Error compiling schema, function code:\", sourceCode);\n        // console.log(\"\\n\\n\\n *** \\n\", sourceCode, this.opts)\n        throw e;\n    }\n    finally {\n        this._compilations.delete(sch);\n    }\n}\nexports.compileSchema = compileSchema;\nfunction resolveRef(root, baseId, ref) {\n    var _a;\n    ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);\n    const schOrFunc = root.refs[ref];\n    if (schOrFunc)\n        return schOrFunc;\n    let _sch = resolve.call(this, root, ref);\n    if (_sch === undefined) {\n        const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref]; // TODO maybe localRefs should hold SchemaEnv\n        const { schemaId } = this.opts;\n        if (schema)\n            _sch = new SchemaEnv({ schema, schemaId, root, baseId });\n    }\n    if (_sch === undefined)\n        return;\n    return (root.refs[ref] = inlineOrCompile.call(this, _sch));\n}\nexports.resolveRef = resolveRef;\nfunction inlineOrCompile(sch) {\n    if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))\n        return sch.schema;\n    return sch.validate ? sch : compileSchema.call(this, sch);\n}\n// Index of schema compilation in the currently compiled list\nfunction getCompilingSchema(schEnv) {\n    for (const sch of this._compilations) {\n        if (sameSchemaEnv(sch, schEnv))\n            return sch;\n    }\n}\nexports.getCompilingSchema = getCompilingSchema;\nfunction sameSchemaEnv(s1, s2) {\n    return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;\n}\n// resolve and compile the references ($ref)\n// TODO returns AnySchemaObject (if the schema can be inlined) or validation function\nfunction resolve(root, // information about the root schema for the current schema\nref // reference to resolve\n) {\n    let sch;\n    while (typeof (sch = this.refs[ref]) == \"string\")\n        ref = sch;\n    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);\n}\n// Resolve schema, its root and baseId\nfunction resolveSchema(root, // root object with properties schema, refs TODO below SchemaEnv is assigned to it\nref // reference to resolve\n) {\n    const p = this.opts.uriResolver.parse(ref);\n    const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);\n    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, undefined);\n    // TODO `Object.keys(root.schema).length > 0` should not be needed - but removing breaks 2 tests\n    if (Object.keys(root.schema).length > 0 && refPath === baseId) {\n        return getJsonPointer.call(this, p, root);\n    }\n    const id = (0, resolve_1.normalizeId)(refPath);\n    const schOrRef = this.refs[id] || this.schemas[id];\n    if (typeof schOrRef == \"string\") {\n        const sch = resolveSchema.call(this, root, schOrRef);\n        if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== \"object\")\n            return;\n        return getJsonPointer.call(this, p, sch);\n    }\n    if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== \"object\")\n        return;\n    if (!schOrRef.validate)\n        compileSchema.call(this, schOrRef);\n    if (id === (0, resolve_1.normalizeId)(ref)) {\n        const { schema } = schOrRef;\n        const { schemaId } = this.opts;\n        const schId = schema[schemaId];\n        if (schId)\n            baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);\n        return new SchemaEnv({ schema, schemaId, root, baseId });\n    }\n    return getJsonPointer.call(this, p, schOrRef);\n}\nexports.resolveSchema = resolveSchema;\nconst PREVENT_SCOPE_CHANGE = new Set([\n    \"properties\",\n    \"patternProperties\",\n    \"enum\",\n    \"dependencies\",\n    \"definitions\",\n]);\nfunction getJsonPointer(parsedRef, { baseId, schema, root }) {\n    var _a;\n    if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== \"/\")\n        return;\n    for (const part of parsedRef.fragment.slice(1).split(\"/\")) {\n        if (typeof schema === \"boolean\")\n            return;\n        const partSchema = schema[(0, util_1.unescapeFragment)(part)];\n        if (partSchema === undefined)\n            return;\n        schema = partSchema;\n        // TODO PREVENT_SCOPE_CHANGE could be defined in keyword def?\n        const schId = typeof schema === \"object\" && schema[this.opts.schemaId];\n        if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {\n            baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);\n        }\n    }\n    let env;\n    if (typeof schema != \"boolean\" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {\n        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);\n        env = resolveSchema.call(this, root, $ref);\n    }\n    // even though resolution failed we need to return SchemaEnv to throw exception\n    // so that compileAsync loads missing schema.\n    const { schemaId } = this.opts;\n    env = env || new SchemaEnv({ schema, schemaId, root, baseId });\n    if (env.schema !== env.root.schema)\n        return env;\n    return undefined;\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"./codegen\");\nconst names = {\n    // validation function arguments\n    data: new codegen_1.Name(\"data\"),\n    // args passed from referencing schema\n    valCxt: new codegen_1.Name(\"valCxt\"),\n    instancePath: new codegen_1.Name(\"instancePath\"),\n    parentData: new codegen_1.Name(\"parentData\"),\n    parentDataProperty: new codegen_1.Name(\"parentDataProperty\"),\n    rootData: new codegen_1.Name(\"rootData\"),\n    dynamicAnchors: new codegen_1.Name(\"dynamicAnchors\"),\n    // function scoped variables\n    vErrors: new codegen_1.Name(\"vErrors\"),\n    errors: new codegen_1.Name(\"errors\"),\n    this: new codegen_1.Name(\"this\"),\n    // \"globals\"\n    self: new codegen_1.Name(\"self\"),\n    scope: new codegen_1.Name(\"scope\"),\n    // JTD serialize/parse name for JSON string and position\n    json: new codegen_1.Name(\"json\"),\n    jsonPos: new codegen_1.Name(\"jsonPos\"),\n    jsonLen: new codegen_1.Name(\"jsonLen\"),\n    jsonPart: new codegen_1.Name(\"jsonPart\"),\n};\nexports.default = names;\n//# sourceMappingURL=names.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst resolve_1 = require(\"./resolve\");\nclass MissingRefError extends Error {\n    constructor(resolver, baseId, ref, msg) {\n        super(msg || `can't resolve reference ${ref} from id ${baseId}`);\n        this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);\n        this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));\n    }\n}\nexports.default = MissingRefError;\n//# sourceMappingURL=ref_error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;\nconst util_1 = require(\"./util\");\nconst equal = require(\"fast-deep-equal\");\nconst traverse = require(\"json-schema-traverse\");\n// TODO refactor to use keyword definitions\nconst SIMPLE_INLINED = new Set([\n    \"type\",\n    \"format\",\n    \"pattern\",\n    \"maxLength\",\n    \"minLength\",\n    \"maxProperties\",\n    \"minProperties\",\n    \"maxItems\",\n    \"minItems\",\n    \"maximum\",\n    \"minimum\",\n    \"uniqueItems\",\n    \"multipleOf\",\n    \"required\",\n    \"enum\",\n    \"const\",\n]);\nfunction inlineRef(schema, limit = true) {\n    if (typeof schema == \"boolean\")\n        return true;\n    if (limit === true)\n        return !hasRef(schema);\n    if (!limit)\n        return false;\n    return countKeys(schema) <= limit;\n}\nexports.inlineRef = inlineRef;\nconst REF_KEYWORDS = new Set([\n    \"$ref\",\n    \"$recursiveRef\",\n    \"$recursiveAnchor\",\n    \"$dynamicRef\",\n    \"$dynamicAnchor\",\n]);\nfunction hasRef(schema) {\n    for (const key in schema) {\n        if (REF_KEYWORDS.has(key))\n            return true;\n        const sch = schema[key];\n        if (Array.isArray(sch) && sch.some(hasRef))\n            return true;\n        if (typeof sch == \"object\" && hasRef(sch))\n            return true;\n    }\n    return false;\n}\nfunction countKeys(schema) {\n    let count = 0;\n    for (const key in schema) {\n        if (key === \"$ref\")\n            return Infinity;\n        count++;\n        if (SIMPLE_INLINED.has(key))\n            continue;\n        if (typeof schema[key] == \"object\") {\n            (0, util_1.eachItem)(schema[key], (sch) => (count += countKeys(sch)));\n        }\n        if (count === Infinity)\n            return Infinity;\n    }\n    return count;\n}\nfunction getFullPath(resolver, id = \"\", normalize) {\n    if (normalize !== false)\n        id = normalizeId(id);\n    const p = resolver.parse(id);\n    return _getFullPath(resolver, p);\n}\nexports.getFullPath = getFullPath;\nfunction _getFullPath(resolver, p) {\n    const serialized = resolver.serialize(p);\n    return serialized.split(\"#\")[0] + \"#\";\n}\nexports._getFullPath = _getFullPath;\nconst TRAILING_SLASH_HASH = /#\\/?$/;\nfunction normalizeId(id) {\n    return id ? id.replace(TRAILING_SLASH_HASH, \"\") : \"\";\n}\nexports.normalizeId = normalizeId;\nfunction resolveUrl(resolver, baseId, id) {\n    id = normalizeId(id);\n    return resolver.resolve(baseId, id);\n}\nexports.resolveUrl = resolveUrl;\nconst ANCHOR = /^[a-z_][-a-z0-9._]*$/i;\nfunction getSchemaRefs(schema, baseId) {\n    if (typeof schema == \"boolean\")\n        return {};\n    const { schemaId, uriResolver } = this.opts;\n    const schId = normalizeId(schema[schemaId] || baseId);\n    const baseIds = { \"\": schId };\n    const pathPrefix = getFullPath(uriResolver, schId, false);\n    const localRefs = {};\n    const schemaRefs = new Set();\n    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {\n        if (parentJsonPtr === undefined)\n            return;\n        const fullPath = pathPrefix + jsonPtr;\n        let baseId = baseIds[parentJsonPtr];\n        if (typeof sch[schemaId] == \"string\")\n            baseId = addRef.call(this, sch[schemaId]);\n        addAnchor.call(this, sch.$anchor);\n        addAnchor.call(this, sch.$dynamicAnchor);\n        baseIds[jsonPtr] = baseId;\n        function addRef(ref) {\n            // eslint-disable-next-line @typescript-eslint/unbound-method\n            const _resolve = this.opts.uriResolver.resolve;\n            ref = normalizeId(baseId ? _resolve(baseId, ref) : ref);\n            if (schemaRefs.has(ref))\n                throw ambiguos(ref);\n            schemaRefs.add(ref);\n            let schOrRef = this.refs[ref];\n            if (typeof schOrRef == \"string\")\n                schOrRef = this.refs[schOrRef];\n            if (typeof schOrRef == \"object\") {\n                checkAmbiguosRef(sch, schOrRef.schema, ref);\n            }\n            else if (ref !== normalizeId(fullPath)) {\n                if (ref[0] === \"#\") {\n                    checkAmbiguosRef(sch, localRefs[ref], ref);\n                    localRefs[ref] = sch;\n                }\n                else {\n                    this.refs[ref] = fullPath;\n                }\n            }\n            return ref;\n        }\n        function addAnchor(anchor) {\n            if (typeof anchor == \"string\") {\n                if (!ANCHOR.test(anchor))\n                    throw new Error(`invalid anchor \"${anchor}\"`);\n                addRef.call(this, `#${anchor}`);\n            }\n        }\n    });\n    return localRefs;\n    function checkAmbiguosRef(sch1, sch2, ref) {\n        if (sch2 !== undefined && !equal(sch1, sch2))\n            throw ambiguos(ref);\n    }\n    function ambiguos(ref) {\n        return new Error(`reference \"${ref}\" resolves to more than one schema`);\n    }\n}\nexports.getSchemaRefs = getSchemaRefs;\n//# sourceMappingURL=resolve.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getRules = exports.isJSONType = void 0;\nconst _jsonTypes = [\"string\", \"number\", \"integer\", \"boolean\", \"null\", \"object\", \"array\"];\nconst jsonTypes = new Set(_jsonTypes);\nfunction isJSONType(x) {\n    return typeof x == \"string\" && jsonTypes.has(x);\n}\nexports.isJSONType = isJSONType;\nfunction getRules() {\n    const groups = {\n        number: { type: \"number\", rules: [] },\n        string: { type: \"string\", rules: [] },\n        array: { type: \"array\", rules: [] },\n        object: { type: \"object\", rules: [] },\n    };\n    return {\n        types: { ...groups, integer: true, boolean: true, null: true },\n        rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],\n        post: { rules: [] },\n        all: {},\n        keywords: {},\n    };\n}\nexports.getRules = getRules;\n//# sourceMappingURL=rules.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst codegen_1 = require(\"./codegen\");\nconst code_1 = require(\"./codegen/code\");\n// TODO refactor to use Set\nfunction toHash(arr) {\n    const hash = {};\n    for (const item of arr)\n        hash[item] = true;\n    return hash;\n}\nexports.toHash = toHash;\nfunction alwaysValidSchema(it, schema) {\n    if (typeof schema == \"boolean\")\n        return schema;\n    if (Object.keys(schema).length === 0)\n        return true;\n    checkUnknownRules(it, schema);\n    return !schemaHasRules(schema, it.self.RULES.all);\n}\nexports.alwaysValidSchema = alwaysValidSchema;\nfunction checkUnknownRules(it, schema = it.schema) {\n    const { opts, self } = it;\n    if (!opts.strictSchema)\n        return;\n    if (typeof schema === \"boolean\")\n        return;\n    const rules = self.RULES.keywords;\n    for (const key in schema) {\n        if (!rules[key])\n            checkStrictMode(it, `unknown keyword: \"${key}\"`);\n    }\n}\nexports.checkUnknownRules = checkUnknownRules;\nfunction schemaHasRules(schema, rules) {\n    if (typeof schema == \"boolean\")\n        return !schema;\n    for (const key in schema)\n        if (rules[key])\n            return true;\n    return false;\n}\nexports.schemaHasRules = schemaHasRules;\nfunction schemaHasRulesButRef(schema, RULES) {\n    if (typeof schema == \"boolean\")\n        return !schema;\n    for (const key in schema)\n        if (key !== \"$ref\" && RULES.all[key])\n            return true;\n    return false;\n}\nexports.schemaHasRulesButRef = schemaHasRulesButRef;\nfunction schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {\n    if (!$data) {\n        if (typeof schema == \"number\" || typeof schema == \"boolean\")\n            return schema;\n        if (typeof schema == \"string\")\n            return (0, codegen_1._) `${schema}`;\n    }\n    return (0, codegen_1._) `${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;\n}\nexports.schemaRefOrVal = schemaRefOrVal;\nfunction unescapeFragment(str) {\n    return unescapeJsonPointer(decodeURIComponent(str));\n}\nexports.unescapeFragment = unescapeFragment;\nfunction escapeFragment(str) {\n    return encodeURIComponent(escapeJsonPointer(str));\n}\nexports.escapeFragment = escapeFragment;\nfunction escapeJsonPointer(str) {\n    if (typeof str == \"number\")\n        return `${str}`;\n    return str.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\n}\nexports.escapeJsonPointer = escapeJsonPointer;\nfunction unescapeJsonPointer(str) {\n    return str.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\n}\nexports.unescapeJsonPointer = unescapeJsonPointer;\nfunction eachItem(xs, f) {\n    if (Array.isArray(xs)) {\n        for (const x of xs)\n            f(x);\n    }\n    else {\n        f(xs);\n    }\n}\nexports.eachItem = eachItem;\nfunction makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName, }) {\n    return (gen, from, to, toName) => {\n        const res = to === undefined\n            ? from\n            : to instanceof codegen_1.Name\n                ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to)\n                : from instanceof codegen_1.Name\n                    ? (mergeToName(gen, to, from), from)\n                    : mergeValues(from, to);\n        return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;\n    };\n}\nexports.mergeEvaluated = {\n    props: makeMergeEvaluated({\n        mergeNames: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true && ${from} !== undefined`, () => {\n            gen.if((0, codegen_1._) `${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._) `${to} || {}`).code((0, codegen_1._) `Object.assign(${to}, ${from})`));\n        }),\n        mergeToName: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true`, () => {\n            if (from === true) {\n                gen.assign(to, true);\n            }\n            else {\n                gen.assign(to, (0, codegen_1._) `${to} || {}`);\n                setEvaluated(gen, to, from);\n            }\n        }),\n        mergeValues: (from, to) => (from === true ? true : { ...from, ...to }),\n        resultToName: evaluatedPropsToName,\n    }),\n    items: makeMergeEvaluated({\n        mergeNames: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._) `${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),\n        mergeToName: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._) `${to} > ${from} ? ${to} : ${from}`)),\n        mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),\n        resultToName: (gen, items) => gen.var(\"items\", items),\n    }),\n};\nfunction evaluatedPropsToName(gen, ps) {\n    if (ps === true)\n        return gen.var(\"props\", true);\n    const props = gen.var(\"props\", (0, codegen_1._) `{}`);\n    if (ps !== undefined)\n        setEvaluated(gen, props, ps);\n    return props;\n}\nexports.evaluatedPropsToName = evaluatedPropsToName;\nfunction setEvaluated(gen, props, ps) {\n    Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._) `${props}${(0, codegen_1.getProperty)(p)}`, true));\n}\nexports.setEvaluated = setEvaluated;\nconst snippets = {};\nfunction useFunc(gen, f) {\n    return gen.scopeValue(\"func\", {\n        ref: f,\n        code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code)),\n    });\n}\nexports.useFunc = useFunc;\nvar Type;\n(function (Type) {\n    Type[Type[\"Num\"] = 0] = \"Num\";\n    Type[Type[\"Str\"] = 1] = \"Str\";\n})(Type = exports.Type || (exports.Type = {}));\nfunction getErrorPath(dataProp, dataPropType, jsPropertySyntax) {\n    // let path\n    if (dataProp instanceof codegen_1.Name) {\n        const isNumber = dataPropType === Type.Num;\n        return jsPropertySyntax\n            ? isNumber\n                ? (0, codegen_1._) `\"[\" + ${dataProp} + \"]\"`\n                : (0, codegen_1._) `\"['\" + ${dataProp} + \"']\"`\n            : isNumber\n                ? (0, codegen_1._) `\"/\" + ${dataProp}`\n                : (0, codegen_1._) `\"/\" + ${dataProp}.replace(/~/g, \"~0\").replace(/\\\\//g, \"~1\")`; // TODO maybe use global escapePointer\n    }\n    return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : \"/\" + escapeJsonPointer(dataProp);\n}\nexports.getErrorPath = getErrorPath;\nfunction checkStrictMode(it, msg, mode = it.opts.strictSchema) {\n    if (!mode)\n        return;\n    msg = `strict mode: ${msg}`;\n    if (mode === true)\n        throw new Error(msg);\n    it.self.logger.warn(msg);\n}\nexports.checkStrictMode = checkStrictMode;\n//# sourceMappingURL=util.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;\nfunction schemaHasRulesForType({ schema, self }, type) {\n    const group = self.RULES.types[type];\n    return group && group !== true && shouldUseGroup(schema, group);\n}\nexports.schemaHasRulesForType = schemaHasRulesForType;\nfunction shouldUseGroup(schema, group) {\n    return group.rules.some((rule) => shouldUseRule(schema, rule));\n}\nexports.shouldUseGroup = shouldUseGroup;\nfunction shouldUseRule(schema, rule) {\n    var _a;\n    return (schema[rule.keyword] !== undefined ||\n        ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined)));\n}\nexports.shouldUseRule = shouldUseRule;\n//# sourceMappingURL=applicability.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;\nconst errors_1 = require(\"../errors\");\nconst codegen_1 = require(\"../codegen\");\nconst names_1 = require(\"../names\");\nconst boolError = {\n    message: \"boolean schema is false\",\n};\nfunction topBoolOrEmptySchema(it) {\n    const { gen, schema, validateName } = it;\n    if (schema === false) {\n        falseSchemaError(it, false);\n    }\n    else if (typeof schema == \"object\" && schema.$async === true) {\n        gen.return(names_1.default.data);\n    }\n    else {\n        gen.assign((0, codegen_1._) `${validateName}.errors`, null);\n        gen.return(true);\n    }\n}\nexports.topBoolOrEmptySchema = topBoolOrEmptySchema;\nfunction boolOrEmptySchema(it, valid) {\n    const { gen, schema } = it;\n    if (schema === false) {\n        gen.var(valid, false); // TODO var\n        falseSchemaError(it);\n    }\n    else {\n        gen.var(valid, true); // TODO var\n    }\n}\nexports.boolOrEmptySchema = boolOrEmptySchema;\nfunction falseSchemaError(it, overrideAllErrors) {\n    const { gen, data } = it;\n    // TODO maybe some other interface should be used for non-keyword validation errors...\n    const cxt = {\n        gen,\n        keyword: \"false schema\",\n        data,\n        schema: false,\n        schemaCode: false,\n        schemaValue: false,\n        params: {},\n        it,\n    };\n    (0, errors_1.reportError)(cxt, boolError, undefined, overrideAllErrors);\n}\n//# sourceMappingURL=boolSchema.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;\nconst rules_1 = require(\"../rules\");\nconst applicability_1 = require(\"./applicability\");\nconst errors_1 = require(\"../errors\");\nconst codegen_1 = require(\"../codegen\");\nconst util_1 = require(\"../util\");\nvar DataType;\n(function (DataType) {\n    DataType[DataType[\"Correct\"] = 0] = \"Correct\";\n    DataType[DataType[\"Wrong\"] = 1] = \"Wrong\";\n})(DataType = exports.DataType || (exports.DataType = {}));\nfunction getSchemaTypes(schema) {\n    const types = getJSONTypes(schema.type);\n    const hasNull = types.includes(\"null\");\n    if (hasNull) {\n        if (schema.nullable === false)\n            throw new Error(\"type: null contradicts nullable: false\");\n    }\n    else {\n        if (!types.length && schema.nullable !== undefined) {\n            throw new Error('\"nullable\" cannot be used without \"type\"');\n        }\n        if (schema.nullable === true)\n            types.push(\"null\");\n    }\n    return types;\n}\nexports.getSchemaTypes = getSchemaTypes;\nfunction getJSONTypes(ts) {\n    const types = Array.isArray(ts) ? ts : ts ? [ts] : [];\n    if (types.every(rules_1.isJSONType))\n        return types;\n    throw new Error(\"type must be JSONType or JSONType[]: \" + types.join(\",\"));\n}\nexports.getJSONTypes = getJSONTypes;\nfunction coerceAndCheckDataType(it, types) {\n    const { gen, data, opts } = it;\n    const coerceTo = coerceToTypes(types, opts.coerceTypes);\n    const checkTypes = types.length > 0 &&\n        !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));\n    if (checkTypes) {\n        const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);\n        gen.if(wrongType, () => {\n            if (coerceTo.length)\n                coerceData(it, types, coerceTo);\n            else\n                reportTypeError(it);\n        });\n    }\n    return checkTypes;\n}\nexports.coerceAndCheckDataType = coerceAndCheckDataType;\nconst COERCIBLE = new Set([\"string\", \"number\", \"integer\", \"boolean\", \"null\"]);\nfunction coerceToTypes(types, coerceTypes) {\n    return coerceTypes\n        ? types.filter((t) => COERCIBLE.has(t) || (coerceTypes === \"array\" && t === \"array\"))\n        : [];\n}\nfunction coerceData(it, types, coerceTo) {\n    const { gen, data, opts } = it;\n    const dataType = gen.let(\"dataType\", (0, codegen_1._) `typeof ${data}`);\n    const coerced = gen.let(\"coerced\", (0, codegen_1._) `undefined`);\n    if (opts.coerceTypes === \"array\") {\n        gen.if((0, codegen_1._) `${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen\n            .assign(data, (0, codegen_1._) `${data}[0]`)\n            .assign(dataType, (0, codegen_1._) `typeof ${data}`)\n            .if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));\n    }\n    gen.if((0, codegen_1._) `${coerced} !== undefined`);\n    for (const t of coerceTo) {\n        if (COERCIBLE.has(t) || (t === \"array\" && opts.coerceTypes === \"array\")) {\n            coerceSpecificType(t);\n        }\n    }\n    gen.else();\n    reportTypeError(it);\n    gen.endIf();\n    gen.if((0, codegen_1._) `${coerced} !== undefined`, () => {\n        gen.assign(data, coerced);\n        assignParentData(it, coerced);\n    });\n    function coerceSpecificType(t) {\n        switch (t) {\n            case \"string\":\n                gen\n                    .elseIf((0, codegen_1._) `${dataType} == \"number\" || ${dataType} == \"boolean\"`)\n                    .assign(coerced, (0, codegen_1._) `\"\" + ${data}`)\n                    .elseIf((0, codegen_1._) `${data} === null`)\n                    .assign(coerced, (0, codegen_1._) `\"\"`);\n                return;\n            case \"number\":\n                gen\n                    .elseIf((0, codegen_1._) `${dataType} == \"boolean\" || ${data} === null\n              || (${dataType} == \"string\" && ${data} && ${data} == +${data})`)\n                    .assign(coerced, (0, codegen_1._) `+${data}`);\n                return;\n            case \"integer\":\n                gen\n                    .elseIf((0, codegen_1._) `${dataType} === \"boolean\" || ${data} === null\n              || (${dataType} === \"string\" && ${data} && ${data} == +${data} && !(${data} % 1))`)\n                    .assign(coerced, (0, codegen_1._) `+${data}`);\n                return;\n            case \"boolean\":\n                gen\n                    .elseIf((0, codegen_1._) `${data} === \"false\" || ${data} === 0 || ${data} === null`)\n                    .assign(coerced, false)\n                    .elseIf((0, codegen_1._) `${data} === \"true\" || ${data} === 1`)\n                    .assign(coerced, true);\n                return;\n            case \"null\":\n                gen.elseIf((0, codegen_1._) `${data} === \"\" || ${data} === 0 || ${data} === false`);\n                gen.assign(coerced, null);\n                return;\n            case \"array\":\n                gen\n                    .elseIf((0, codegen_1._) `${dataType} === \"string\" || ${dataType} === \"number\"\n              || ${dataType} === \"boolean\" || ${data} === null`)\n                    .assign(coerced, (0, codegen_1._) `[${data}]`);\n        }\n    }\n}\nfunction assignParentData({ gen, parentData, parentDataProperty }, expr) {\n    // TODO use gen.property\n    gen.if((0, codegen_1._) `${parentData} !== undefined`, () => gen.assign((0, codegen_1._) `${parentData}[${parentDataProperty}]`, expr));\n}\nfunction checkDataType(dataType, data, strictNums, correct = DataType.Correct) {\n    const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;\n    let cond;\n    switch (dataType) {\n        case \"null\":\n            return (0, codegen_1._) `${data} ${EQ} null`;\n        case \"array\":\n            cond = (0, codegen_1._) `Array.isArray(${data})`;\n            break;\n        case \"object\":\n            cond = (0, codegen_1._) `${data} && typeof ${data} == \"object\" && !Array.isArray(${data})`;\n            break;\n        case \"integer\":\n            cond = numCond((0, codegen_1._) `!(${data} % 1) && !isNaN(${data})`);\n            break;\n        case \"number\":\n            cond = numCond();\n            break;\n        default:\n            return (0, codegen_1._) `typeof ${data} ${EQ} ${dataType}`;\n    }\n    return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);\n    function numCond(_cond = codegen_1.nil) {\n        return (0, codegen_1.and)((0, codegen_1._) `typeof ${data} == \"number\"`, _cond, strictNums ? (0, codegen_1._) `isFinite(${data})` : codegen_1.nil);\n    }\n}\nexports.checkDataType = checkDataType;\nfunction checkDataTypes(dataTypes, data, strictNums, correct) {\n    if (dataTypes.length === 1) {\n        return checkDataType(dataTypes[0], data, strictNums, correct);\n    }\n    let cond;\n    const types = (0, util_1.toHash)(dataTypes);\n    if (types.array && types.object) {\n        const notObj = (0, codegen_1._) `typeof ${data} != \"object\"`;\n        cond = types.null ? notObj : (0, codegen_1._) `!${data} || ${notObj}`;\n        delete types.null;\n        delete types.array;\n        delete types.object;\n    }\n    else {\n        cond = codegen_1.nil;\n    }\n    if (types.number)\n        delete types.integer;\n    for (const t in types)\n        cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));\n    return cond;\n}\nexports.checkDataTypes = checkDataTypes;\nconst typeError = {\n    message: ({ schema }) => `must be ${schema}`,\n    params: ({ schema, schemaValue }) => typeof schema == \"string\" ? (0, codegen_1._) `{type: ${schema}}` : (0, codegen_1._) `{type: ${schemaValue}}`,\n};\nfunction reportTypeError(it) {\n    const cxt = getTypeErrorContext(it);\n    (0, errors_1.reportError)(cxt, typeError);\n}\nexports.reportTypeError = reportTypeError;\nfunction getTypeErrorContext(it) {\n    const { gen, data, schema } = it;\n    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, \"type\");\n    return {\n        gen,\n        keyword: \"type\",\n        data,\n        schema: schema.type,\n        schemaCode,\n        schemaValue: schemaCode,\n        parentSchema: schema,\n        params: {},\n        it,\n    };\n}\n//# sourceMappingURL=dataType.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assignDefaults = void 0;\nconst codegen_1 = require(\"../codegen\");\nconst util_1 = require(\"../util\");\nfunction assignDefaults(it, ty) {\n    const { properties, items } = it.schema;\n    if (ty === \"object\" && properties) {\n        for (const key in properties) {\n            assignDefault(it, key, properties[key].default);\n        }\n    }\n    else if (ty === \"array\" && Array.isArray(items)) {\n        items.forEach((sch, i) => assignDefault(it, i, sch.default));\n    }\n}\nexports.assignDefaults = assignDefaults;\nfunction assignDefault(it, prop, defaultValue) {\n    const { gen, compositeRule, data, opts } = it;\n    if (defaultValue === undefined)\n        return;\n    const childData = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(prop)}`;\n    if (compositeRule) {\n        (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);\n        return;\n    }\n    let condition = (0, codegen_1._) `${childData} === undefined`;\n    if (opts.useDefaults === \"empty\") {\n        condition = (0, codegen_1._) `${condition} || ${childData} === null || ${childData} === \"\"`;\n    }\n    // `${childData} === undefined` +\n    // (opts.useDefaults === \"empty\" ? ` || ${childData} === null || ${childData} === \"\"` : \"\")\n    gen.if(condition, (0, codegen_1._) `${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);\n}\n//# sourceMappingURL=defaults.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;\nconst boolSchema_1 = require(\"./boolSchema\");\nconst dataType_1 = require(\"./dataType\");\nconst applicability_1 = require(\"./applicability\");\nconst dataType_2 = require(\"./dataType\");\nconst defaults_1 = require(\"./defaults\");\nconst keyword_1 = require(\"./keyword\");\nconst subschema_1 = require(\"./subschema\");\nconst codegen_1 = require(\"../codegen\");\nconst names_1 = require(\"../names\");\nconst resolve_1 = require(\"../resolve\");\nconst util_1 = require(\"../util\");\nconst errors_1 = require(\"../errors\");\n// schema compilation - generates validation function, subschemaCode (below) is used for subschemas\nfunction validateFunctionCode(it) {\n    if (isSchemaObj(it)) {\n        checkKeywords(it);\n        if (schemaCxtHasRules(it)) {\n            topSchemaObjCode(it);\n            return;\n        }\n    }\n    validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));\n}\nexports.validateFunctionCode = validateFunctionCode;\nfunction validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {\n    if (opts.code.es5) {\n        gen.func(validateName, (0, codegen_1._) `${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {\n            gen.code((0, codegen_1._) `\"use strict\"; ${funcSourceUrl(schema, opts)}`);\n            destructureValCxtES5(gen, opts);\n            gen.code(body);\n        });\n    }\n    else {\n        gen.func(validateName, (0, codegen_1._) `${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));\n    }\n}\nfunction destructureValCxt(opts) {\n    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}}={}`;\n}\nfunction destructureValCxtES5(gen, opts) {\n    gen.if(names_1.default.valCxt, () => {\n        gen.var(names_1.default.instancePath, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.instancePath}`);\n        gen.var(names_1.default.parentData, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.parentData}`);\n        gen.var(names_1.default.parentDataProperty, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);\n        gen.var(names_1.default.rootData, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.rootData}`);\n        if (opts.dynamicRef)\n            gen.var(names_1.default.dynamicAnchors, (0, codegen_1._) `${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);\n    }, () => {\n        gen.var(names_1.default.instancePath, (0, codegen_1._) `\"\"`);\n        gen.var(names_1.default.parentData, (0, codegen_1._) `undefined`);\n        gen.var(names_1.default.parentDataProperty, (0, codegen_1._) `undefined`);\n        gen.var(names_1.default.rootData, names_1.default.data);\n        if (opts.dynamicRef)\n            gen.var(names_1.default.dynamicAnchors, (0, codegen_1._) `{}`);\n    });\n}\nfunction topSchemaObjCode(it) {\n    const { schema, opts, gen } = it;\n    validateFunction(it, () => {\n        if (opts.$comment && schema.$comment)\n            commentKeyword(it);\n        checkNoDefault(it);\n        gen.let(names_1.default.vErrors, null);\n        gen.let(names_1.default.errors, 0);\n        if (opts.unevaluated)\n            resetEvaluated(it);\n        typeAndKeywords(it);\n        returnResults(it);\n    });\n    return;\n}\nfunction resetEvaluated(it) {\n    // TODO maybe some hook to execute it in the end to check whether props/items are Name, as in assignEvaluated\n    const { gen, validateName } = it;\n    it.evaluated = gen.const(\"evaluated\", (0, codegen_1._) `${validateName}.evaluated`);\n    gen.if((0, codegen_1._) `${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._) `${it.evaluated}.props`, (0, codegen_1._) `undefined`));\n    gen.if((0, codegen_1._) `${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._) `${it.evaluated}.items`, (0, codegen_1._) `undefined`));\n}\nfunction funcSourceUrl(schema, opts) {\n    const schId = typeof schema == \"object\" && schema[opts.schemaId];\n    return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._) `/*# sourceURL=${schId} */` : codegen_1.nil;\n}\n// schema compilation - this function is used recursively to generate code for sub-schemas\nfunction subschemaCode(it, valid) {\n    if (isSchemaObj(it)) {\n        checkKeywords(it);\n        if (schemaCxtHasRules(it)) {\n            subSchemaObjCode(it, valid);\n            return;\n        }\n    }\n    (0, boolSchema_1.boolOrEmptySchema)(it, valid);\n}\nfunction schemaCxtHasRules({ schema, self }) {\n    if (typeof schema == \"boolean\")\n        return !schema;\n    for (const key in schema)\n        if (self.RULES.all[key])\n            return true;\n    return false;\n}\nfunction isSchemaObj(it) {\n    return typeof it.schema != \"boolean\";\n}\nfunction subSchemaObjCode(it, valid) {\n    const { schema, gen, opts } = it;\n    if (opts.$comment && schema.$comment)\n        commentKeyword(it);\n    updateContext(it);\n    checkAsyncSchema(it);\n    const errsCount = gen.const(\"_errs\", names_1.default.errors);\n    typeAndKeywords(it, errsCount);\n    // TODO var\n    gen.var(valid, (0, codegen_1._) `${errsCount} === ${names_1.default.errors}`);\n}\nfunction checkKeywords(it) {\n    (0, util_1.checkUnknownRules)(it);\n    checkRefsAndKeywords(it);\n}\nfunction typeAndKeywords(it, errsCount) {\n    if (it.opts.jtd)\n        return schemaKeywords(it, [], false, errsCount);\n    const types = (0, dataType_1.getSchemaTypes)(it.schema);\n    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);\n    schemaKeywords(it, types, !checkedTypes, errsCount);\n}\nfunction checkRefsAndKeywords(it) {\n    const { schema, errSchemaPath, opts, self } = it;\n    if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) {\n        self.logger.warn(`$ref: keywords ignored in schema at path \"${errSchemaPath}\"`);\n    }\n}\nfunction checkNoDefault(it) {\n    const { schema, opts } = it;\n    if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) {\n        (0, util_1.checkStrictMode)(it, \"default is ignored in the schema root\");\n    }\n}\nfunction updateContext(it) {\n    const schId = it.schema[it.opts.schemaId];\n    if (schId)\n        it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);\n}\nfunction checkAsyncSchema(it) {\n    if (it.schema.$async && !it.schemaEnv.$async)\n        throw new Error(\"async schema in sync schema\");\n}\nfunction commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {\n    const msg = schema.$comment;\n    if (opts.$comment === true) {\n        gen.code((0, codegen_1._) `${names_1.default.self}.logger.log(${msg})`);\n    }\n    else if (typeof opts.$comment == \"function\") {\n        const schemaPath = (0, codegen_1.str) `${errSchemaPath}/$comment`;\n        const rootName = gen.scopeValue(\"root\", { ref: schemaEnv.root });\n        gen.code((0, codegen_1._) `${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);\n    }\n}\nfunction returnResults(it) {\n    const { gen, schemaEnv, validateName, ValidationError, opts } = it;\n    if (schemaEnv.$async) {\n        // TODO assign unevaluated\n        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})`));\n    }\n    else {\n        gen.assign((0, codegen_1._) `${validateName}.errors`, names_1.default.vErrors);\n        if (opts.unevaluated)\n            assignEvaluated(it);\n        gen.return((0, codegen_1._) `${names_1.default.errors} === 0`);\n    }\n}\nfunction assignEvaluated({ gen, evaluated, props, items }) {\n    if (props instanceof codegen_1.Name)\n        gen.assign((0, codegen_1._) `${evaluated}.props`, props);\n    if (items instanceof codegen_1.Name)\n        gen.assign((0, codegen_1._) `${evaluated}.items`, items);\n}\nfunction schemaKeywords(it, types, typeErrors, errsCount) {\n    const { gen, schema, data, allErrors, opts, self } = it;\n    const { RULES } = self;\n    if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {\n        gen.block(() => keywordCode(it, \"$ref\", RULES.all.$ref.definition)); // TODO typecast\n        return;\n    }\n    if (!opts.jtd)\n        checkStrictTypes(it, types);\n    gen.block(() => {\n        for (const group of RULES.rules)\n            groupKeywords(group);\n        groupKeywords(RULES.post);\n    });\n    function groupKeywords(group) {\n        if (!(0, applicability_1.shouldUseGroup)(schema, group))\n            return;\n        if (group.type) {\n            gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));\n            iterateKeywords(it, group);\n            if (types.length === 1 && types[0] === group.type && typeErrors) {\n                gen.else();\n                (0, dataType_2.reportTypeError)(it);\n            }\n            gen.endIf();\n        }\n        else {\n            iterateKeywords(it, group);\n        }\n        // TODO make it \"ok\" call?\n        if (!allErrors)\n            gen.if((0, codegen_1._) `${names_1.default.errors} === ${errsCount || 0}`);\n    }\n}\nfunction iterateKeywords(it, group) {\n    const { gen, schema, opts: { useDefaults }, } = it;\n    if (useDefaults)\n        (0, defaults_1.assignDefaults)(it, group.type);\n    gen.block(() => {\n        for (const rule of group.rules) {\n            if ((0, applicability_1.shouldUseRule)(schema, rule)) {\n                keywordCode(it, rule.keyword, rule.definition, group.type);\n            }\n        }\n    });\n}\nfunction checkStrictTypes(it, types) {\n    if (it.schemaEnv.meta || !it.opts.strictTypes)\n        return;\n    checkContextTypes(it, types);\n    if (!it.opts.allowUnionTypes)\n        checkMultipleTypes(it, types);\n    checkKeywordTypes(it, it.dataTypes);\n}\nfunction checkContextTypes(it, types) {\n    if (!types.length)\n        return;\n    if (!it.dataTypes.length) {\n        it.dataTypes = types;\n        return;\n    }\n    types.forEach((t) => {\n        if (!includesType(it.dataTypes, t)) {\n            strictTypesError(it, `type \"${t}\" not allowed by context \"${it.dataTypes.join(\",\")}\"`);\n        }\n    });\n    it.dataTypes = it.dataTypes.filter((t) => includesType(types, t));\n}\nfunction checkMultipleTypes(it, ts) {\n    if (ts.length > 1 && !(ts.length === 2 && ts.includes(\"null\"))) {\n        strictTypesError(it, \"use allowUnionTypes to allow union type keyword\");\n    }\n}\nfunction checkKeywordTypes(it, ts) {\n    const rules = it.self.RULES.all;\n    for (const keyword in rules) {\n        const rule = rules[keyword];\n        if (typeof rule == \"object\" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {\n            const { type } = rule.definition;\n            if (type.length && !type.some((t) => hasApplicableType(ts, t))) {\n                strictTypesError(it, `missing type \"${type.join(\",\")}\" for keyword \"${keyword}\"`);\n            }\n        }\n    }\n}\nfunction hasApplicableType(schTs, kwdT) {\n    return schTs.includes(kwdT) || (kwdT === \"number\" && schTs.includes(\"integer\"));\n}\nfunction includesType(ts, t) {\n    return ts.includes(t) || (t === \"integer\" && ts.includes(\"number\"));\n}\nfunction strictTypesError(it, msg) {\n    const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;\n    msg += ` at \"${schemaPath}\" (strictTypes)`;\n    (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);\n}\nclass KeywordCxt {\n    constructor(it, def, keyword) {\n        (0, keyword_1.validateKeywordUsage)(it, def, keyword);\n        this.gen = it.gen;\n        this.allErrors = it.allErrors;\n        this.keyword = keyword;\n        this.data = it.data;\n        this.schema = it.schema[keyword];\n        this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;\n        this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);\n        this.schemaType = def.schemaType;\n        this.parentSchema = it.schema;\n        this.params = {};\n        this.it = it;\n        this.def = def;\n        if (this.$data) {\n            this.schemaCode = it.gen.const(\"vSchema\", getData(this.$data, it));\n        }\n        else {\n            this.schemaCode = this.schemaValue;\n            if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) {\n                throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);\n            }\n        }\n        if (\"code\" in def ? def.trackErrors : def.errors !== false) {\n            this.errsCount = it.gen.const(\"_errs\", names_1.default.errors);\n        }\n    }\n    result(condition, successAction, failAction) {\n        this.failResult((0, codegen_1.not)(condition), successAction, failAction);\n    }\n    failResult(condition, successAction, failAction) {\n        this.gen.if(condition);\n        if (failAction)\n            failAction();\n        else\n            this.error();\n        if (successAction) {\n            this.gen.else();\n            successAction();\n            if (this.allErrors)\n                this.gen.endIf();\n        }\n        else {\n            if (this.allErrors)\n                this.gen.endIf();\n            else\n                this.gen.else();\n        }\n    }\n    pass(condition, failAction) {\n        this.failResult((0, codegen_1.not)(condition), undefined, failAction);\n    }\n    fail(condition) {\n        if (condition === undefined) {\n            this.error();\n            if (!this.allErrors)\n                this.gen.if(false); // this branch will be removed by gen.optimize\n            return;\n        }\n        this.gen.if(condition);\n        this.error();\n        if (this.allErrors)\n            this.gen.endIf();\n        else\n            this.gen.else();\n    }\n    fail$data(condition) {\n        if (!this.$data)\n            return this.fail(condition);\n        const { schemaCode } = this;\n        this.fail((0, codegen_1._) `${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);\n    }\n    error(append, errorParams, errorPaths) {\n        if (errorParams) {\n            this.setParams(errorParams);\n            this._error(append, errorPaths);\n            this.setParams({});\n            return;\n        }\n        this._error(append, errorPaths);\n    }\n    _error(append, errorPaths) {\n        ;\n        (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);\n    }\n    $dataError() {\n        (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);\n    }\n    reset() {\n        if (this.errsCount === undefined)\n            throw new Error('add \"trackErrors\" to keyword definition');\n        (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);\n    }\n    ok(cond) {\n        if (!this.allErrors)\n            this.gen.if(cond);\n    }\n    setParams(obj, assign) {\n        if (assign)\n            Object.assign(this.params, obj);\n        else\n            this.params = obj;\n    }\n    block$data(valid, codeBlock, $dataValid = codegen_1.nil) {\n        this.gen.block(() => {\n            this.check$data(valid, $dataValid);\n            codeBlock();\n        });\n    }\n    check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {\n        if (!this.$data)\n            return;\n        const { gen, schemaCode, schemaType, def } = this;\n        gen.if((0, codegen_1.or)((0, codegen_1._) `${schemaCode} === undefined`, $dataValid));\n        if (valid !== codegen_1.nil)\n            gen.assign(valid, true);\n        if (schemaType.length || def.validateSchema) {\n            gen.elseIf(this.invalid$data());\n            this.$dataError();\n            if (valid !== codegen_1.nil)\n                gen.assign(valid, false);\n        }\n        gen.else();\n    }\n    invalid$data() {\n        const { gen, schemaCode, schemaType, def, it } = this;\n        return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());\n        function wrong$DataType() {\n            if (schemaType.length) {\n                /* istanbul ignore if */\n                if (!(schemaCode instanceof codegen_1.Name))\n                    throw new Error(\"ajv implementation error\");\n                const st = Array.isArray(schemaType) ? schemaType : [schemaType];\n                return (0, codegen_1._) `${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;\n            }\n            return codegen_1.nil;\n        }\n        function invalid$DataSchema() {\n            if (def.validateSchema) {\n                const validateSchemaRef = gen.scopeValue(\"validate$data\", { ref: def.validateSchema }); // TODO value.code for standalone\n                return (0, codegen_1._) `!${validateSchemaRef}(${schemaCode})`;\n            }\n            return codegen_1.nil;\n        }\n    }\n    subschema(appl, valid) {\n        const subschema = (0, subschema_1.getSubschema)(this.it, appl);\n        (0, subschema_1.extendSubschemaData)(subschema, this.it, appl);\n        (0, subschema_1.extendSubschemaMode)(subschema, appl);\n        const nextContext = { ...this.it, ...subschema, items: undefined, props: undefined };\n        subschemaCode(nextContext, valid);\n        return nextContext;\n    }\n    mergeEvaluated(schemaCxt, toName) {\n        const { it, gen } = this;\n        if (!it.opts.unevaluated)\n            return;\n        if (it.props !== true && schemaCxt.props !== undefined) {\n            it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);\n        }\n        if (it.items !== true && schemaCxt.items !== undefined) {\n            it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);\n        }\n    }\n    mergeValidEvaluated(schemaCxt, valid) {\n        const { it, gen } = this;\n        if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {\n            gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));\n            return true;\n        }\n    }\n}\nexports.KeywordCxt = KeywordCxt;\nfunction keywordCode(it, keyword, def, ruleType) {\n    const cxt = new KeywordCxt(it, def, keyword);\n    if (\"code\" in def) {\n        def.code(cxt, ruleType);\n    }\n    else if (cxt.$data && def.validate) {\n        (0, keyword_1.funcKeywordCode)(cxt, def);\n    }\n    else if (\"macro\" in def) {\n        (0, keyword_1.macroKeywordCode)(cxt, def);\n    }\n    else if (def.compile || def.validate) {\n        (0, keyword_1.funcKeywordCode)(cxt, def);\n    }\n}\nconst JSON_POINTER = /^\\/(?:[^~]|~0|~1)*$/;\nconst RELATIVE_JSON_POINTER = /^([0-9]+)(#|\\/(?:[^~]|~0|~1)*)?$/;\nfunction getData($data, { dataLevel, dataNames, dataPathArr }) {\n    let jsonPointer;\n    let data;\n    if ($data === \"\")\n        return names_1.default.rootData;\n    if ($data[0] === \"/\") {\n        if (!JSON_POINTER.test($data))\n            throw new Error(`Invalid JSON-pointer: ${$data}`);\n        jsonPointer = $data;\n        data = names_1.default.rootData;\n    }\n    else {\n        const matches = RELATIVE_JSON_POINTER.exec($data);\n        if (!matches)\n            throw new Error(`Invalid JSON-pointer: ${$data}`);\n        const up = +matches[1];\n        jsonPointer = matches[2];\n        if (jsonPointer === \"#\") {\n            if (up >= dataLevel)\n                throw new Error(errorMsg(\"property/index\", up));\n            return dataPathArr[dataLevel - up];\n        }\n        if (up > dataLevel)\n            throw new Error(errorMsg(\"data\", up));\n        data = dataNames[dataLevel - up];\n        if (!jsonPointer)\n            return data;\n    }\n    let expr = data;\n    const segments = jsonPointer.split(\"/\");\n    for (const segment of segments) {\n        if (segment) {\n            data = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;\n            expr = (0, codegen_1._) `${expr} && ${data}`;\n        }\n    }\n    return expr;\n    function errorMsg(pointerType, up) {\n        return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;\n    }\n}\nexports.getData = getData;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;\nconst codegen_1 = require(\"../codegen\");\nconst names_1 = require(\"../names\");\nconst code_1 = require(\"../../vocabularies/code\");\nconst errors_1 = require(\"../errors\");\nfunction macroKeywordCode(cxt, def) {\n    const { gen, keyword, schema, parentSchema, it } = cxt;\n    const macroSchema = def.macro.call(it.self, schema, parentSchema, it);\n    const schemaRef = useKeyword(gen, keyword, macroSchema);\n    if (it.opts.validateSchema !== false)\n        it.self.validateSchema(macroSchema, true);\n    const valid = gen.name(\"valid\");\n    cxt.subschema({\n        schema: macroSchema,\n        schemaPath: codegen_1.nil,\n        errSchemaPath: `${it.errSchemaPath}/${keyword}`,\n        topSchemaRef: schemaRef,\n        compositeRule: true,\n    }, valid);\n    cxt.pass(valid, () => cxt.error(true));\n}\nexports.macroKeywordCode = macroKeywordCode;\nfunction funcKeywordCode(cxt, def) {\n    var _a;\n    const { gen, keyword, schema, parentSchema, $data, it } = cxt;\n    checkAsyncKeyword(it, def);\n    const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;\n    const validateRef = useKeyword(gen, keyword, validate);\n    const valid = gen.let(\"valid\");\n    cxt.block$data(valid, validateKeyword);\n    cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);\n    function validateKeyword() {\n        if (def.errors === false) {\n            assignValid();\n            if (def.modifying)\n                modifyData(cxt);\n            reportErrs(() => cxt.error());\n        }\n        else {\n            const ruleErrs = def.async ? validateAsync() : validateSync();\n            if (def.modifying)\n                modifyData(cxt);\n            reportErrs(() => addErrs(cxt, ruleErrs));\n        }\n    }\n    function validateAsync() {\n        const ruleErrs = gen.let(\"ruleErrs\", null);\n        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)));\n        return ruleErrs;\n    }\n    function validateSync() {\n        const validateErrs = (0, codegen_1._) `${validateRef}.errors`;\n        gen.assign(validateErrs, null);\n        assignValid(codegen_1.nil);\n        return validateErrs;\n    }\n    function assignValid(_await = def.async ? (0, codegen_1._) `await ` : codegen_1.nil) {\n        const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;\n        const passSchema = !((\"compile\" in def && !$data) || def.schema === false);\n        gen.assign(valid, (0, codegen_1._) `${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);\n    }\n    function reportErrs(errors) {\n        var _a;\n        gen.if((0, codegen_1.not)((_a = def.valid) !== null && _a !== void 0 ? _a : valid), errors);\n    }\n}\nexports.funcKeywordCode = funcKeywordCode;\nfunction modifyData(cxt) {\n    const { gen, data, it } = cxt;\n    gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._) `${it.parentData}[${it.parentDataProperty}]`));\n}\nfunction addErrs(cxt, errs) {\n    const { gen } = cxt;\n    gen.if((0, codegen_1._) `Array.isArray(${errs})`, () => {\n        gen\n            .assign(names_1.default.vErrors, (0, codegen_1._) `${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`)\n            .assign(names_1.default.errors, (0, codegen_1._) `${names_1.default.vErrors}.length`);\n        (0, errors_1.extendErrors)(cxt);\n    }, () => cxt.error());\n}\nfunction checkAsyncKeyword({ schemaEnv }, def) {\n    if (def.async && !schemaEnv.$async)\n        throw new Error(\"async keyword in sync schema\");\n}\nfunction useKeyword(gen, keyword, result) {\n    if (result === undefined)\n        throw new Error(`keyword \"${keyword}\" failed to compile`);\n    return gen.scopeValue(\"keyword\", typeof result == \"function\" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });\n}\nfunction validSchemaType(schema, schemaType, allowUndefined = false) {\n    // TODO add tests\n    return (!schemaType.length ||\n        schemaType.some((st) => st === \"array\"\n            ? Array.isArray(schema)\n            : st === \"object\"\n                ? schema && typeof schema == \"object\" && !Array.isArray(schema)\n                : typeof schema == st || (allowUndefined && typeof schema == \"undefined\")));\n}\nexports.validSchemaType = validSchemaType;\nfunction validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {\n    /* istanbul ignore if */\n    if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {\n        throw new Error(\"ajv implementation error\");\n    }\n    const deps = def.dependencies;\n    if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {\n        throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(\",\")}`);\n    }\n    if (def.validateSchema) {\n        const valid = def.validateSchema(schema[keyword]);\n        if (!valid) {\n            const msg = `keyword \"${keyword}\" value is invalid at path \"${errSchemaPath}\": ` +\n                self.errorsText(def.validateSchema.errors);\n            if (opts.validateSchema === \"log\")\n                self.logger.error(msg);\n            else\n                throw new Error(msg);\n        }\n    }\n}\nexports.validateKeywordUsage = validateKeywordUsage;\n//# sourceMappingURL=keyword.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;\nconst codegen_1 = require(\"../codegen\");\nconst util_1 = require(\"../util\");\nfunction getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {\n    if (keyword !== undefined && schema !== undefined) {\n        throw new Error('both \"keyword\" and \"schema\" passed, only one allowed');\n    }\n    if (keyword !== undefined) {\n        const sch = it.schema[keyword];\n        return schemaProp === undefined\n            ? {\n                schema: sch,\n                schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,\n                errSchemaPath: `${it.errSchemaPath}/${keyword}`,\n            }\n            : {\n                schema: sch[schemaProp],\n                schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,\n                errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,\n            };\n    }\n    if (schema !== undefined) {\n        if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {\n            throw new Error('\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"');\n        }\n        return {\n            schema,\n            schemaPath,\n            topSchemaRef,\n            errSchemaPath,\n        };\n    }\n    throw new Error('either \"keyword\" or \"schema\" must be passed');\n}\nexports.getSubschema = getSubschema;\nfunction extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {\n    if (data !== undefined && dataProp !== undefined) {\n        throw new Error('both \"data\" and \"dataProp\" passed, only one allowed');\n    }\n    const { gen } = it;\n    if (dataProp !== undefined) {\n        const { errorPath, dataPathArr, opts } = it;\n        const nextData = gen.let(\"data\", (0, codegen_1._) `${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);\n        dataContextProps(nextData);\n        subschema.errorPath = (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;\n        subschema.parentDataProperty = (0, codegen_1._) `${dataProp}`;\n        subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];\n    }\n    if (data !== undefined) {\n        const nextData = data instanceof codegen_1.Name ? data : gen.let(\"data\", data, true); // replaceable if used once?\n        dataContextProps(nextData);\n        if (propertyName !== undefined)\n            subschema.propertyName = propertyName;\n        // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr\n    }\n    if (dataTypes)\n        subschema.dataTypes = dataTypes;\n    function dataContextProps(_nextData) {\n        subschema.data = _nextData;\n        subschema.dataLevel = it.dataLevel + 1;\n        subschema.dataTypes = [];\n        it.definedProperties = new Set();\n        subschema.parentData = it.data;\n        subschema.dataNames = [...it.dataNames, _nextData];\n    }\n}\nexports.extendSubschemaData = extendSubschemaData;\nfunction extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {\n    if (compositeRule !== undefined)\n        subschema.compositeRule = compositeRule;\n    if (createErrors !== undefined)\n        subschema.createErrors = createErrors;\n    if (allErrors !== undefined)\n        subschema.allErrors = allErrors;\n    subschema.jtdDiscriminator = jtdDiscriminator; // not inherited\n    subschema.jtdMetadata = jtdMetadata; // not inherited\n}\nexports.extendSubschemaMode = extendSubschemaMode;\n//# sourceMappingURL=subschema.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;\nvar validate_1 = require(\"./compile/validate\");\nObject.defineProperty(exports, \"KeywordCxt\", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });\nvar codegen_1 = require(\"./compile/codegen\");\nObject.defineProperty(exports, \"_\", { enumerable: true, get: function () { return codegen_1._; } });\nObject.defineProperty(exports, \"str\", { enumerable: true, get: function () { return codegen_1.str; } });\nObject.defineProperty(exports, \"stringify\", { enumerable: true, get: function () { return codegen_1.stringify; } });\nObject.defineProperty(exports, \"nil\", { enumerable: true, get: function () { return codegen_1.nil; } });\nObject.defineProperty(exports, \"Name\", { enumerable: true, get: function () { return codegen_1.Name; } });\nObject.defineProperty(exports, \"CodeGen\", { enumerable: true, get: function () { return codegen_1.CodeGen; } });\nconst validation_error_1 = require(\"./runtime/validation_error\");\nconst ref_error_1 = require(\"./compile/ref_error\");\nconst rules_1 = require(\"./compile/rules\");\nconst compile_1 = require(\"./compile\");\nconst codegen_2 = require(\"./compile/codegen\");\nconst resolve_1 = require(\"./compile/resolve\");\nconst dataType_1 = require(\"./compile/validate/dataType\");\nconst util_1 = require(\"./compile/util\");\nconst $dataRefSchema = require(\"./refs/data.json\");\nconst uri_1 = require(\"./runtime/uri\");\nconst defaultRegExp = (str, flags) => new RegExp(str, flags);\ndefaultRegExp.code = \"new RegExp\";\nconst META_IGNORE_OPTIONS = [\"removeAdditional\", \"useDefaults\", \"coerceTypes\"];\nconst EXT_SCOPE_NAMES = new Set([\n    \"validate\",\n    \"serialize\",\n    \"parse\",\n    \"wrapper\",\n    \"root\",\n    \"schema\",\n    \"keyword\",\n    \"pattern\",\n    \"formats\",\n    \"validate$data\",\n    \"func\",\n    \"obj\",\n    \"Error\",\n]);\nconst removedOptions = {\n    errorDataPath: \"\",\n    format: \"`validateFormats: false` can be used instead.\",\n    nullable: '\"nullable\" keyword is supported by default.',\n    jsonPointers: \"Deprecated jsPropertySyntax can be used instead.\",\n    extendRefs: \"Deprecated ignoreKeywordsWithRef can be used instead.\",\n    missingRefs: \"Pass empty schema with $id that should be ignored to ajv.addSchema.\",\n    processCode: \"Use option `code: {process: (code, schemaEnv: object) => string}`\",\n    sourceCode: \"Use option `code: {source: true}`\",\n    strictDefaults: \"It is default now, see option `strict`.\",\n    strictKeywords: \"It is default now, see option `strict`.\",\n    uniqueItems: '\"uniqueItems\" keyword is always validated.',\n    unknownFormats: \"Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).\",\n    cache: \"Map is used as cache, schema object as key.\",\n    serialize: \"Map is used as cache, schema object as key.\",\n    ajvErrors: \"It is default now.\",\n};\nconst deprecatedOptions = {\n    ignoreKeywordsWithRef: \"\",\n    jsPropertySyntax: \"\",\n    unicode: '\"minLength\"/\"maxLength\" account for unicode characters by default.',\n};\nconst MAX_EXPRESSION = 200;\n// eslint-disable-next-line complexity\nfunction requiredOptions(o) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;\n    const s = o.strict;\n    const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;\n    const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0;\n    const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;\n    const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;\n    return {\n        strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,\n        strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,\n        strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : \"log\",\n        strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : \"log\",\n        strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,\n        code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },\n        loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,\n        loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,\n        meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,\n        messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,\n        inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,\n        schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : \"$id\",\n        addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,\n        validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,\n        validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,\n        unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,\n        int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,\n        uriResolver: uriResolver,\n    };\n}\nclass Ajv {\n    constructor(opts = {}) {\n        this.schemas = {};\n        this.refs = {};\n        this.formats = {};\n        this._compilations = new Set();\n        this._loading = {};\n        this._cache = new Map();\n        opts = this.opts = { ...opts, ...requiredOptions(opts) };\n        const { es5, lines } = this.opts.code;\n        this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });\n        this.logger = getLogger(opts.logger);\n        const formatOpt = opts.validateFormats;\n        opts.validateFormats = false;\n        this.RULES = (0, rules_1.getRules)();\n        checkOptions.call(this, removedOptions, opts, \"NOT SUPPORTED\");\n        checkOptions.call(this, deprecatedOptions, opts, \"DEPRECATED\", \"warn\");\n        this._metaOpts = getMetaSchemaOptions.call(this);\n        if (opts.formats)\n            addInitialFormats.call(this);\n        this._addVocabularies();\n        this._addDefaultMetaSchema();\n        if (opts.keywords)\n            addInitialKeywords.call(this, opts.keywords);\n        if (typeof opts.meta == \"object\")\n            this.addMetaSchema(opts.meta);\n        addInitialSchemas.call(this);\n        opts.validateFormats = formatOpt;\n    }\n    _addVocabularies() {\n        this.addKeyword(\"$async\");\n    }\n    _addDefaultMetaSchema() {\n        const { $data, meta, schemaId } = this.opts;\n        let _dataRefSchema = $dataRefSchema;\n        if (schemaId === \"id\") {\n            _dataRefSchema = { ...$dataRefSchema };\n            _dataRefSchema.id = _dataRefSchema.$id;\n            delete _dataRefSchema.$id;\n        }\n        if (meta && $data)\n            this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);\n    }\n    defaultMeta() {\n        const { meta, schemaId } = this.opts;\n        return (this.opts.defaultMeta = typeof meta == \"object\" ? meta[schemaId] || meta : undefined);\n    }\n    validate(schemaKeyRef, // key, ref or schema object\n    data // to be validated\n    ) {\n        let v;\n        if (typeof schemaKeyRef == \"string\") {\n            v = this.getSchema(schemaKeyRef);\n            if (!v)\n                throw new Error(`no schema with key or ref \"${schemaKeyRef}\"`);\n        }\n        else {\n            v = this.compile(schemaKeyRef);\n        }\n        const valid = v(data);\n        if (!(\"$async\" in v))\n            this.errors = v.errors;\n        return valid;\n    }\n    compile(schema, _meta) {\n        const sch = this._addSchema(schema, _meta);\n        return (sch.validate || this._compileSchemaEnv(sch));\n    }\n    compileAsync(schema, meta) {\n        if (typeof this.opts.loadSchema != \"function\") {\n            throw new Error(\"options.loadSchema should be a function\");\n        }\n        const { loadSchema } = this.opts;\n        return runCompileAsync.call(this, schema, meta);\n        async function runCompileAsync(_schema, _meta) {\n            await loadMetaSchema.call(this, _schema.$schema);\n            const sch = this._addSchema(_schema, _meta);\n            return sch.validate || _compileAsync.call(this, sch);\n        }\n        async function loadMetaSchema($ref) {\n            if ($ref && !this.getSchema($ref)) {\n                await runCompileAsync.call(this, { $ref }, true);\n            }\n        }\n        async function _compileAsync(sch) {\n            try {\n                return this._compileSchemaEnv(sch);\n            }\n            catch (e) {\n                if (!(e instanceof ref_error_1.default))\n                    throw e;\n                checkLoaded.call(this, e);\n                await loadMissingSchema.call(this, e.missingSchema);\n                return _compileAsync.call(this, sch);\n            }\n        }\n        function checkLoaded({ missingSchema: ref, missingRef }) {\n            if (this.refs[ref]) {\n                throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);\n            }\n        }\n        async function loadMissingSchema(ref) {\n            const _schema = await _loadSchema.call(this, ref);\n            if (!this.refs[ref])\n                await loadMetaSchema.call(this, _schema.$schema);\n            if (!this.refs[ref])\n                this.addSchema(_schema, ref, meta);\n        }\n        async function _loadSchema(ref) {\n            const p = this._loading[ref];\n            if (p)\n                return p;\n            try {\n                return await (this._loading[ref] = loadSchema(ref));\n            }\n            finally {\n                delete this._loading[ref];\n            }\n        }\n    }\n    // Adds schema to the instance\n    addSchema(schema, // If array is passed, `key` will be ignored\n    key, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.\n    _meta, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.\n    _validateSchema = this.opts.validateSchema // false to skip schema validation. Used internally, option validateSchema should be used instead.\n    ) {\n        if (Array.isArray(schema)) {\n            for (const sch of schema)\n                this.addSchema(sch, undefined, _meta, _validateSchema);\n            return this;\n        }\n        let id;\n        if (typeof schema === \"object\") {\n            const { schemaId } = this.opts;\n            id = schema[schemaId];\n            if (id !== undefined && typeof id != \"string\") {\n                throw new Error(`schema ${schemaId} must be string`);\n            }\n        }\n        key = (0, resolve_1.normalizeId)(key || id);\n        this._checkUnique(key);\n        this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);\n        return this;\n    }\n    // Add schema that will be used to validate other schemas\n    // options in META_IGNORE_OPTIONS are alway set to false\n    addMetaSchema(schema, key, // schema key\n    _validateSchema = this.opts.validateSchema // false to skip schema validation, can be used to override validateSchema option for meta-schema\n    ) {\n        this.addSchema(schema, key, true, _validateSchema);\n        return this;\n    }\n    //  Validate schema against its meta-schema\n    validateSchema(schema, throwOrLogError) {\n        if (typeof schema == \"boolean\")\n            return true;\n        let $schema;\n        $schema = schema.$schema;\n        if ($schema !== undefined && typeof $schema != \"string\") {\n            throw new Error(\"$schema must be a string\");\n        }\n        $schema = $schema || this.opts.defaultMeta || this.defaultMeta();\n        if (!$schema) {\n            this.logger.warn(\"meta-schema not available\");\n            this.errors = null;\n            return true;\n        }\n        const valid = this.validate($schema, schema);\n        if (!valid && throwOrLogError) {\n            const message = \"schema is invalid: \" + this.errorsText();\n            if (this.opts.validateSchema === \"log\")\n                this.logger.error(message);\n            else\n                throw new Error(message);\n        }\n        return valid;\n    }\n    // Get compiled schema by `key` or `ref`.\n    // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)\n    getSchema(keyRef) {\n        let sch;\n        while (typeof (sch = getSchEnv.call(this, keyRef)) == \"string\")\n            keyRef = sch;\n        if (sch === undefined) {\n            const { schemaId } = this.opts;\n            const root = new compile_1.SchemaEnv({ schema: {}, schemaId });\n            sch = compile_1.resolveSchema.call(this, root, keyRef);\n            if (!sch)\n                return;\n            this.refs[keyRef] = sch;\n        }\n        return (sch.validate || this._compileSchemaEnv(sch));\n    }\n    // Remove cached schema(s).\n    // If no parameter is passed all schemas but meta-schemas are removed.\n    // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.\n    // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.\n    removeSchema(schemaKeyRef) {\n        if (schemaKeyRef instanceof RegExp) {\n            this._removeAllSchemas(this.schemas, schemaKeyRef);\n            this._removeAllSchemas(this.refs, schemaKeyRef);\n            return this;\n        }\n        switch (typeof schemaKeyRef) {\n            case \"undefined\":\n                this._removeAllSchemas(this.schemas);\n                this._removeAllSchemas(this.refs);\n                this._cache.clear();\n                return this;\n            case \"string\": {\n                const sch = getSchEnv.call(this, schemaKeyRef);\n                if (typeof sch == \"object\")\n                    this._cache.delete(sch.schema);\n                delete this.schemas[schemaKeyRef];\n                delete this.refs[schemaKeyRef];\n                return this;\n            }\n            case \"object\": {\n                const cacheKey = schemaKeyRef;\n                this._cache.delete(cacheKey);\n                let id = schemaKeyRef[this.opts.schemaId];\n                if (id) {\n                    id = (0, resolve_1.normalizeId)(id);\n                    delete this.schemas[id];\n                    delete this.refs[id];\n                }\n                return this;\n            }\n            default:\n                throw new Error(\"ajv.removeSchema: invalid parameter\");\n        }\n    }\n    // add \"vocabulary\" - a collection of keywords\n    addVocabulary(definitions) {\n        for (const def of definitions)\n            this.addKeyword(def);\n        return this;\n    }\n    addKeyword(kwdOrDef, def // deprecated\n    ) {\n        let keyword;\n        if (typeof kwdOrDef == \"string\") {\n            keyword = kwdOrDef;\n            if (typeof def == \"object\") {\n                this.logger.warn(\"these parameters are deprecated, see docs for addKeyword\");\n                def.keyword = keyword;\n            }\n        }\n        else if (typeof kwdOrDef == \"object\" && def === undefined) {\n            def = kwdOrDef;\n            keyword = def.keyword;\n            if (Array.isArray(keyword) && !keyword.length) {\n                throw new Error(\"addKeywords: keyword must be string or non-empty array\");\n            }\n        }\n        else {\n            throw new Error(\"invalid addKeywords parameters\");\n        }\n        checkKeyword.call(this, keyword, def);\n        if (!def) {\n            (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));\n            return this;\n        }\n        keywordMetaschema.call(this, def);\n        const definition = {\n            ...def,\n            type: (0, dataType_1.getJSONTypes)(def.type),\n            schemaType: (0, dataType_1.getJSONTypes)(def.schemaType),\n        };\n        (0, util_1.eachItem)(keyword, definition.type.length === 0\n            ? (k) => addRule.call(this, k, definition)\n            : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));\n        return this;\n    }\n    getKeyword(keyword) {\n        const rule = this.RULES.all[keyword];\n        return typeof rule == \"object\" ? rule.definition : !!rule;\n    }\n    // Remove keyword\n    removeKeyword(keyword) {\n        // TODO return type should be Ajv\n        const { RULES } = this;\n        delete RULES.keywords[keyword];\n        delete RULES.all[keyword];\n        for (const group of RULES.rules) {\n            const i = group.rules.findIndex((rule) => rule.keyword === keyword);\n            if (i >= 0)\n                group.rules.splice(i, 1);\n        }\n        return this;\n    }\n    // Add format\n    addFormat(name, format) {\n        if (typeof format == \"string\")\n            format = new RegExp(format);\n        this.formats[name] = format;\n        return this;\n    }\n    errorsText(errors = this.errors, // optional array of validation errors\n    { separator = \", \", dataVar = \"data\" } = {} // optional options with properties `separator` and `dataVar`\n    ) {\n        if (!errors || errors.length === 0)\n            return \"No errors\";\n        return errors\n            .map((e) => `${dataVar}${e.instancePath} ${e.message}`)\n            .reduce((text, msg) => text + separator + msg);\n    }\n    $dataMetaSchema(metaSchema, keywordsJsonPointers) {\n        const rules = this.RULES.all;\n        metaSchema = JSON.parse(JSON.stringify(metaSchema));\n        for (const jsonPointer of keywordsJsonPointers) {\n            const segments = jsonPointer.split(\"/\").slice(1); // first segment is an empty string\n            let keywords = metaSchema;\n            for (const seg of segments)\n                keywords = keywords[seg];\n            for (const key in rules) {\n                const rule = rules[key];\n                if (typeof rule != \"object\")\n                    continue;\n                const { $data } = rule.definition;\n                const schema = keywords[key];\n                if ($data && schema)\n                    keywords[key] = schemaOrData(schema);\n            }\n        }\n        return metaSchema;\n    }\n    _removeAllSchemas(schemas, regex) {\n        for (const keyRef in schemas) {\n            const sch = schemas[keyRef];\n            if (!regex || regex.test(keyRef)) {\n                if (typeof sch == \"string\") {\n                    delete schemas[keyRef];\n                }\n                else if (sch && !sch.meta) {\n                    this._cache.delete(sch.schema);\n                    delete schemas[keyRef];\n                }\n            }\n        }\n    }\n    _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {\n        let id;\n        const { schemaId } = this.opts;\n        if (typeof schema == \"object\") {\n            id = schema[schemaId];\n        }\n        else {\n            if (this.opts.jtd)\n                throw new Error(\"schema must be object\");\n            else if (typeof schema != \"boolean\")\n                throw new Error(\"schema must be object or boolean\");\n        }\n        let sch = this._cache.get(schema);\n        if (sch !== undefined)\n            return sch;\n        baseId = (0, resolve_1.normalizeId)(id || baseId);\n        const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);\n        sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });\n        this._cache.set(sch.schema, sch);\n        if (addSchema && !baseId.startsWith(\"#\")) {\n            // TODO atm it is allowed to overwrite schemas without id (instead of not adding them)\n            if (baseId)\n                this._checkUnique(baseId);\n            this.refs[baseId] = sch;\n        }\n        if (validateSchema)\n            this.validateSchema(schema, true);\n        return sch;\n    }\n    _checkUnique(id) {\n        if (this.schemas[id] || this.refs[id]) {\n            throw new Error(`schema with key or id \"${id}\" already exists`);\n        }\n    }\n    _compileSchemaEnv(sch) {\n        if (sch.meta)\n            this._compileMetaSchema(sch);\n        else\n            compile_1.compileSchema.call(this, sch);\n        /* istanbul ignore if */\n        if (!sch.validate)\n            throw new Error(\"ajv implementation error\");\n        return sch.validate;\n    }\n    _compileMetaSchema(sch) {\n        const currentOpts = this.opts;\n        this.opts = this._metaOpts;\n        try {\n            compile_1.compileSchema.call(this, sch);\n        }\n        finally {\n            this.opts = currentOpts;\n        }\n    }\n}\nexports.default = Ajv;\nAjv.ValidationError = validation_error_1.default;\nAjv.MissingRefError = ref_error_1.default;\nfunction checkOptions(checkOpts, options, msg, log = \"error\") {\n    for (const key in checkOpts) {\n        const opt = key;\n        if (opt in options)\n            this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);\n    }\n}\nfunction getSchEnv(keyRef) {\n    keyRef = (0, resolve_1.normalizeId)(keyRef); // TODO tests fail without this line\n    return this.schemas[keyRef] || this.refs[keyRef];\n}\nfunction addInitialSchemas() {\n    const optsSchemas = this.opts.schemas;\n    if (!optsSchemas)\n        return;\n    if (Array.isArray(optsSchemas))\n        this.addSchema(optsSchemas);\n    else\n        for (const key in optsSchemas)\n            this.addSchema(optsSchemas[key], key);\n}\nfunction addInitialFormats() {\n    for (const name in this.opts.formats) {\n        const format = this.opts.formats[name];\n        if (format)\n            this.addFormat(name, format);\n    }\n}\nfunction addInitialKeywords(defs) {\n    if (Array.isArray(defs)) {\n        this.addVocabulary(defs);\n        return;\n    }\n    this.logger.warn(\"keywords option as map is deprecated, pass array\");\n    for (const keyword in defs) {\n        const def = defs[keyword];\n        if (!def.keyword)\n            def.keyword = keyword;\n        this.addKeyword(def);\n    }\n}\nfunction getMetaSchemaOptions() {\n    const metaOpts = { ...this.opts };\n    for (const opt of META_IGNORE_OPTIONS)\n        delete metaOpts[opt];\n    return metaOpts;\n}\nconst noLogs = { log() { }, warn() { }, error() { } };\nfunction getLogger(logger) {\n    if (logger === false)\n        return noLogs;\n    if (logger === undefined)\n        return console;\n    if (logger.log && logger.warn && logger.error)\n        return logger;\n    throw new Error(\"logger must implement log, warn and error methods\");\n}\nconst KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;\nfunction checkKeyword(keyword, def) {\n    const { RULES } = this;\n    (0, util_1.eachItem)(keyword, (kwd) => {\n        if (RULES.keywords[kwd])\n            throw new Error(`Keyword ${kwd} is already defined`);\n        if (!KEYWORD_NAME.test(kwd))\n            throw new Error(`Keyword ${kwd} has invalid name`);\n    });\n    if (!def)\n        return;\n    if (def.$data && !(\"code\" in def || \"validate\" in def)) {\n        throw new Error('$data keyword must have \"code\" or \"validate\" function');\n    }\n}\nfunction addRule(keyword, definition, dataType) {\n    var _a;\n    const post = definition === null || definition === void 0 ? void 0 : definition.post;\n    if (dataType && post)\n        throw new Error('keyword with \"post\" flag cannot have \"type\"');\n    const { RULES } = this;\n    let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);\n    if (!ruleGroup) {\n        ruleGroup = { type: dataType, rules: [] };\n        RULES.rules.push(ruleGroup);\n    }\n    RULES.keywords[keyword] = true;\n    if (!definition)\n        return;\n    const rule = {\n        keyword,\n        definition: {\n            ...definition,\n            type: (0, dataType_1.getJSONTypes)(definition.type),\n            schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType),\n        },\n    };\n    if (definition.before)\n        addBeforeRule.call(this, ruleGroup, rule, definition.before);\n    else\n        ruleGroup.rules.push(rule);\n    RULES.all[keyword] = rule;\n    (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));\n}\nfunction addBeforeRule(ruleGroup, rule, before) {\n    const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);\n    if (i >= 0) {\n        ruleGroup.rules.splice(i, 0, rule);\n    }\n    else {\n        ruleGroup.rules.push(rule);\n        this.logger.warn(`rule ${before} is not defined`);\n    }\n}\nfunction keywordMetaschema(def) {\n    let { metaSchema } = def;\n    if (metaSchema === undefined)\n        return;\n    if (def.$data && this.opts.$data)\n        metaSchema = schemaOrData(metaSchema);\n    def.validateSchema = this.compile(metaSchema, true);\n}\nconst $dataRef = {\n    $ref: \"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#\",\n};\nfunction schemaOrData(schema) {\n    return { anyOf: [schema, $dataRef] };\n}\n//# sourceMappingURL=core.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// https://github.com/ajv-validator/ajv/issues/889\nconst equal = require(\"fast-deep-equal\");\nequal.code = 'require(\"ajv/dist/runtime/equal\").default';\nexports.default = equal;\n//# sourceMappingURL=equal.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// https://mathiasbynens.be/notes/javascript-encoding\n// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode\nfunction ucs2length(str) {\n    const len = str.length;\n    let length = 0;\n    let pos = 0;\n    let value;\n    while (pos < len) {\n        length++;\n        value = str.charCodeAt(pos++);\n        if (value >= 0xd800 && value <= 0xdbff && pos < len) {\n            // high surrogate, and there is a next character\n            value = str.charCodeAt(pos);\n            if ((value & 0xfc00) === 0xdc00)\n                pos++; // low surrogate\n        }\n    }\n    return length;\n}\nexports.default = ucs2length;\nucs2length.code = 'require(\"ajv/dist/runtime/ucs2length\").default';\n//# sourceMappingURL=ucs2length.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst uri = require(\"uri-js\");\nuri.code = 'require(\"ajv/dist/runtime/uri\").default';\nexports.default = uri;\n//# sourceMappingURL=uri.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nclass ValidationError extends Error {\n    constructor(errors) {\n        super(\"validation failed\");\n        this.errors = errors;\n        this.ajv = this.validation = true;\n    }\n}\nexports.default = ValidationError;\n//# sourceMappingURL=validation_error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.validateAdditionalItems = void 0;\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: ({ params: { len } }) => (0, codegen_1.str) `must NOT have more than ${len} items`,\n    params: ({ params: { len } }) => (0, codegen_1._) `{limit: ${len}}`,\n};\nconst def = {\n    keyword: \"additionalItems\",\n    type: \"array\",\n    schemaType: [\"boolean\", \"object\"],\n    before: \"uniqueItems\",\n    error,\n    code(cxt) {\n        const { parentSchema, it } = cxt;\n        const { items } = parentSchema;\n        if (!Array.isArray(items)) {\n            (0, util_1.checkStrictMode)(it, '\"additionalItems\" is ignored when \"items\" is not an array of schemas');\n            return;\n        }\n        validateAdditionalItems(cxt, items);\n    },\n};\nfunction validateAdditionalItems(cxt, items) {\n    const { gen, schema, data, keyword, it } = cxt;\n    it.items = true;\n    const len = gen.const(\"len\", (0, codegen_1._) `${data}.length`);\n    if (schema === false) {\n        cxt.setParams({ len: items.length });\n        cxt.pass((0, codegen_1._) `${len} <= ${items.length}`);\n    }\n    else if (typeof schema == \"object\" && !(0, util_1.alwaysValidSchema)(it, schema)) {\n        const valid = gen.var(\"valid\", (0, codegen_1._) `${len} <= ${items.length}`); // TODO var\n        gen.if((0, codegen_1.not)(valid), () => validateItems(valid));\n        cxt.ok(valid);\n    }\n    function validateItems(valid) {\n        gen.forRange(\"i\", items.length, len, (i) => {\n            cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);\n            if (!it.allErrors)\n                gen.if((0, codegen_1.not)(valid), () => gen.break());\n        });\n    }\n}\nexports.validateAdditionalItems = validateAdditionalItems;\nexports.default = def;\n//# sourceMappingURL=additionalItems.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst code_1 = require(\"../code\");\nconst codegen_1 = require(\"../../compile/codegen\");\nconst names_1 = require(\"../../compile/names\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: \"must NOT have additional properties\",\n    params: ({ params }) => (0, codegen_1._) `{additionalProperty: ${params.additionalProperty}}`,\n};\nconst def = {\n    keyword: \"additionalProperties\",\n    type: [\"object\"],\n    schemaType: [\"boolean\", \"object\"],\n    allowUndefined: true,\n    trackErrors: true,\n    error,\n    code(cxt) {\n        const { gen, schema, parentSchema, data, errsCount, it } = cxt;\n        /* istanbul ignore if */\n        if (!errsCount)\n            throw new Error(\"ajv implementation error\");\n        const { allErrors, opts } = it;\n        it.props = true;\n        if (opts.removeAdditional !== \"all\" && (0, util_1.alwaysValidSchema)(it, schema))\n            return;\n        const props = (0, code_1.allSchemaProperties)(parentSchema.properties);\n        const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);\n        checkAdditionalProperties();\n        cxt.ok((0, codegen_1._) `${errsCount} === ${names_1.default.errors}`);\n        function checkAdditionalProperties() {\n            gen.forIn(\"key\", data, (key) => {\n                if (!props.length && !patProps.length)\n                    additionalPropertyCode(key);\n                else\n                    gen.if(isAdditional(key), () => additionalPropertyCode(key));\n            });\n        }\n        function isAdditional(key) {\n            let definedProp;\n            if (props.length > 8) {\n                // TODO maybe an option instead of hard-coded 8?\n                const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, \"properties\");\n                definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);\n            }\n            else if (props.length) {\n                definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._) `${key} === ${p}`));\n            }\n            else {\n                definedProp = codegen_1.nil;\n            }\n            if (patProps.length) {\n                definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._) `${(0, code_1.usePattern)(cxt, p)}.test(${key})`));\n            }\n            return (0, codegen_1.not)(definedProp);\n        }\n        function deleteAdditional(key) {\n            gen.code((0, codegen_1._) `delete ${data}[${key}]`);\n        }\n        function additionalPropertyCode(key) {\n            if (opts.removeAdditional === \"all\" || (opts.removeAdditional && schema === false)) {\n                deleteAdditional(key);\n                return;\n            }\n            if (schema === false) {\n                cxt.setParams({ additionalProperty: key });\n                cxt.error();\n                if (!allErrors)\n                    gen.break();\n                return;\n            }\n            if (typeof schema == \"object\" && !(0, util_1.alwaysValidSchema)(it, schema)) {\n                const valid = gen.name(\"valid\");\n                if (opts.removeAdditional === \"failing\") {\n                    applyAdditionalSchema(key, valid, false);\n                    gen.if((0, codegen_1.not)(valid), () => {\n                        cxt.reset();\n                        deleteAdditional(key);\n                    });\n                }\n                else {\n                    applyAdditionalSchema(key, valid);\n                    if (!allErrors)\n                        gen.if((0, codegen_1.not)(valid), () => gen.break());\n                }\n            }\n        }\n        function applyAdditionalSchema(key, valid, errors) {\n            const subschema = {\n                keyword: \"additionalProperties\",\n                dataProp: key,\n                dataPropType: util_1.Type.Str,\n            };\n            if (errors === false) {\n                Object.assign(subschema, {\n                    compositeRule: true,\n                    createErrors: false,\n                    allErrors: false,\n                });\n            }\n            cxt.subschema(subschema, valid);\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=additionalProperties.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst util_1 = require(\"../../compile/util\");\nconst def = {\n    keyword: \"allOf\",\n    schemaType: \"array\",\n    code(cxt) {\n        const { gen, schema, it } = cxt;\n        /* istanbul ignore if */\n        if (!Array.isArray(schema))\n            throw new Error(\"ajv implementation error\");\n        const valid = gen.name(\"valid\");\n        schema.forEach((sch, i) => {\n            if ((0, util_1.alwaysValidSchema)(it, sch))\n                return;\n            const schCxt = cxt.subschema({ keyword: \"allOf\", schemaProp: i }, valid);\n            cxt.ok(valid);\n            cxt.mergeEvaluated(schCxt);\n        });\n    },\n};\nexports.default = def;\n//# sourceMappingURL=allOf.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst code_1 = require(\"../code\");\nconst def = {\n    keyword: \"anyOf\",\n    schemaType: \"array\",\n    trackErrors: true,\n    code: code_1.validateUnion,\n    error: { message: \"must match a schema in anyOf\" },\n};\nexports.default = def;\n//# sourceMappingURL=anyOf.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: ({ params: { min, max } }) => max === undefined\n        ? (0, codegen_1.str) `must contain at least ${min} valid item(s)`\n        : (0, codegen_1.str) `must contain at least ${min} and no more than ${max} valid item(s)`,\n    params: ({ params: { min, max } }) => max === undefined ? (0, codegen_1._) `{minContains: ${min}}` : (0, codegen_1._) `{minContains: ${min}, maxContains: ${max}}`,\n};\nconst def = {\n    keyword: \"contains\",\n    type: \"array\",\n    schemaType: [\"object\", \"boolean\"],\n    before: \"uniqueItems\",\n    trackErrors: true,\n    error,\n    code(cxt) {\n        const { gen, schema, parentSchema, data, it } = cxt;\n        let min;\n        let max;\n        const { minContains, maxContains } = parentSchema;\n        if (it.opts.next) {\n            min = minContains === undefined ? 1 : minContains;\n            max = maxContains;\n        }\n        else {\n            min = 1;\n        }\n        const len = gen.const(\"len\", (0, codegen_1._) `${data}.length`);\n        cxt.setParams({ min, max });\n        if (max === undefined && min === 0) {\n            (0, util_1.checkStrictMode)(it, `\"minContains\" == 0 without \"maxContains\": \"contains\" keyword ignored`);\n            return;\n        }\n        if (max !== undefined && min > max) {\n            (0, util_1.checkStrictMode)(it, `\"minContains\" > \"maxContains\" is always invalid`);\n            cxt.fail();\n            return;\n        }\n        if ((0, util_1.alwaysValidSchema)(it, schema)) {\n            let cond = (0, codegen_1._) `${len} >= ${min}`;\n            if (max !== undefined)\n                cond = (0, codegen_1._) `${cond} && ${len} <= ${max}`;\n            cxt.pass(cond);\n            return;\n        }\n        it.items = true;\n        const valid = gen.name(\"valid\");\n        if (max === undefined && min === 1) {\n            validateItems(valid, () => gen.if(valid, () => gen.break()));\n        }\n        else if (min === 0) {\n            gen.let(valid, true);\n            if (max !== undefined)\n                gen.if((0, codegen_1._) `${data}.length > 0`, validateItemsWithCount);\n        }\n        else {\n            gen.let(valid, false);\n            validateItemsWithCount();\n        }\n        cxt.result(valid, () => cxt.reset());\n        function validateItemsWithCount() {\n            const schValid = gen.name(\"_valid\");\n            const count = gen.let(\"count\", 0);\n            validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));\n        }\n        function validateItems(_valid, block) {\n            gen.forRange(\"i\", 0, len, (i) => {\n                cxt.subschema({\n                    keyword: \"contains\",\n                    dataProp: i,\n                    dataPropType: util_1.Type.Num,\n                    compositeRule: true,\n                }, _valid);\n                block();\n            });\n        }\n        function checkLimits(count) {\n            gen.code((0, codegen_1._) `${count}++`);\n            if (max === undefined) {\n                gen.if((0, codegen_1._) `${count} >= ${min}`, () => gen.assign(valid, true).break());\n            }\n            else {\n                gen.if((0, codegen_1._) `${count} > ${max}`, () => gen.assign(valid, false).break());\n                if (min === 1)\n                    gen.assign(valid, true);\n                else\n                    gen.if((0, codegen_1._) `${count} >= ${min}`, () => gen.assign(valid, true));\n            }\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=contains.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst code_1 = require(\"../code\");\nexports.error = {\n    message: ({ params: { property, depsCount, deps } }) => {\n        const property_ies = depsCount === 1 ? \"property\" : \"properties\";\n        return (0, codegen_1.str) `must have ${property_ies} ${deps} when property ${property} is present`;\n    },\n    params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._) `{property: ${property},\n    missingProperty: ${missingProperty},\n    depsCount: ${depsCount},\n    deps: ${deps}}`, // TODO change to reference\n};\nconst def = {\n    keyword: \"dependencies\",\n    type: \"object\",\n    schemaType: \"object\",\n    error: exports.error,\n    code(cxt) {\n        const [propDeps, schDeps] = splitDependencies(cxt);\n        validatePropertyDeps(cxt, propDeps);\n        validateSchemaDeps(cxt, schDeps);\n    },\n};\nfunction splitDependencies({ schema }) {\n    const propertyDeps = {};\n    const schemaDeps = {};\n    for (const key in schema) {\n        if (key === \"__proto__\")\n            continue;\n        const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;\n        deps[key] = schema[key];\n    }\n    return [propertyDeps, schemaDeps];\n}\nfunction validatePropertyDeps(cxt, propertyDeps = cxt.schema) {\n    const { gen, data, it } = cxt;\n    if (Object.keys(propertyDeps).length === 0)\n        return;\n    const missing = gen.let(\"missing\");\n    for (const prop in propertyDeps) {\n        const deps = propertyDeps[prop];\n        if (deps.length === 0)\n            continue;\n        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);\n        cxt.setParams({\n            property: prop,\n            depsCount: deps.length,\n            deps: deps.join(\", \"),\n        });\n        if (it.allErrors) {\n            gen.if(hasProperty, () => {\n                for (const depProp of deps) {\n                    (0, code_1.checkReportMissingProp)(cxt, depProp);\n                }\n            });\n        }\n        else {\n            gen.if((0, codegen_1._) `${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);\n            (0, code_1.reportMissingProp)(cxt, missing);\n            gen.else();\n        }\n    }\n}\nexports.validatePropertyDeps = validatePropertyDeps;\nfunction validateSchemaDeps(cxt, schemaDeps = cxt.schema) {\n    const { gen, data, keyword, it } = cxt;\n    const valid = gen.name(\"valid\");\n    for (const prop in schemaDeps) {\n        if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))\n            continue;\n        gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {\n            const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);\n            cxt.mergeValidEvaluated(schCxt, valid);\n        }, () => gen.var(valid, true) // TODO var\n        );\n        cxt.ok(valid);\n    }\n}\nexports.validateSchemaDeps = validateSchemaDeps;\nexports.default = def;\n//# sourceMappingURL=dependencies.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: ({ params }) => (0, codegen_1.str) `must match \"${params.ifClause}\" schema`,\n    params: ({ params }) => (0, codegen_1._) `{failingKeyword: ${params.ifClause}}`,\n};\nconst def = {\n    keyword: \"if\",\n    schemaType: [\"object\", \"boolean\"],\n    trackErrors: true,\n    error,\n    code(cxt) {\n        const { gen, parentSchema, it } = cxt;\n        if (parentSchema.then === undefined && parentSchema.else === undefined) {\n            (0, util_1.checkStrictMode)(it, '\"if\" without \"then\" and \"else\" is ignored');\n        }\n        const hasThen = hasSchema(it, \"then\");\n        const hasElse = hasSchema(it, \"else\");\n        if (!hasThen && !hasElse)\n            return;\n        const valid = gen.let(\"valid\", true);\n        const schValid = gen.name(\"_valid\");\n        validateIf();\n        cxt.reset();\n        if (hasThen && hasElse) {\n            const ifClause = gen.let(\"ifClause\");\n            cxt.setParams({ ifClause });\n            gen.if(schValid, validateClause(\"then\", ifClause), validateClause(\"else\", ifClause));\n        }\n        else if (hasThen) {\n            gen.if(schValid, validateClause(\"then\"));\n        }\n        else {\n            gen.if((0, codegen_1.not)(schValid), validateClause(\"else\"));\n        }\n        cxt.pass(valid, () => cxt.error(true));\n        function validateIf() {\n            const schCxt = cxt.subschema({\n                keyword: \"if\",\n                compositeRule: true,\n                createErrors: false,\n                allErrors: false,\n            }, schValid);\n            cxt.mergeEvaluated(schCxt);\n        }\n        function validateClause(keyword, ifClause) {\n            return () => {\n                const schCxt = cxt.subschema({ keyword }, schValid);\n                gen.assign(valid, schValid);\n                cxt.mergeValidEvaluated(schCxt, valid);\n                if (ifClause)\n                    gen.assign(ifClause, (0, codegen_1._) `${keyword}`);\n                else\n                    cxt.setParams({ ifClause: keyword });\n            };\n        }\n    },\n};\nfunction hasSchema(it, keyword) {\n    const schema = it.schema[keyword];\n    return schema !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);\n}\nexports.default = def;\n//# sourceMappingURL=if.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst additionalItems_1 = require(\"./additionalItems\");\nconst prefixItems_1 = require(\"./prefixItems\");\nconst items_1 = require(\"./items\");\nconst items2020_1 = require(\"./items2020\");\nconst contains_1 = require(\"./contains\");\nconst dependencies_1 = require(\"./dependencies\");\nconst propertyNames_1 = require(\"./propertyNames\");\nconst additionalProperties_1 = require(\"./additionalProperties\");\nconst properties_1 = require(\"./properties\");\nconst patternProperties_1 = require(\"./patternProperties\");\nconst not_1 = require(\"./not\");\nconst anyOf_1 = require(\"./anyOf\");\nconst oneOf_1 = require(\"./oneOf\");\nconst allOf_1 = require(\"./allOf\");\nconst if_1 = require(\"./if\");\nconst thenElse_1 = require(\"./thenElse\");\nfunction getApplicator(draft2020 = false) {\n    const applicator = [\n        // any\n        not_1.default,\n        anyOf_1.default,\n        oneOf_1.default,\n        allOf_1.default,\n        if_1.default,\n        thenElse_1.default,\n        // object\n        propertyNames_1.default,\n        additionalProperties_1.default,\n        dependencies_1.default,\n        properties_1.default,\n        patternProperties_1.default,\n    ];\n    // array\n    if (draft2020)\n        applicator.push(prefixItems_1.default, items2020_1.default);\n    else\n        applicator.push(additionalItems_1.default, items_1.default);\n    applicator.push(contains_1.default);\n    return applicator;\n}\nexports.default = getApplicator;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.validateTuple = void 0;\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst code_1 = require(\"../code\");\nconst def = {\n    keyword: \"items\",\n    type: \"array\",\n    schemaType: [\"object\", \"array\", \"boolean\"],\n    before: \"uniqueItems\",\n    code(cxt) {\n        const { schema, it } = cxt;\n        if (Array.isArray(schema))\n            return validateTuple(cxt, \"additionalItems\", schema);\n        it.items = true;\n        if ((0, util_1.alwaysValidSchema)(it, schema))\n            return;\n        cxt.ok((0, code_1.validateArray)(cxt));\n    },\n};\nfunction validateTuple(cxt, extraItems, schArr = cxt.schema) {\n    const { gen, parentSchema, data, keyword, it } = cxt;\n    checkStrictTuple(parentSchema);\n    if (it.opts.unevaluated && schArr.length && it.items !== true) {\n        it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);\n    }\n    const valid = gen.name(\"valid\");\n    const len = gen.const(\"len\", (0, codegen_1._) `${data}.length`);\n    schArr.forEach((sch, i) => {\n        if ((0, util_1.alwaysValidSchema)(it, sch))\n            return;\n        gen.if((0, codegen_1._) `${len} > ${i}`, () => cxt.subschema({\n            keyword,\n            schemaProp: i,\n            dataProp: i,\n        }, valid));\n        cxt.ok(valid);\n    });\n    function checkStrictTuple(sch) {\n        const { opts, errSchemaPath } = it;\n        const l = schArr.length;\n        const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);\n        if (opts.strictTuples && !fullTuple) {\n            const msg = `\"${keyword}\" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path \"${errSchemaPath}\"`;\n            (0, util_1.checkStrictMode)(it, msg, opts.strictTuples);\n        }\n    }\n}\nexports.validateTuple = validateTuple;\nexports.default = def;\n//# sourceMappingURL=items.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst code_1 = require(\"../code\");\nconst additionalItems_1 = require(\"./additionalItems\");\nconst error = {\n    message: ({ params: { len } }) => (0, codegen_1.str) `must NOT have more than ${len} items`,\n    params: ({ params: { len } }) => (0, codegen_1._) `{limit: ${len}}`,\n};\nconst def = {\n    keyword: \"items\",\n    type: \"array\",\n    schemaType: [\"object\", \"boolean\"],\n    before: \"uniqueItems\",\n    error,\n    code(cxt) {\n        const { schema, parentSchema, it } = cxt;\n        const { prefixItems } = parentSchema;\n        it.items = true;\n        if ((0, util_1.alwaysValidSchema)(it, schema))\n            return;\n        if (prefixItems)\n            (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);\n        else\n            cxt.ok((0, code_1.validateArray)(cxt));\n    },\n};\nexports.default = def;\n//# sourceMappingURL=items2020.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst util_1 = require(\"../../compile/util\");\nconst def = {\n    keyword: \"not\",\n    schemaType: [\"object\", \"boolean\"],\n    trackErrors: true,\n    code(cxt) {\n        const { gen, schema, it } = cxt;\n        if ((0, util_1.alwaysValidSchema)(it, schema)) {\n            cxt.fail();\n            return;\n        }\n        const valid = gen.name(\"valid\");\n        cxt.subschema({\n            keyword: \"not\",\n            compositeRule: true,\n            createErrors: false,\n            allErrors: false,\n        }, valid);\n        cxt.failResult(valid, () => cxt.reset(), () => cxt.error());\n    },\n    error: { message: \"must NOT be valid\" },\n};\nexports.default = def;\n//# sourceMappingURL=not.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: \"must match exactly one schema in oneOf\",\n    params: ({ params }) => (0, codegen_1._) `{passingSchemas: ${params.passing}}`,\n};\nconst def = {\n    keyword: \"oneOf\",\n    schemaType: \"array\",\n    trackErrors: true,\n    error,\n    code(cxt) {\n        const { gen, schema, parentSchema, it } = cxt;\n        /* istanbul ignore if */\n        if (!Array.isArray(schema))\n            throw new Error(\"ajv implementation error\");\n        if (it.opts.discriminator && parentSchema.discriminator)\n            return;\n        const schArr = schema;\n        const valid = gen.let(\"valid\", false);\n        const passing = gen.let(\"passing\", null);\n        const schValid = gen.name(\"_valid\");\n        cxt.setParams({ passing });\n        // TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas\n        gen.block(validateOneOf);\n        cxt.result(valid, () => cxt.reset(), () => cxt.error(true));\n        function validateOneOf() {\n            schArr.forEach((sch, i) => {\n                let schCxt;\n                if ((0, util_1.alwaysValidSchema)(it, sch)) {\n                    gen.var(schValid, true);\n                }\n                else {\n                    schCxt = cxt.subschema({\n                        keyword: \"oneOf\",\n                        schemaProp: i,\n                        compositeRule: true,\n                    }, schValid);\n                }\n                if (i > 0) {\n                    gen\n                        .if((0, codegen_1._) `${schValid} && ${valid}`)\n                        .assign(valid, false)\n                        .assign(passing, (0, codegen_1._) `[${passing}, ${i}]`)\n                        .else();\n                }\n                gen.if(schValid, () => {\n                    gen.assign(valid, true);\n                    gen.assign(passing, i);\n                    if (schCxt)\n                        cxt.mergeEvaluated(schCxt, codegen_1.Name);\n                });\n            });\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=oneOf.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst code_1 = require(\"../code\");\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst util_2 = require(\"../../compile/util\");\nconst def = {\n    keyword: \"patternProperties\",\n    type: \"object\",\n    schemaType: \"object\",\n    code(cxt) {\n        const { gen, schema, data, parentSchema, it } = cxt;\n        const { opts } = it;\n        const patterns = (0, code_1.allSchemaProperties)(schema);\n        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));\n        if (patterns.length === 0 ||\n            (alwaysValidPatterns.length === patterns.length &&\n                (!it.opts.unevaluated || it.props === true))) {\n            return;\n        }\n        const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;\n        const valid = gen.name(\"valid\");\n        if (it.props !== true && !(it.props instanceof codegen_1.Name)) {\n            it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);\n        }\n        const { props } = it;\n        validatePatternProperties();\n        function validatePatternProperties() {\n            for (const pat of patterns) {\n                if (checkProperties)\n                    checkMatchingProperties(pat);\n                if (it.allErrors) {\n                    validateProperties(pat);\n                }\n                else {\n                    gen.var(valid, true); // TODO var\n                    validateProperties(pat);\n                    gen.if(valid);\n                }\n            }\n        }\n        function checkMatchingProperties(pat) {\n            for (const prop in checkProperties) {\n                if (new RegExp(pat).test(prop)) {\n                    (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);\n                }\n            }\n        }\n        function validateProperties(pat) {\n            gen.forIn(\"key\", data, (key) => {\n                gen.if((0, codegen_1._) `${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {\n                    const alwaysValid = alwaysValidPatterns.includes(pat);\n                    if (!alwaysValid) {\n                        cxt.subschema({\n                            keyword: \"patternProperties\",\n                            schemaProp: pat,\n                            dataProp: key,\n                            dataPropType: util_2.Type.Str,\n                        }, valid);\n                    }\n                    if (it.opts.unevaluated && props !== true) {\n                        gen.assign((0, codegen_1._) `${props}[${key}]`, true);\n                    }\n                    else if (!alwaysValid && !it.allErrors) {\n                        // can short-circuit if `unevaluatedProperties` is not supported (opts.next === false)\n                        // or if all properties were evaluated (props === true)\n                        gen.if((0, codegen_1.not)(valid), () => gen.break());\n                    }\n                });\n            });\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=patternProperties.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst items_1 = require(\"./items\");\nconst def = {\n    keyword: \"prefixItems\",\n    type: \"array\",\n    schemaType: [\"array\"],\n    before: \"uniqueItems\",\n    code: (cxt) => (0, items_1.validateTuple)(cxt, \"items\"),\n};\nexports.default = def;\n//# sourceMappingURL=prefixItems.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst validate_1 = require(\"../../compile/validate\");\nconst code_1 = require(\"../code\");\nconst util_1 = require(\"../../compile/util\");\nconst additionalProperties_1 = require(\"./additionalProperties\");\nconst def = {\n    keyword: \"properties\",\n    type: \"object\",\n    schemaType: \"object\",\n    code(cxt) {\n        const { gen, schema, parentSchema, data, it } = cxt;\n        if (it.opts.removeAdditional === \"all\" && parentSchema.additionalProperties === undefined) {\n            additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, \"additionalProperties\"));\n        }\n        const allProps = (0, code_1.allSchemaProperties)(schema);\n        for (const prop of allProps) {\n            it.definedProperties.add(prop);\n        }\n        if (it.opts.unevaluated && allProps.length && it.props !== true) {\n            it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);\n        }\n        const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));\n        if (properties.length === 0)\n            return;\n        const valid = gen.name(\"valid\");\n        for (const prop of properties) {\n            if (hasDefault(prop)) {\n                applyPropertySchema(prop);\n            }\n            else {\n                gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));\n                applyPropertySchema(prop);\n                if (!it.allErrors)\n                    gen.else().var(valid, true);\n                gen.endIf();\n            }\n            cxt.it.definedProperties.add(prop);\n            cxt.ok(valid);\n        }\n        function hasDefault(prop) {\n            return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined;\n        }\n        function applyPropertySchema(prop) {\n            cxt.subschema({\n                keyword: \"properties\",\n                schemaProp: prop,\n                dataProp: prop,\n            }, valid);\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=properties.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: \"property name must be valid\",\n    params: ({ params }) => (0, codegen_1._) `{propertyName: ${params.propertyName}}`,\n};\nconst def = {\n    keyword: \"propertyNames\",\n    type: \"object\",\n    schemaType: [\"object\", \"boolean\"],\n    error,\n    code(cxt) {\n        const { gen, schema, data, it } = cxt;\n        if ((0, util_1.alwaysValidSchema)(it, schema))\n            return;\n        const valid = gen.name(\"valid\");\n        gen.forIn(\"key\", data, (key) => {\n            cxt.setParams({ propertyName: key });\n            cxt.subschema({\n                keyword: \"propertyNames\",\n                data: key,\n                dataTypes: [\"string\"],\n                propertyName: key,\n                compositeRule: true,\n            }, valid);\n            gen.if((0, codegen_1.not)(valid), () => {\n                cxt.error(true);\n                if (!it.allErrors)\n                    gen.break();\n            });\n        });\n        cxt.ok(valid);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=propertyNames.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst util_1 = require(\"../../compile/util\");\nconst def = {\n    keyword: [\"then\", \"else\"],\n    schemaType: [\"object\", \"boolean\"],\n    code({ keyword, parentSchema, it }) {\n        if (parentSchema.if === undefined)\n            (0, util_1.checkStrictMode)(it, `\"${keyword}\" without \"if\" is ignored`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=thenElse.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;\nconst codegen_1 = require(\"../compile/codegen\");\nconst util_1 = require(\"../compile/util\");\nconst names_1 = require(\"../compile/names\");\nconst util_2 = require(\"../compile/util\");\nfunction checkReportMissingProp(cxt, prop) {\n    const { gen, data, it } = cxt;\n    gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {\n        cxt.setParams({ missingProperty: (0, codegen_1._) `${prop}` }, true);\n        cxt.error();\n    });\n}\nexports.checkReportMissingProp = checkReportMissingProp;\nfunction checkMissingProp({ gen, data, it: { opts } }, properties, missing) {\n    return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._) `${missing} = ${prop}`)));\n}\nexports.checkMissingProp = checkMissingProp;\nfunction reportMissingProp(cxt, missing) {\n    cxt.setParams({ missingProperty: missing }, true);\n    cxt.error();\n}\nexports.reportMissingProp = reportMissingProp;\nfunction hasPropFunc(gen) {\n    return gen.scopeValue(\"func\", {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        ref: Object.prototype.hasOwnProperty,\n        code: (0, codegen_1._) `Object.prototype.hasOwnProperty`,\n    });\n}\nexports.hasPropFunc = hasPropFunc;\nfunction isOwnProperty(gen, data, property) {\n    return (0, codegen_1._) `${hasPropFunc(gen)}.call(${data}, ${property})`;\n}\nexports.isOwnProperty = isOwnProperty;\nfunction propertyInData(gen, data, property, ownProperties) {\n    const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} !== undefined`;\n    return ownProperties ? (0, codegen_1._) `${cond} && ${isOwnProperty(gen, data, property)}` : cond;\n}\nexports.propertyInData = propertyInData;\nfunction noPropertyInData(gen, data, property, ownProperties) {\n    const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} === undefined`;\n    return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;\n}\nexports.noPropertyInData = noPropertyInData;\nfunction allSchemaProperties(schemaMap) {\n    return schemaMap ? Object.keys(schemaMap).filter((p) => p !== \"__proto__\") : [];\n}\nexports.allSchemaProperties = allSchemaProperties;\nfunction schemaProperties(it, schemaMap) {\n    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));\n}\nexports.schemaProperties = schemaProperties;\nfunction callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {\n    const dataAndSchema = passSchema ? (0, codegen_1._) `${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;\n    const valCxt = [\n        [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],\n        [names_1.default.parentData, it.parentData],\n        [names_1.default.parentDataProperty, it.parentDataProperty],\n        [names_1.default.rootData, names_1.default.rootData],\n    ];\n    if (it.opts.dynamicRef)\n        valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);\n    const args = (0, codegen_1._) `${dataAndSchema}, ${gen.object(...valCxt)}`;\n    return context !== codegen_1.nil ? (0, codegen_1._) `${func}.call(${context}, ${args})` : (0, codegen_1._) `${func}(${args})`;\n}\nexports.callValidateCode = callValidateCode;\nconst newRegExp = (0, codegen_1._) `new RegExp`;\nfunction usePattern({ gen, it: { opts } }, pattern) {\n    const u = opts.unicodeRegExp ? \"u\" : \"\";\n    const { regExp } = opts.code;\n    const rx = regExp(pattern, u);\n    return gen.scopeValue(\"pattern\", {\n        key: rx.toString(),\n        ref: rx,\n        code: (0, codegen_1._) `${regExp.code === \"new RegExp\" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,\n    });\n}\nexports.usePattern = usePattern;\nfunction validateArray(cxt) {\n    const { gen, data, keyword, it } = cxt;\n    const valid = gen.name(\"valid\");\n    if (it.allErrors) {\n        const validArr = gen.let(\"valid\", true);\n        validateItems(() => gen.assign(validArr, false));\n        return validArr;\n    }\n    gen.var(valid, true);\n    validateItems(() => gen.break());\n    return valid;\n    function validateItems(notValid) {\n        const len = gen.const(\"len\", (0, codegen_1._) `${data}.length`);\n        gen.forRange(\"i\", 0, len, (i) => {\n            cxt.subschema({\n                keyword,\n                dataProp: i,\n                dataPropType: util_1.Type.Num,\n            }, valid);\n            gen.if((0, codegen_1.not)(valid), notValid);\n        });\n    }\n}\nexports.validateArray = validateArray;\nfunction validateUnion(cxt) {\n    const { gen, schema, keyword, it } = cxt;\n    /* istanbul ignore if */\n    if (!Array.isArray(schema))\n        throw new Error(\"ajv implementation error\");\n    const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));\n    if (alwaysValid && !it.opts.unevaluated)\n        return;\n    const valid = gen.let(\"valid\", false);\n    const schValid = gen.name(\"_valid\");\n    gen.block(() => schema.forEach((_sch, i) => {\n        const schCxt = cxt.subschema({\n            keyword,\n            schemaProp: i,\n            compositeRule: true,\n        }, schValid);\n        gen.assign(valid, (0, codegen_1._) `${valid} || ${schValid}`);\n        const merged = cxt.mergeValidEvaluated(schCxt, schValid);\n        // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)\n        // or if all properties and items were evaluated (it.props === true && it.items === true)\n        if (!merged)\n            gen.if((0, codegen_1.not)(valid));\n    }));\n    cxt.result(valid, () => cxt.reset(), () => cxt.error(true));\n}\nexports.validateUnion = validateUnion;\n//# sourceMappingURL=code.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst def = {\n    keyword: \"id\",\n    code() {\n        throw new Error('NOT SUPPORTED: keyword \"id\", use \"$id\" for schema ID');\n    },\n};\nexports.default = def;\n//# sourceMappingURL=id.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst id_1 = require(\"./id\");\nconst ref_1 = require(\"./ref\");\nconst core = [\n    \"$schema\",\n    \"$id\",\n    \"$defs\",\n    \"$vocabulary\",\n    { keyword: \"$comment\" },\n    \"definitions\",\n    id_1.default,\n    ref_1.default,\n];\nexports.default = core;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.callRef = exports.getValidate = void 0;\nconst ref_error_1 = require(\"../../compile/ref_error\");\nconst code_1 = require(\"../code\");\nconst codegen_1 = require(\"../../compile/codegen\");\nconst names_1 = require(\"../../compile/names\");\nconst compile_1 = require(\"../../compile\");\nconst util_1 = require(\"../../compile/util\");\nconst def = {\n    keyword: \"$ref\",\n    schemaType: \"string\",\n    code(cxt) {\n        const { gen, schema: $ref, it } = cxt;\n        const { baseId, schemaEnv: env, validateName, opts, self } = it;\n        const { root } = env;\n        if (($ref === \"#\" || $ref === \"#/\") && baseId === root.baseId)\n            return callRootRef();\n        const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);\n        if (schOrEnv === undefined)\n            throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);\n        if (schOrEnv instanceof compile_1.SchemaEnv)\n            return callValidate(schOrEnv);\n        return inlineRefSchema(schOrEnv);\n        function callRootRef() {\n            if (env === root)\n                return callRef(cxt, validateName, env, env.$async);\n            const rootName = gen.scopeValue(\"root\", { ref: root });\n            return callRef(cxt, (0, codegen_1._) `${rootName}.validate`, root, root.$async);\n        }\n        function callValidate(sch) {\n            const v = getValidate(cxt, sch);\n            callRef(cxt, v, sch, sch.$async);\n        }\n        function inlineRefSchema(sch) {\n            const schName = gen.scopeValue(\"schema\", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch });\n            const valid = gen.name(\"valid\");\n            const schCxt = cxt.subschema({\n                schema: sch,\n                dataTypes: [],\n                schemaPath: codegen_1.nil,\n                topSchemaRef: schName,\n                errSchemaPath: $ref,\n            }, valid);\n            cxt.mergeEvaluated(schCxt);\n            cxt.ok(valid);\n        }\n    },\n};\nfunction getValidate(cxt, sch) {\n    const { gen } = cxt;\n    return sch.validate\n        ? gen.scopeValue(\"validate\", { ref: sch.validate })\n        : (0, codegen_1._) `${gen.scopeValue(\"wrapper\", { ref: sch })}.validate`;\n}\nexports.getValidate = getValidate;\nfunction callRef(cxt, v, sch, $async) {\n    const { gen, it } = cxt;\n    const { allErrors, schemaEnv: env, opts } = it;\n    const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;\n    if ($async)\n        callAsyncRef();\n    else\n        callSyncRef();\n    function callAsyncRef() {\n        if (!env.$async)\n            throw new Error(\"async schema referenced by sync schema\");\n        const valid = gen.let(\"valid\");\n        gen.try(() => {\n            gen.code((0, codegen_1._) `await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);\n            addEvaluatedFrom(v); // TODO will not work with async, it has to be returned with the result\n            if (!allErrors)\n                gen.assign(valid, true);\n        }, (e) => {\n            gen.if((0, codegen_1._) `!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));\n            addErrorsFrom(e);\n            if (!allErrors)\n                gen.assign(valid, false);\n        });\n        cxt.ok(valid);\n    }\n    function callSyncRef() {\n        cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));\n    }\n    function addErrorsFrom(source) {\n        const errs = (0, codegen_1._) `${source}.errors`;\n        gen.assign(names_1.default.vErrors, (0, codegen_1._) `${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`); // TODO tagged\n        gen.assign(names_1.default.errors, (0, codegen_1._) `${names_1.default.vErrors}.length`);\n    }\n    function addEvaluatedFrom(source) {\n        var _a;\n        if (!it.opts.unevaluated)\n            return;\n        const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;\n        // TODO refactor\n        if (it.props !== true) {\n            if (schEvaluated && !schEvaluated.dynamicProps) {\n                if (schEvaluated.props !== undefined) {\n                    it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);\n                }\n            }\n            else {\n                const props = gen.var(\"props\", (0, codegen_1._) `${source}.evaluated.props`);\n                it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);\n            }\n        }\n        if (it.items !== true) {\n            if (schEvaluated && !schEvaluated.dynamicItems) {\n                if (schEvaluated.items !== undefined) {\n                    it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);\n                }\n            }\n            else {\n                const items = gen.var(\"items\", (0, codegen_1._) `${source}.evaluated.items`);\n                it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);\n            }\n        }\n    }\n}\nexports.callRef = callRef;\nexports.default = def;\n//# sourceMappingURL=ref.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst types_1 = require(\"../discriminator/types\");\nconst compile_1 = require(\"../../compile\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag\n        ? `tag \"${tagName}\" must be string`\n        : `value of tag \"${tagName}\" must be in oneOf`,\n    params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._) `{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,\n};\nconst def = {\n    keyword: \"discriminator\",\n    type: \"object\",\n    schemaType: \"object\",\n    error,\n    code(cxt) {\n        const { gen, data, schema, parentSchema, it } = cxt;\n        const { oneOf } = parentSchema;\n        if (!it.opts.discriminator) {\n            throw new Error(\"discriminator: requires discriminator option\");\n        }\n        const tagName = schema.propertyName;\n        if (typeof tagName != \"string\")\n            throw new Error(\"discriminator: requires propertyName\");\n        if (schema.mapping)\n            throw new Error(\"discriminator: mapping is not supported\");\n        if (!oneOf)\n            throw new Error(\"discriminator: requires oneOf keyword\");\n        const valid = gen.let(\"valid\", false);\n        const tag = gen.const(\"tag\", (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(tagName)}`);\n        gen.if((0, codegen_1._) `typeof ${tag} == \"string\"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName }));\n        cxt.ok(valid);\n        function validateMapping() {\n            const mapping = getMapping();\n            gen.if(false);\n            for (const tagValue in mapping) {\n                gen.elseIf((0, codegen_1._) `${tag} === ${tagValue}`);\n                gen.assign(valid, applyTagSchema(mapping[tagValue]));\n            }\n            gen.else();\n            cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName });\n            gen.endIf();\n        }\n        function applyTagSchema(schemaProp) {\n            const _valid = gen.name(\"valid\");\n            const schCxt = cxt.subschema({ keyword: \"oneOf\", schemaProp }, _valid);\n            cxt.mergeEvaluated(schCxt, codegen_1.Name);\n            return _valid;\n        }\n        function getMapping() {\n            var _a;\n            const oneOfMapping = {};\n            const topRequired = hasRequired(parentSchema);\n            let tagRequired = true;\n            for (let i = 0; i < oneOf.length; i++) {\n                let sch = oneOf[i];\n                if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {\n                    sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, sch === null || sch === void 0 ? void 0 : sch.$ref);\n                    if (sch instanceof compile_1.SchemaEnv)\n                        sch = sch.schema;\n                }\n                const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName];\n                if (typeof propSch != \"object\") {\n                    throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have \"properties/${tagName}\"`);\n                }\n                tagRequired = tagRequired && (topRequired || hasRequired(sch));\n                addMappings(propSch, i);\n            }\n            if (!tagRequired)\n                throw new Error(`discriminator: \"${tagName}\" must be required`);\n            return oneOfMapping;\n            function hasRequired({ required }) {\n                return Array.isArray(required) && required.includes(tagName);\n            }\n            function addMappings(sch, i) {\n                if (sch.const) {\n                    addMapping(sch.const, i);\n                }\n                else if (sch.enum) {\n                    for (const tagValue of sch.enum) {\n                        addMapping(tagValue, i);\n                    }\n                }\n                else {\n                    throw new Error(`discriminator: \"properties/${tagName}\" must have \"const\" or \"enum\"`);\n                }\n            }\n            function addMapping(tagValue, i) {\n                if (typeof tagValue != \"string\" || tagValue in oneOfMapping) {\n                    throw new Error(`discriminator: \"${tagName}\" values must be unique strings`);\n                }\n                oneOfMapping[tagValue] = i;\n            }\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DiscrError = void 0;\nvar DiscrError;\n(function (DiscrError) {\n    DiscrError[\"Tag\"] = \"tag\";\n    DiscrError[\"Mapping\"] = \"mapping\";\n})(DiscrError = exports.DiscrError || (exports.DiscrError = {}));\n//# sourceMappingURL=types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst core_1 = require(\"./core\");\nconst validation_1 = require(\"./validation\");\nconst applicator_1 = require(\"./applicator\");\nconst format_1 = require(\"./format\");\nconst metadata_1 = require(\"./metadata\");\nconst draft7Vocabularies = [\n    core_1.default,\n    validation_1.default,\n    (0, applicator_1.default)(),\n    format_1.default,\n    metadata_1.metadataVocabulary,\n    metadata_1.contentVocabulary,\n];\nexports.default = draft7Vocabularies;\n//# sourceMappingURL=draft7.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst error = {\n    message: ({ schemaCode }) => (0, codegen_1.str) `must match format \"${schemaCode}\"`,\n    params: ({ schemaCode }) => (0, codegen_1._) `{format: ${schemaCode}}`,\n};\nconst def = {\n    keyword: \"format\",\n    type: [\"number\", \"string\"],\n    schemaType: \"string\",\n    $data: true,\n    error,\n    code(cxt, ruleType) {\n        const { gen, data, $data, schema, schemaCode, it } = cxt;\n        const { opts, errSchemaPath, schemaEnv, self } = it;\n        if (!opts.validateFormats)\n            return;\n        if ($data)\n            validate$DataFormat();\n        else\n            validateFormat();\n        function validate$DataFormat() {\n            const fmts = gen.scopeValue(\"formats\", {\n                ref: self.formats,\n                code: opts.code.formats,\n            });\n            const fDef = gen.const(\"fDef\", (0, codegen_1._) `${fmts}[${schemaCode}]`);\n            const fType = gen.let(\"fType\");\n            const format = gen.let(\"format\");\n            // TODO simplify\n            gen.if((0, codegen_1._) `typeof ${fDef} == \"object\" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._) `${fDef}.type || \"string\"`).assign(format, (0, codegen_1._) `${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._) `\"string\"`).assign(format, fDef));\n            cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));\n            function unknownFmt() {\n                if (opts.strictSchema === false)\n                    return codegen_1.nil;\n                return (0, codegen_1._) `${schemaCode} && !${format}`;\n            }\n            function invalidFmt() {\n                const callFormat = schemaEnv.$async\n                    ? (0, codegen_1._) `(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`\n                    : (0, codegen_1._) `${format}(${data})`;\n                const validData = (0, codegen_1._) `(typeof ${format} == \"function\" ? ${callFormat} : ${format}.test(${data}))`;\n                return (0, codegen_1._) `${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;\n            }\n        }\n        function validateFormat() {\n            const formatDef = self.formats[schema];\n            if (!formatDef) {\n                unknownFormat();\n                return;\n            }\n            if (formatDef === true)\n                return;\n            const [fmtType, format, fmtRef] = getFormat(formatDef);\n            if (fmtType === ruleType)\n                cxt.pass(validCondition());\n            function unknownFormat() {\n                if (opts.strictSchema === false) {\n                    self.logger.warn(unknownMsg());\n                    return;\n                }\n                throw new Error(unknownMsg());\n                function unknownMsg() {\n                    return `unknown format \"${schema}\" ignored in schema at path \"${errSchemaPath}\"`;\n                }\n            }\n            function getFormat(fmtDef) {\n                const code = fmtDef instanceof RegExp\n                    ? (0, codegen_1.regexpCode)(fmtDef)\n                    : opts.code.formats\n                        ? (0, codegen_1._) `${opts.code.formats}${(0, codegen_1.getProperty)(schema)}`\n                        : undefined;\n                const fmt = gen.scopeValue(\"formats\", { key: schema, ref: fmtDef, code });\n                if (typeof fmtDef == \"object\" && !(fmtDef instanceof RegExp)) {\n                    return [fmtDef.type || \"string\", fmtDef.validate, (0, codegen_1._) `${fmt}.validate`];\n                }\n                return [\"string\", fmtDef, fmt];\n            }\n            function validCondition() {\n                if (typeof formatDef == \"object\" && !(formatDef instanceof RegExp) && formatDef.async) {\n                    if (!schemaEnv.$async)\n                        throw new Error(\"async format in sync schema\");\n                    return (0, codegen_1._) `await ${fmtRef}(${data})`;\n                }\n                return typeof format == \"function\" ? (0, codegen_1._) `${fmtRef}(${data})` : (0, codegen_1._) `${fmtRef}.test(${data})`;\n            }\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=format.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst format_1 = require(\"./format\");\nconst format = [format_1.default];\nexports.default = format;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.contentVocabulary = exports.metadataVocabulary = void 0;\nexports.metadataVocabulary = [\n    \"title\",\n    \"description\",\n    \"default\",\n    \"deprecated\",\n    \"readOnly\",\n    \"writeOnly\",\n    \"examples\",\n];\nexports.contentVocabulary = [\n    \"contentMediaType\",\n    \"contentEncoding\",\n    \"contentSchema\",\n];\n//# sourceMappingURL=metadata.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst equal_1 = require(\"../../runtime/equal\");\nconst error = {\n    message: \"must be equal to constant\",\n    params: ({ schemaCode }) => (0, codegen_1._) `{allowedValue: ${schemaCode}}`,\n};\nconst def = {\n    keyword: \"const\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { gen, data, $data, schemaCode, schema } = cxt;\n        if ($data || (schema && typeof schema == \"object\")) {\n            cxt.fail$data((0, codegen_1._) `!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);\n        }\n        else {\n            cxt.fail((0, codegen_1._) `${schema} !== ${data}`);\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=const.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst equal_1 = require(\"../../runtime/equal\");\nconst error = {\n    message: \"must be equal to one of the allowed values\",\n    params: ({ schemaCode }) => (0, codegen_1._) `{allowedValues: ${schemaCode}}`,\n};\nconst def = {\n    keyword: \"enum\",\n    schemaType: \"array\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { gen, data, $data, schema, schemaCode, it } = cxt;\n        if (!$data && schema.length === 0)\n            throw new Error(\"enum must have non-empty array\");\n        const useLoop = schema.length >= it.opts.loopEnum;\n        let eql;\n        const getEql = () => (eql !== null && eql !== void 0 ? eql : (eql = (0, util_1.useFunc)(gen, equal_1.default)));\n        let valid;\n        if (useLoop || $data) {\n            valid = gen.let(\"valid\");\n            cxt.block$data(valid, loopEnum);\n        }\n        else {\n            /* istanbul ignore if */\n            if (!Array.isArray(schema))\n                throw new Error(\"ajv implementation error\");\n            const vSchema = gen.const(\"vSchema\", schemaCode);\n            valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));\n        }\n        cxt.pass(valid);\n        function loopEnum() {\n            gen.assign(valid, false);\n            gen.forOf(\"v\", schemaCode, (v) => gen.if((0, codegen_1._) `${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));\n        }\n        function equalCode(vSchema, i) {\n            const sch = schema[i];\n            return typeof sch === \"object\" && sch !== null\n                ? (0, codegen_1._) `${getEql()}(${data}, ${vSchema}[${i}])`\n                : (0, codegen_1._) `${data} === ${sch}`;\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=enum.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst limitNumber_1 = require(\"./limitNumber\");\nconst multipleOf_1 = require(\"./multipleOf\");\nconst limitLength_1 = require(\"./limitLength\");\nconst pattern_1 = require(\"./pattern\");\nconst limitProperties_1 = require(\"./limitProperties\");\nconst required_1 = require(\"./required\");\nconst limitItems_1 = require(\"./limitItems\");\nconst uniqueItems_1 = require(\"./uniqueItems\");\nconst const_1 = require(\"./const\");\nconst enum_1 = require(\"./enum\");\nconst validation = [\n    // number\n    limitNumber_1.default,\n    multipleOf_1.default,\n    // string\n    limitLength_1.default,\n    pattern_1.default,\n    // object\n    limitProperties_1.default,\n    required_1.default,\n    // array\n    limitItems_1.default,\n    uniqueItems_1.default,\n    // any\n    { keyword: \"type\", schemaType: [\"string\", \"array\"] },\n    { keyword: \"nullable\", schemaType: \"boolean\" },\n    const_1.default,\n    enum_1.default,\n];\nexports.default = validation;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst error = {\n    message({ keyword, schemaCode }) {\n        const comp = keyword === \"maxItems\" ? \"more\" : \"fewer\";\n        return (0, codegen_1.str) `must NOT have ${comp} than ${schemaCode} items`;\n    },\n    params: ({ schemaCode }) => (0, codegen_1._) `{limit: ${schemaCode}}`,\n};\nconst def = {\n    keyword: [\"maxItems\", \"minItems\"],\n    type: \"array\",\n    schemaType: \"number\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { keyword, data, schemaCode } = cxt;\n        const op = keyword === \"maxItems\" ? codegen_1.operators.GT : codegen_1.operators.LT;\n        cxt.fail$data((0, codegen_1._) `${data}.length ${op} ${schemaCode}`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=limitItems.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst ucs2length_1 = require(\"../../runtime/ucs2length\");\nconst error = {\n    message({ keyword, schemaCode }) {\n        const comp = keyword === \"maxLength\" ? \"more\" : \"fewer\";\n        return (0, codegen_1.str) `must NOT have ${comp} than ${schemaCode} characters`;\n    },\n    params: ({ schemaCode }) => (0, codegen_1._) `{limit: ${schemaCode}}`,\n};\nconst def = {\n    keyword: [\"maxLength\", \"minLength\"],\n    type: \"string\",\n    schemaType: \"number\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { keyword, data, schemaCode, it } = cxt;\n        const op = keyword === \"maxLength\" ? codegen_1.operators.GT : codegen_1.operators.LT;\n        const len = it.opts.unicode === false ? (0, codegen_1._) `${data}.length` : (0, codegen_1._) `${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;\n        cxt.fail$data((0, codegen_1._) `${len} ${op} ${schemaCode}`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=limitLength.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst ops = codegen_1.operators;\nconst KWDs = {\n    maximum: { okStr: \"<=\", ok: ops.LTE, fail: ops.GT },\n    minimum: { okStr: \">=\", ok: ops.GTE, fail: ops.LT },\n    exclusiveMaximum: { okStr: \"<\", ok: ops.LT, fail: ops.GTE },\n    exclusiveMinimum: { okStr: \">\", ok: ops.GT, fail: ops.LTE },\n};\nconst error = {\n    message: ({ keyword, schemaCode }) => (0, codegen_1.str) `must be ${KWDs[keyword].okStr} ${schemaCode}`,\n    params: ({ keyword, schemaCode }) => (0, codegen_1._) `{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,\n};\nconst def = {\n    keyword: Object.keys(KWDs),\n    type: \"number\",\n    schemaType: \"number\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { keyword, data, schemaCode } = cxt;\n        cxt.fail$data((0, codegen_1._) `${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=limitNumber.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst error = {\n    message({ keyword, schemaCode }) {\n        const comp = keyword === \"maxProperties\" ? \"more\" : \"fewer\";\n        return (0, codegen_1.str) `must NOT have ${comp} than ${schemaCode} properties`;\n    },\n    params: ({ schemaCode }) => (0, codegen_1._) `{limit: ${schemaCode}}`,\n};\nconst def = {\n    keyword: [\"maxProperties\", \"minProperties\"],\n    type: \"object\",\n    schemaType: \"number\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { keyword, data, schemaCode } = cxt;\n        const op = keyword === \"maxProperties\" ? codegen_1.operators.GT : codegen_1.operators.LT;\n        cxt.fail$data((0, codegen_1._) `Object.keys(${data}).length ${op} ${schemaCode}`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=limitProperties.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst codegen_1 = require(\"../../compile/codegen\");\nconst error = {\n    message: ({ schemaCode }) => (0, codegen_1.str) `must be multiple of ${schemaCode}`,\n    params: ({ schemaCode }) => (0, codegen_1._) `{multipleOf: ${schemaCode}}`,\n};\nconst def = {\n    keyword: \"multipleOf\",\n    type: \"number\",\n    schemaType: \"number\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { gen, data, schemaCode, it } = cxt;\n        // const bdt = bad$DataType(schemaCode, <string>def.schemaType, $data)\n        const prec = it.opts.multipleOfPrecision;\n        const res = gen.let(\"res\");\n        const invalid = prec\n            ? (0, codegen_1._) `Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}`\n            : (0, codegen_1._) `${res} !== parseInt(${res})`;\n        cxt.fail$data((0, codegen_1._) `(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=multipleOf.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst code_1 = require(\"../code\");\nconst codegen_1 = require(\"../../compile/codegen\");\nconst error = {\n    message: ({ schemaCode }) => (0, codegen_1.str) `must match pattern \"${schemaCode}\"`,\n    params: ({ schemaCode }) => (0, codegen_1._) `{pattern: ${schemaCode}}`,\n};\nconst def = {\n    keyword: \"pattern\",\n    type: \"string\",\n    schemaType: \"string\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { data, $data, schema, schemaCode, it } = cxt;\n        // TODO regexp should be wrapped in try/catchs\n        const u = it.opts.unicodeRegExp ? \"u\" : \"\";\n        const regExp = $data ? (0, codegen_1._) `(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);\n        cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);\n    },\n};\nexports.default = def;\n//# sourceMappingURL=pattern.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst code_1 = require(\"../code\");\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst error = {\n    message: ({ params: { missingProperty } }) => (0, codegen_1.str) `must have required property '${missingProperty}'`,\n    params: ({ params: { missingProperty } }) => (0, codegen_1._) `{missingProperty: ${missingProperty}}`,\n};\nconst def = {\n    keyword: \"required\",\n    type: \"object\",\n    schemaType: \"array\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { gen, schema, schemaCode, data, $data, it } = cxt;\n        const { opts } = it;\n        if (!$data && schema.length === 0)\n            return;\n        const useLoop = schema.length >= opts.loopRequired;\n        if (it.allErrors)\n            allErrorsMode();\n        else\n            exitOnErrorMode();\n        if (opts.strictRequired) {\n            const props = cxt.parentSchema.properties;\n            const { definedProperties } = cxt.it;\n            for (const requiredKey of schema) {\n                if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === undefined && !definedProperties.has(requiredKey)) {\n                    const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;\n                    const msg = `required property \"${requiredKey}\" is not defined at \"${schemaPath}\" (strictRequired)`;\n                    (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);\n                }\n            }\n        }\n        function allErrorsMode() {\n            if (useLoop || $data) {\n                cxt.block$data(codegen_1.nil, loopAllRequired);\n            }\n            else {\n                for (const prop of schema) {\n                    (0, code_1.checkReportMissingProp)(cxt, prop);\n                }\n            }\n        }\n        function exitOnErrorMode() {\n            const missing = gen.let(\"missing\");\n            if (useLoop || $data) {\n                const valid = gen.let(\"valid\", true);\n                cxt.block$data(valid, () => loopUntilMissing(missing, valid));\n                cxt.ok(valid);\n            }\n            else {\n                gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));\n                (0, code_1.reportMissingProp)(cxt, missing);\n                gen.else();\n            }\n        }\n        function loopAllRequired() {\n            gen.forOf(\"prop\", schemaCode, (prop) => {\n                cxt.setParams({ missingProperty: prop });\n                gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());\n            });\n        }\n        function loopUntilMissing(missing, valid) {\n            cxt.setParams({ missingProperty: missing });\n            gen.forOf(missing, schemaCode, () => {\n                gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));\n                gen.if((0, codegen_1.not)(valid), () => {\n                    cxt.error();\n                    gen.break();\n                });\n            }, codegen_1.nil);\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=required.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dataType_1 = require(\"../../compile/validate/dataType\");\nconst codegen_1 = require(\"../../compile/codegen\");\nconst util_1 = require(\"../../compile/util\");\nconst equal_1 = require(\"../../runtime/equal\");\nconst error = {\n    message: ({ params: { i, j } }) => (0, codegen_1.str) `must NOT have duplicate items (items ## ${j} and ${i} are identical)`,\n    params: ({ params: { i, j } }) => (0, codegen_1._) `{i: ${i}, j: ${j}}`,\n};\nconst def = {\n    keyword: \"uniqueItems\",\n    type: \"array\",\n    schemaType: \"boolean\",\n    $data: true,\n    error,\n    code(cxt) {\n        const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;\n        if (!$data && !schema)\n            return;\n        const valid = gen.let(\"valid\");\n        const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];\n        cxt.block$data(valid, validateUniqueItems, (0, codegen_1._) `${schemaCode} === false`);\n        cxt.ok(valid);\n        function validateUniqueItems() {\n            const i = gen.let(\"i\", (0, codegen_1._) `${data}.length`);\n            const j = gen.let(\"j\");\n            cxt.setParams({ i, j });\n            gen.assign(valid, true);\n            gen.if((0, codegen_1._) `${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));\n        }\n        function canOptimize() {\n            return itemTypes.length > 0 && !itemTypes.some((t) => t === \"object\" || t === \"array\");\n        }\n        function loopN(i, j) {\n            const item = gen.name(\"item\");\n            const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);\n            const indices = gen.const(\"indices\", (0, codegen_1._) `{}`);\n            gen.for((0, codegen_1._) `;${i}--;`, () => {\n                gen.let(item, (0, codegen_1._) `${data}[${i}]`);\n                gen.if(wrongType, (0, codegen_1._) `continue`);\n                if (itemTypes.length > 1)\n                    gen.if((0, codegen_1._) `typeof ${item} == \"string\"`, (0, codegen_1._) `${item} += \"_\"`);\n                gen\n                    .if((0, codegen_1._) `typeof ${indices}[${item}] == \"number\"`, () => {\n                    gen.assign(j, (0, codegen_1._) `${indices}[${item}]`);\n                    cxt.error();\n                    gen.assign(valid, false).break();\n                })\n                    .code((0, codegen_1._) `${indices}[${item}] = ${i}`);\n            });\n        }\n        function loopN2(i, j) {\n            const eql = (0, util_1.useFunc)(gen, equal_1.default);\n            const outer = gen.name(\"outer\");\n            gen.label(outer).for((0, codegen_1._) `;${i}--;`, () => gen.for((0, codegen_1._) `${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._) `${eql}(${data}[${i}], ${data}[${j}])`, () => {\n                cxt.error();\n                gen.assign(valid, false).break(outer);\n            })));\n        }\n    },\n};\nexports.default = def;\n//# sourceMappingURL=uniqueItems.js.map"],"sourceRoot":""}