{"version":3,"file":"blitzdiagrams.bundle.js","mappings":"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","sources":["webpack://BlitzDiagrams/webpack/universalModuleDefinition","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/properties.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/dataType.js","webpack://BlitzDiagrams/./node_modules/fast-uri/lib/schemes.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/rules.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/pattern.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/items.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/uniqueItems.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/limitItems.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/if.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/codegen/code.js","webpack://BlitzDiagrams/./node_modules/fast-deep-equal/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/names.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/core/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/contains.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/dependencies.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/ajv.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/multipleOf.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/core/id.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/runtime/validation_error.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/keyword.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/core/ref.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/runtime/ucs2length.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/items2020.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/required.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/core.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/util.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/thenElse.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/limitProperties.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/subschema.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/ref_error.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/format/format.js","webpack://BlitzDiagrams/./node_modules/fast-uri/lib/utils.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/patternProperties.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/prefixItems.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/additionalItems.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/code.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/allOf.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/limitNumber.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/runtime/uri.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/draft7.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/oneOf.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/runtime/equal.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/anyOf.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/discriminator/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/resolve.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/index.js","webpack://BlitzDiagrams/./node_modules/json-schema-traverse/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/limitLength.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/format/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/discriminator/types.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/codegen/scope.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/defaults.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/applicability.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/not.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/const.js","webpack://BlitzDiagrams/./node_modules/fast-uri/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/validation/enum.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/errors.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/validate/boolSchema.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/compile/codegen/index.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/applicator/propertyNames.js","webpack://BlitzDiagrams/./node_modules/ajv/dist/vocabularies/metadata.js","webpack://BlitzDiagrams/webpack/bootstrap","webpack://BlitzDiagrams/webpack/runtime/compat get default export","webpack://BlitzDiagrams/webpack/runtime/define property getters","webpack://BlitzDiagrams/webpack/runtime/hasOwnProperty shorthand","webpack://BlitzDiagrams/./src/core/ComponentRegistry.ts","webpack://BlitzDiagrams/./src/core/EventSystem.ts","webpack://BlitzDiagrams/./src/validation/SchemaValidator.ts","webpack://BlitzDiagrams/./src/core/configResolver.ts","webpack://BlitzDiagrams/./src/core/BlitzDiagram.ts","webpack://BlitzDiagrams/./src/utils/expressionEvaluator.ts","webpack://BlitzDiagrams/./src/core/DiagramComponent.ts","webpack://BlitzDiagrams/./src/components/Diagram.ts","webpack://BlitzDiagrams/./src/components/geometric/Point.ts","webpack://BlitzDiagrams/./src/components/geometric/Square.ts","webpack://BlitzDiagrams/./src/components/interactive/Slider.ts","webpack://BlitzDiagrams/./src/index.ts","webpack://BlitzDiagrams/./src/components/geometric/Line.ts","webpack://BlitzDiagrams/./src/components/geometric/Circle.ts","webpack://BlitzDiagrams/./src/components/geometric/Grid.ts","webpack://BlitzDiagrams/./src/components/geometric/Text.ts","webpack://BlitzDiagrams/./src/components/educational/TenFrame.ts","webpack://BlitzDiagrams/./src/components/educational/Bin.ts","webpack://BlitzDiagrams/./src/components/educational/DraggableDot.ts","webpack://BlitzDiagrams/./src/components/educational/DropBin.ts","webpack://BlitzDiagrams/./src/components/educational/DotPool.ts","webpack://BlitzDiagrams/./src/components/layout/Grid.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"BlitzDiagrams\"] = factory();\n\telse\n\t\troot[\"BlitzDiagrams\"] = factory();\n})(this, () => {\nreturn ","\"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 });\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 = 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;\n// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\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'\n\nconst { isUUID } = require('./utils')\nconst URN_REG = /([\\da-z][\\d\\-a-z]{0,31}):((?:[\\w!$'()*+,\\-.:;=@]|%[\\da-f]{2})+)/iu\n\nconst supportedSchemeNames = /** @type {const} */ (['http', 'https', 'ws',\n  'wss', 'urn', 'urn:uuid'])\n\n/** @typedef {supportedSchemeNames[number]} SchemeName */\n\n/**\n * @param {string} name\n * @returns {name is SchemeName}\n */\nfunction isValidSchemeName (name) {\n  return supportedSchemeNames.indexOf(/** @type {*} */ (name)) !== -1\n}\n\n/**\n * @callback SchemeFn\n * @param {import('../types/index').URIComponent} component\n * @param {import('../types/index').Options} options\n * @returns {import('../types/index').URIComponent}\n */\n\n/**\n * @typedef {Object} SchemeHandler\n * @property {SchemeName} scheme - The scheme name.\n * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.\n * @property {SchemeFn} parse - Function to parse the URI component for this scheme.\n * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.\n * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.\n * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.\n * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.\n */\n\n/**\n * @param {import('../types/index').URIComponent} wsComponent\n * @returns {boolean}\n */\nfunction wsIsSecure (wsComponent) {\n  if (wsComponent.secure === true) {\n    return true\n  } else if (wsComponent.secure === false) {\n    return false\n  } else if (wsComponent.scheme) {\n    return (\n      wsComponent.scheme.length === 3 &&\n      (wsComponent.scheme[0] === 'w' || wsComponent.scheme[0] === 'W') &&\n      (wsComponent.scheme[1] === 's' || wsComponent.scheme[1] === 'S') &&\n      (wsComponent.scheme[2] === 's' || wsComponent.scheme[2] === 'S')\n    )\n  } else {\n    return false\n  }\n}\n\n/** @type {SchemeFn} */\nfunction httpParse (component) {\n  if (!component.host) {\n    component.error = component.error || 'HTTP URIs must have a host.'\n  }\n\n  return component\n}\n\n/** @type {SchemeFn} */\nfunction httpSerialize (component) {\n  const secure = String(component.scheme).toLowerCase() === 'https'\n\n  // normalize the default port\n  if (component.port === (secure ? 443 : 80) || component.port === '') {\n    component.port = undefined\n  }\n\n  // normalize the empty path\n  if (!component.path) {\n    component.path = '/'\n  }\n\n  // NOTE: We do not parse query strings for HTTP URIs\n  // as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n  // and not the HTTP spec.\n\n  return component\n}\n\n/** @type {SchemeFn} */\nfunction wsParse (wsComponent) {\n// indicate if the secure flag is set\n  wsComponent.secure = wsIsSecure(wsComponent)\n\n  // construct resouce name\n  wsComponent.resourceName = (wsComponent.path || '/') + (wsComponent.query ? '?' + wsComponent.query : '')\n  wsComponent.path = undefined\n  wsComponent.query = undefined\n\n  return wsComponent\n}\n\n/** @type {SchemeFn} */\nfunction wsSerialize (wsComponent) {\n// normalize the default port\n  if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === '') {\n    wsComponent.port = undefined\n  }\n\n  // ensure scheme matches secure flag\n  if (typeof wsComponent.secure === 'boolean') {\n    wsComponent.scheme = (wsComponent.secure ? 'wss' : 'ws')\n    wsComponent.secure = undefined\n  }\n\n  // reconstruct path from resource name\n  if (wsComponent.resourceName) {\n    const [path, query] = wsComponent.resourceName.split('?')\n    wsComponent.path = (path && path !== '/' ? path : undefined)\n    wsComponent.query = query\n    wsComponent.resourceName = undefined\n  }\n\n  // forbid fragment component\n  wsComponent.fragment = undefined\n\n  return wsComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnParse (urnComponent, options) {\n  if (!urnComponent.path) {\n    urnComponent.error = 'URN can not be parsed'\n    return urnComponent\n  }\n  const matches = urnComponent.path.match(URN_REG)\n  if (matches) {\n    const scheme = options.scheme || urnComponent.scheme || 'urn'\n    urnComponent.nid = matches[1].toLowerCase()\n    urnComponent.nss = matches[2]\n    const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`\n    const schemeHandler = getSchemeHandler(urnScheme)\n    urnComponent.path = undefined\n\n    if (schemeHandler) {\n      urnComponent = schemeHandler.parse(urnComponent, options)\n    }\n  } else {\n    urnComponent.error = urnComponent.error || 'URN can not be parsed.'\n  }\n\n  return urnComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnSerialize (urnComponent, options) {\n  if (urnComponent.nid === undefined) {\n    throw new Error('URN without nid cannot be serialized')\n  }\n  const scheme = options.scheme || urnComponent.scheme || 'urn'\n  const nid = urnComponent.nid.toLowerCase()\n  const urnScheme = `${scheme}:${options.nid || nid}`\n  const schemeHandler = getSchemeHandler(urnScheme)\n\n  if (schemeHandler) {\n    urnComponent = schemeHandler.serialize(urnComponent, options)\n  }\n\n  const uriComponent = urnComponent\n  const nss = urnComponent.nss\n  uriComponent.path = `${nid || options.nid}:${nss}`\n\n  options.skipEscape = true\n  return uriComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnuuidParse (urnComponent, options) {\n  const uuidComponent = urnComponent\n  uuidComponent.uuid = uuidComponent.nss\n  uuidComponent.nss = undefined\n\n  if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {\n    uuidComponent.error = uuidComponent.error || 'UUID is not valid.'\n  }\n\n  return uuidComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnuuidSerialize (uuidComponent) {\n  const urnComponent = uuidComponent\n  // normalize UUID\n  urnComponent.nss = (uuidComponent.uuid || '').toLowerCase()\n  return urnComponent\n}\n\nconst http = /** @type {SchemeHandler} */ ({\n  scheme: 'http',\n  domainHost: true,\n  parse: httpParse,\n  serialize: httpSerialize\n})\n\nconst https = /** @type {SchemeHandler} */ ({\n  scheme: 'https',\n  domainHost: http.domainHost,\n  parse: httpParse,\n  serialize: httpSerialize\n})\n\nconst ws = /** @type {SchemeHandler} */ ({\n  scheme: 'ws',\n  domainHost: true,\n  parse: wsParse,\n  serialize: wsSerialize\n})\n\nconst wss = /** @type {SchemeHandler} */ ({\n  scheme: 'wss',\n  domainHost: ws.domainHost,\n  parse: ws.parse,\n  serialize: ws.serialize\n})\n\nconst urn = /** @type {SchemeHandler} */ ({\n  scheme: 'urn',\n  parse: urnParse,\n  serialize: urnSerialize,\n  skipNormalize: true\n})\n\nconst urnuuid = /** @type {SchemeHandler} */ ({\n  scheme: 'urn:uuid',\n  parse: urnuuidParse,\n  serialize: urnuuidSerialize,\n  skipNormalize: true\n})\n\nconst SCHEMES = /** @type {Record<SchemeName, SchemeHandler>} */ ({\n  http,\n  https,\n  ws,\n  wss,\n  urn,\n  'urn:uuid': urnuuid\n})\n\nObject.setPrototypeOf(SCHEMES, null)\n\n/**\n * @param {string|undefined} scheme\n * @returns {SchemeHandler|undefined}\n */\nfunction getSchemeHandler (scheme) {\n  return (\n    scheme && (\n      SCHEMES[/** @type {SchemeName} */ (scheme)] ||\n      SCHEMES[/** @type {SchemeName} */(scheme.toLowerCase())])\n  ) ||\n    undefined\n}\n\nmodule.exports = {\n  wsIsSecure,\n  SCHEMES,\n  isValidSchemeName,\n  getSchemeHandler,\n}\n","\"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 });\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 });\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 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","\"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 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 });\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;\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\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';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","\"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\"), // data passed to validation function\n    // args passed from referencing schema\n    valCxt: new codegen_1.Name(\"valCxt\"), // validation/data context - should not be used directly, it is destructured to the names below\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\"), // root data - same as the data passed to the first/top validation function\n    dynamicAnchors: new codegen_1.Name(\"dynamicAnchors\"), // used to support recursiveRef and dynamicRef\n    // function scoped variables\n    vErrors: new codegen_1.Name(\"vErrors\"), // null or array of validation errors\n    errors: new codegen_1.Name(\"errors\"), // counter of validation 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 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.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    narrowSchemaTypes(it, types);\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 narrowSchemaTypes(it, withTypes) {\n    const ts = [];\n    for (const t of it.dataTypes) {\n        if (includesType(withTypes, t))\n            ts.push(t);\n        else if (withTypes.includes(\"integer\") && t === \"number\")\n            ts.push(\"integer\");\n    }\n    it.dataTypes = ts;\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 });\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 });\nexports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = 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}\nexports.Ajv = Ajv;\nmodule.exports = exports = Ajv;\nmodule.exports.Ajv = 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; } });\nvar validation_error_1 = require(\"./runtime/validation_error\");\nObject.defineProperty(exports, \"ValidationError\", { enumerable: true, get: function () { return validation_error_1.default; } });\nvar ref_error_1 = require(\"./compile/ref_error\");\nObject.defineProperty(exports, \"MissingRefError\", { enumerable: true, get: function () { return ref_error_1.default; } });\n//# sourceMappingURL=ajv.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 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 });\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.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.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 });\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], // TODO can its length be used as dataLevel if nil is removed?\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 });\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 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 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 });\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    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\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}\nAjv.ValidationError = validation_error_1.default;\nAjv.MissingRefError = ref_error_1.default;\nexports.default = Ajv;\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 });\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 = 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 });\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 });\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 });\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 });\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 });\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'\n\n/** @type {(value: string) => boolean} */\nconst isUUID = RegExp.prototype.test.bind(/^[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12}$/iu)\n\n/** @type {(value: string) => boolean} */\nconst isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\\d|1\\d{2}|[1-9]\\d|\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d{2}|[1-9]\\d|\\d)$/u)\n\n/**\n * @param {Array<string>} input\n * @returns {string}\n */\nfunction stringArrayToHexStripped (input) {\n  let acc = ''\n  let code = 0\n  let i = 0\n\n  for (i = 0; i < input.length; i++) {\n    code = input[i].charCodeAt(0)\n    if (code === 48) {\n      continue\n    }\n    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {\n      return ''\n    }\n    acc += input[i]\n    break\n  }\n\n  for (i += 1; i < input.length; i++) {\n    code = input[i].charCodeAt(0)\n    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {\n      return ''\n    }\n    acc += input[i]\n  }\n  return acc\n}\n\n/**\n * @typedef {Object} GetIPV6Result\n * @property {boolean} error - Indicates if there was an error parsing the IPv6 address.\n * @property {string} address - The parsed IPv6 address.\n * @property {string} [zone] - The zone identifier, if present.\n */\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nconst nonSimpleDomain = RegExp.prototype.test.bind(/[^!\"$&'()*+,\\-.;=_`a-z{}~]/u)\n\n/**\n * @param {Array<string>} buffer\n * @returns {boolean}\n */\nfunction consumeIsZone (buffer) {\n  buffer.length = 0\n  return true\n}\n\n/**\n * @param {Array<string>} buffer\n * @param {Array<string>} address\n * @param {GetIPV6Result} output\n * @returns {boolean}\n */\nfunction consumeHextets (buffer, address, output) {\n  if (buffer.length) {\n    const hex = stringArrayToHexStripped(buffer)\n    if (hex !== '') {\n      address.push(hex)\n    } else {\n      output.error = true\n      return false\n    }\n    buffer.length = 0\n  }\n  return true\n}\n\n/**\n * @param {string} input\n * @returns {GetIPV6Result}\n */\nfunction getIPV6 (input) {\n  let tokenCount = 0\n  const output = { error: false, address: '', zone: '' }\n  /** @type {Array<string>} */\n  const address = []\n  /** @type {Array<string>} */\n  const buffer = []\n  let endipv6Encountered = false\n  let endIpv6 = false\n\n  let consume = consumeHextets\n\n  for (let i = 0; i < input.length; i++) {\n    const cursor = input[i]\n    if (cursor === '[' || cursor === ']') { continue }\n    if (cursor === ':') {\n      if (endipv6Encountered === true) {\n        endIpv6 = true\n      }\n      if (!consume(buffer, address, output)) { break }\n      if (++tokenCount > 7) {\n        // not valid\n        output.error = true\n        break\n      }\n      if (i > 0 && input[i - 1] === ':') {\n        endipv6Encountered = true\n      }\n      address.push(':')\n      continue\n    } else if (cursor === '%') {\n      if (!consume(buffer, address, output)) { break }\n      // switch to zone detection\n      consume = consumeIsZone\n    } else {\n      buffer.push(cursor)\n      continue\n    }\n  }\n  if (buffer.length) {\n    if (consume === consumeIsZone) {\n      output.zone = buffer.join('')\n    } else if (endIpv6) {\n      address.push(buffer.join(''))\n    } else {\n      address.push(stringArrayToHexStripped(buffer))\n    }\n  }\n  output.address = address.join('')\n  return output\n}\n\n/**\n * @typedef {Object} NormalizeIPv6Result\n * @property {string} host - The normalized host.\n * @property {string} [escapedHost] - The escaped host.\n * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.\n */\n\n/**\n * @param {string} host\n * @returns {NormalizeIPv6Result}\n */\nfunction normalizeIPv6 (host) {\n  if (findToken(host, ':') < 2) { return { host, isIPV6: false } }\n  const ipv6 = getIPV6(host)\n\n  if (!ipv6.error) {\n    let newHost = ipv6.address\n    let escapedHost = ipv6.address\n    if (ipv6.zone) {\n      newHost += '%' + ipv6.zone\n      escapedHost += '%25' + ipv6.zone\n    }\n    return { host: newHost, isIPV6: true, escapedHost }\n  } else {\n    return { host, isIPV6: false }\n  }\n}\n\n/**\n * @param {string} str\n * @param {string} token\n * @returns {number}\n */\nfunction findToken (str, token) {\n  let ind = 0\n  for (let i = 0; i < str.length; i++) {\n    if (str[i] === token) ind++\n  }\n  return ind\n}\n\n/**\n * @param {string} path\n * @returns {string}\n *\n * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4\n */\nfunction removeDotSegments (path) {\n  let input = path\n  const output = []\n  let nextSlash = -1\n  let len = 0\n\n  // eslint-disable-next-line no-cond-assign\n  while (len = input.length) {\n    if (len === 1) {\n      if (input === '.') {\n        break\n      } else if (input === '/') {\n        output.push('/')\n        break\n      } else {\n        output.push(input)\n        break\n      }\n    } else if (len === 2) {\n      if (input[0] === '.') {\n        if (input[1] === '.') {\n          break\n        } else if (input[1] === '/') {\n          input = input.slice(2)\n          continue\n        }\n      } else if (input[0] === '/') {\n        if (input[1] === '.' || input[1] === '/') {\n          output.push('/')\n          break\n        }\n      }\n    } else if (len === 3) {\n      if (input === '/..') {\n        if (output.length !== 0) {\n          output.pop()\n        }\n        output.push('/')\n        break\n      }\n    }\n    if (input[0] === '.') {\n      if (input[1] === '.') {\n        if (input[2] === '/') {\n          input = input.slice(3)\n          continue\n        }\n      } else if (input[1] === '/') {\n        input = input.slice(2)\n        continue\n      }\n    } else if (input[0] === '/') {\n      if (input[1] === '.') {\n        if (input[2] === '/') {\n          input = input.slice(2)\n          continue\n        } else if (input[2] === '.') {\n          if (input[3] === '/') {\n            input = input.slice(3)\n            if (output.length !== 0) {\n              output.pop()\n            }\n            continue\n          }\n        }\n      }\n    }\n\n    // Rule 2E: Move normal path segment to output\n    if ((nextSlash = input.indexOf('/', 1)) === -1) {\n      output.push(input)\n      break\n    } else {\n      output.push(input.slice(0, nextSlash))\n      input = input.slice(nextSlash)\n    }\n  }\n\n  return output.join('')\n}\n\n/**\n * @param {import('../types/index').URIComponent} component\n * @param {boolean} esc\n * @returns {import('../types/index').URIComponent}\n */\nfunction normalizeComponentEncoding (component, esc) {\n  const func = esc !== true ? escape : unescape\n  if (component.scheme !== undefined) {\n    component.scheme = func(component.scheme)\n  }\n  if (component.userinfo !== undefined) {\n    component.userinfo = func(component.userinfo)\n  }\n  if (component.host !== undefined) {\n    component.host = func(component.host)\n  }\n  if (component.path !== undefined) {\n    component.path = func(component.path)\n  }\n  if (component.query !== undefined) {\n    component.query = func(component.query)\n  }\n  if (component.fragment !== undefined) {\n    component.fragment = func(component.fragment)\n  }\n  return component\n}\n\n/**\n * @param {import('../types/index').URIComponent} component\n * @returns {string|undefined}\n */\nfunction recomposeAuthority (component) {\n  const uriTokens = []\n\n  if (component.userinfo !== undefined) {\n    uriTokens.push(component.userinfo)\n    uriTokens.push('@')\n  }\n\n  if (component.host !== undefined) {\n    let host = unescape(component.host)\n    if (!isIPv4(host)) {\n      const ipV6res = normalizeIPv6(host)\n      if (ipV6res.isIPV6 === true) {\n        host = `[${ipV6res.escapedHost}]`\n      } else {\n        host = component.host\n      }\n    }\n    uriTokens.push(host)\n  }\n\n  if (typeof component.port === 'number' || typeof component.port === 'string') {\n    uriTokens.push(':')\n    uriTokens.push(String(component.port))\n  }\n\n  return uriTokens.length ? uriTokens.join('') : undefined\n};\n\nmodule.exports = {\n  nonSimpleDomain,\n  recomposeAuthority,\n  normalizeComponentEncoding,\n  removeDotSegments,\n  isIPv4,\n  isUUID,\n  normalizeIPv6,\n  stringArrayToHexStripped\n}\n","\"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 });\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 });\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 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 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 uri = require(\"fast-uri\");\nuri.code = 'require(\"ajv/dist/runtime/uri\").default';\nexports.default = uri;\n//# sourceMappingURL=uri.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 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 });\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 });\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 });\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 types_1 = require(\"../discriminator/types\");\nconst compile_1 = require(\"../../compile\");\nconst ref_error_1 = require(\"../../compile/ref_error\");\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                    const ref = sch.$ref;\n                    sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);\n                    if (sch instanceof compile_1.SchemaEnv)\n                        sch = sch.schema;\n                    if (sch === undefined)\n                        throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);\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.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 innerBaseId = baseIds[parentJsonPtr];\n        if (typeof sch[schemaId] == \"string\")\n            innerBaseId = addRef.call(this, sch[schemaId]);\n        addAnchor.call(this, sch.$anchor);\n        addAnchor.call(this, sch.$dynamicAnchor);\n        baseIds[jsonPtr] = innerBaseId;\n        function addRef(ref) {\n            // eslint-disable-next-line @typescript-eslint/unbound-method\n            const _resolve = this.opts.uriResolver.resolve;\n            ref = normalizeId(innerBaseId ? _resolve(innerBaseId, 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 });\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';\n\nvar traverse = module.exports = function (schema, opts, cb) {\n  // Legacy support for v0.3.1 and earlier.\n  if (typeof opts == 'function') {\n    cb = opts;\n    opts = {};\n  }\n\n  cb = opts.cb || cb;\n  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};\n  var post = cb.post || function() {};\n\n  _traverse(opts, pre, post, schema, '', schema);\n};\n\n\ntraverse.keywords = {\n  additionalItems: true,\n  items: true,\n  contains: true,\n  additionalProperties: true,\n  propertyNames: true,\n  not: true,\n  if: true,\n  then: true,\n  else: true\n};\n\ntraverse.arrayKeywords = {\n  items: true,\n  allOf: true,\n  anyOf: true,\n  oneOf: true\n};\n\ntraverse.propsKeywords = {\n  $defs: true,\n  definitions: true,\n  properties: true,\n  patternProperties: true,\n  dependencies: true\n};\n\ntraverse.skipKeywords = {\n  default: true,\n  enum: true,\n  const: true,\n  required: true,\n  maximum: true,\n  minimum: true,\n  exclusiveMaximum: true,\n  exclusiveMinimum: true,\n  multipleOf: true,\n  maxLength: true,\n  minLength: true,\n  pattern: true,\n  format: true,\n  maxItems: true,\n  minItems: true,\n  uniqueItems: true,\n  maxProperties: true,\n  minProperties: true\n};\n\n\nfunction _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {\n    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n    for (var key in schema) {\n      var sch = schema[key];\n      if (Array.isArray(sch)) {\n        if (key in traverse.arrayKeywords) {\n          for (var i=0; i<sch.length; i++)\n            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);\n        }\n      } else if (key in traverse.propsKeywords) {\n        if (sch && typeof sch == 'object') {\n          for (var prop in sch)\n            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);\n        }\n      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {\n        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);\n      }\n    }\n    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n  }\n}\n\n\nfunction escapeJsonPtr(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n","\"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 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.DiscrError = void 0;\nvar DiscrError;\n(function (DiscrError) {\n    DiscrError[\"Tag\"] = \"tag\";\n    DiscrError[\"Mapping\"] = \"mapping\";\n})(DiscrError || (exports.DiscrError = DiscrError = {}));\n//# sourceMappingURL=types.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 = 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.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.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 });\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 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'\n\nconst { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require('./lib/utils')\nconst { SCHEMES, getSchemeHandler } = require('./lib/schemes')\n\n/**\n * @template {import('./types/index').URIComponent|string} T\n * @param {T} uri\n * @param {import('./types/index').Options} [options]\n * @returns {T}\n */\nfunction normalize (uri, options) {\n  if (typeof uri === 'string') {\n    uri = /** @type {T} */ (serialize(parse(uri, options), options))\n  } else if (typeof uri === 'object') {\n    uri = /** @type {T} */ (parse(serialize(uri, options), options))\n  }\n  return uri\n}\n\n/**\n * @param {string} baseURI\n * @param {string} relativeURI\n * @param {import('./types/index').Options} [options]\n * @returns {string}\n */\nfunction resolve (baseURI, relativeURI, options) {\n  const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' }\n  const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)\n  schemelessOptions.skipEscape = true\n  return serialize(resolved, schemelessOptions)\n}\n\n/**\n * @param {import ('./types/index').URIComponent} base\n * @param {import ('./types/index').URIComponent} relative\n * @param {import('./types/index').Options} [options]\n * @param {boolean} [skipNormalization=false]\n * @returns {import ('./types/index').URIComponent}\n */\nfunction resolveComponent (base, relative, options, skipNormalization) {\n  /** @type {import('./types/index').URIComponent} */\n  const target = {}\n  if (!skipNormalization) {\n    base = parse(serialize(base, options), options) // normalize base component\n    relative = parse(serialize(relative, options), options) // normalize relative component\n  }\n  options = options || {}\n\n  if (!options.tolerant && relative.scheme) {\n    target.scheme = relative.scheme\n    // target.authority = relative.authority;\n    target.userinfo = relative.userinfo\n    target.host = relative.host\n    target.port = relative.port\n    target.path = removeDotSegments(relative.path || '')\n    target.query = relative.query\n  } else {\n    if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n      // target.authority = relative.authority;\n      target.userinfo = relative.userinfo\n      target.host = relative.host\n      target.port = relative.port\n      target.path = removeDotSegments(relative.path || '')\n      target.query = relative.query\n    } else {\n      if (!relative.path) {\n        target.path = base.path\n        if (relative.query !== undefined) {\n          target.query = relative.query\n        } else {\n          target.query = base.query\n        }\n      } else {\n        if (relative.path[0] === '/') {\n          target.path = removeDotSegments(relative.path)\n        } else {\n          if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n            target.path = '/' + relative.path\n          } else if (!base.path) {\n            target.path = relative.path\n          } else {\n            target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path\n          }\n          target.path = removeDotSegments(target.path)\n        }\n        target.query = relative.query\n      }\n      // target.authority = base.authority;\n      target.userinfo = base.userinfo\n      target.host = base.host\n      target.port = base.port\n    }\n    target.scheme = base.scheme\n  }\n\n  target.fragment = relative.fragment\n\n  return target\n}\n\n/**\n * @param {import ('./types/index').URIComponent|string} uriA\n * @param {import ('./types/index').URIComponent|string} uriB\n * @param {import ('./types/index').Options} options\n * @returns {boolean}\n */\nfunction equal (uriA, uriB, options) {\n  if (typeof uriA === 'string') {\n    uriA = unescape(uriA)\n    uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true })\n  } else if (typeof uriA === 'object') {\n    uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true })\n  }\n\n  if (typeof uriB === 'string') {\n    uriB = unescape(uriB)\n    uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true })\n  } else if (typeof uriB === 'object') {\n    uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true })\n  }\n\n  return uriA.toLowerCase() === uriB.toLowerCase()\n}\n\n/**\n * @param {Readonly<import('./types/index').URIComponent>} cmpts\n * @param {import('./types/index').Options} [opts]\n * @returns {string}\n */\nfunction serialize (cmpts, opts) {\n  const component = {\n    host: cmpts.host,\n    scheme: cmpts.scheme,\n    userinfo: cmpts.userinfo,\n    port: cmpts.port,\n    path: cmpts.path,\n    query: cmpts.query,\n    nid: cmpts.nid,\n    nss: cmpts.nss,\n    uuid: cmpts.uuid,\n    fragment: cmpts.fragment,\n    reference: cmpts.reference,\n    resourceName: cmpts.resourceName,\n    secure: cmpts.secure,\n    error: ''\n  }\n  const options = Object.assign({}, opts)\n  const uriTokens = []\n\n  // find scheme handler\n  const schemeHandler = getSchemeHandler(options.scheme || component.scheme)\n\n  // perform scheme specific serialization\n  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options)\n\n  if (component.path !== undefined) {\n    if (!options.skipEscape) {\n      component.path = escape(component.path)\n\n      if (component.scheme !== undefined) {\n        component.path = component.path.split('%3A').join(':')\n      }\n    } else {\n      component.path = unescape(component.path)\n    }\n  }\n\n  if (options.reference !== 'suffix' && component.scheme) {\n    uriTokens.push(component.scheme, ':')\n  }\n\n  const authority = recomposeAuthority(component)\n  if (authority !== undefined) {\n    if (options.reference !== 'suffix') {\n      uriTokens.push('//')\n    }\n\n    uriTokens.push(authority)\n\n    if (component.path && component.path[0] !== '/') {\n      uriTokens.push('/')\n    }\n  }\n  if (component.path !== undefined) {\n    let s = component.path\n\n    if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n      s = removeDotSegments(s)\n    }\n\n    if (\n      authority === undefined &&\n      s[0] === '/' &&\n      s[1] === '/'\n    ) {\n      // don't allow the path to start with \"//\"\n      s = '/%2F' + s.slice(2)\n    }\n\n    uriTokens.push(s)\n  }\n\n  if (component.query !== undefined) {\n    uriTokens.push('?', component.query)\n  }\n\n  if (component.fragment !== undefined) {\n    uriTokens.push('#', component.fragment)\n  }\n  return uriTokens.join('')\n}\n\nconst URI_PARSE = /^(?:([^#/:?]+):)?(?:\\/\\/((?:([^#/?@]*)@)?(\\[[^#/?\\]]+\\]|[^#/:?]*)(?::(\\d*))?))?([^#?]*)(?:\\?([^#]*))?(?:#((?:.|[\\n\\r])*))?/u\n\n/**\n * @param {string} uri\n * @param {import('./types/index').Options} [opts]\n * @returns\n */\nfunction parse (uri, opts) {\n  const options = Object.assign({}, opts)\n  /** @type {import('./types/index').URIComponent} */\n  const parsed = {\n    scheme: undefined,\n    userinfo: undefined,\n    host: '',\n    port: undefined,\n    path: '',\n    query: undefined,\n    fragment: undefined\n  }\n\n  let isIP = false\n  if (options.reference === 'suffix') {\n    if (options.scheme) {\n      uri = options.scheme + ':' + uri\n    } else {\n      uri = '//' + uri\n    }\n  }\n\n  const matches = uri.match(URI_PARSE)\n\n  if (matches) {\n    // store each component\n    parsed.scheme = matches[1]\n    parsed.userinfo = matches[3]\n    parsed.host = matches[4]\n    parsed.port = parseInt(matches[5], 10)\n    parsed.path = matches[6] || ''\n    parsed.query = matches[7]\n    parsed.fragment = matches[8]\n\n    // fix port number\n    if (isNaN(parsed.port)) {\n      parsed.port = matches[5]\n    }\n    if (parsed.host) {\n      const ipv4result = isIPv4(parsed.host)\n      if (ipv4result === false) {\n        const ipv6result = normalizeIPv6(parsed.host)\n        parsed.host = ipv6result.host.toLowerCase()\n        isIP = ipv6result.isIPV6\n      } else {\n        isIP = true\n      }\n    }\n    if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {\n      parsed.reference = 'same-document'\n    } else if (parsed.scheme === undefined) {\n      parsed.reference = 'relative'\n    } else if (parsed.fragment === undefined) {\n      parsed.reference = 'absolute'\n    } else {\n      parsed.reference = 'uri'\n    }\n\n    // check for reference errors\n    if (options.reference && options.reference !== 'suffix' && options.reference !== parsed.reference) {\n      parsed.error = parsed.error || 'URI is not a ' + options.reference + ' reference.'\n    }\n\n    // find scheme handler\n    const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme)\n\n    // check if scheme can't handle IRIs\n    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n      // if host component is a domain name\n      if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && isIP === false && nonSimpleDomain(parsed.host)) {\n        // convert Unicode IDN -> ASCII IDN\n        try {\n          parsed.host = URL.domainToASCII(parsed.host.toLowerCase())\n        } catch (e) {\n          parsed.error = parsed.error || \"Host's domain name can not be converted to ASCII: \" + e\n        }\n      }\n      // convert IRI -> URI\n    }\n\n    if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {\n      if (uri.indexOf('%') !== -1) {\n        if (parsed.scheme !== undefined) {\n          parsed.scheme = unescape(parsed.scheme)\n        }\n        if (parsed.host !== undefined) {\n          parsed.host = unescape(parsed.host)\n        }\n      }\n      if (parsed.path) {\n        parsed.path = escape(unescape(parsed.path))\n      }\n      if (parsed.fragment) {\n        parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment))\n      }\n    }\n\n    // perform scheme specific parsing\n    if (schemeHandler && schemeHandler.parse) {\n      schemeHandler.parse(parsed, options)\n    }\n  } else {\n    parsed.error = parsed.error || 'URI can not be parsed.'\n  }\n  return parsed\n}\n\nconst fastUri = {\n  SCHEMES,\n  normalize,\n  resolve,\n  resolveComponent,\n  equal,\n  serialize,\n  parse\n}\n\nmodule.exports = fastUri\nmodule.exports.default = fastUri\nmodule.exports.fastUri = fastUri\n","\"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 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 });\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\"), // also used in JTD errors\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.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.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 });\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 });\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","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import type { Variables, ComponentConstructor, BaseComponentConfig, JXGBoard } from '../types/interfaces';\nimport { DiagramComponent } from './DiagramComponent';\n\n/**\n * Registry for component type -> class mapping\n * Allows declarative instantiation from JSON\n */\nclass ComponentRegistry {\n  components: Map<string, ComponentConstructor>;\n\n  constructor() {\n    this.components = new Map();\n  }\n\n  /**\n   * Register a component class\n   */\n  register(type: string, componentClass: ComponentConstructor): void {\n    this.components.set(type, componentClass);\n  }\n\n  /**\n   * Create component instance from config\n   */\n  create(config: BaseComponentConfig, board: JXGBoard, parentState: Variables = {}): DiagramComponent | null {\n    const ComponentClass = this.components.get(config.type);\n\n    if (!ComponentClass) {\n      console.warn(`Unknown component type: ${config.type}`);\n      return null;\n    }\n\n    return new ComponentClass(config, board, parentState) as DiagramComponent;\n  }\n\n  /**\n   * Check if type is registered\n   */\n  has(type: string): boolean {\n    return this.components.has(type);\n  }\n\n  /**\n   * Get component class by type\n   */\n  get(type: string): ComponentConstructor | undefined {\n    return this.components.get(type);\n  }\n\n  /**\n   * Get all registered types\n   */\n  getTypes(): string[] {\n    return Array.from(this.components.keys());\n  }\n}\n\n// Singleton instance\nexport const componentRegistry = new ComponentRegistry();\n\n// Export class for testing\nexport { ComponentRegistry };\n","import { DiagramComponent } from './DiagramComponent';\n\n/**\n * Event for diagram interactions\n */\nexport class DiagramEvent {\n  type: string;\n  detail: Record<string, any>;\n  source: DiagramComponent;\n  consumed: boolean;\n  timestamp: number;\n\n  constructor(type: string, detail: Record<string, any>, source: DiagramComponent) {\n    this.type = type;\n    this.detail = detail;\n    this.source = source;\n    this.consumed = false;\n    this.timestamp = Date.now();\n  }\n\n  /**\n   * Stop event propagation\n   */\n  consume(): void {\n    this.consumed = true;\n  }\n\n  /**\n   * Check if event was consumed\n   */\n  isConsumed(): boolean {\n    return this.consumed;\n  }\n}\n\n/**\n * Event system for component interaction\n * Implements DOM-style event bubbling with consumption\n */\nexport class EventSystem {\n  private listeners: Map<string, Set<(event: DiagramEvent) => void>>;\n\n  constructor() {\n    this.listeners = new Map();\n  }\n\n  /**\n   * Add event listener\n   */\n  on(type: string, handler: (event: DiagramEvent) => void): void {\n    if (!this.listeners.has(type)) {\n      this.listeners.set(type, new Set());\n    }\n    this.listeners.get(type)!.add(handler);\n  }\n\n  /**\n   * Remove event listener\n   */\n  off(type: string, handler: (event: DiagramEvent) => void): void {\n    const handlers = this.listeners.get(type);\n    if (handlers) {\n      handlers.delete(handler);\n    }\n  }\n\n  /**\n   * Emit event with bubbling\n   */\n  emit(event: DiagramEvent, bubblePath: DiagramComponent[]): void {\n    for (const component of bubblePath) {\n      // Offer event to component\n      const consumed = component.handleEvent(event);\n\n      if (consumed || event.isConsumed()) {\n        break; // Stop bubbling\n      }\n    }\n\n    // Fire global listeners (even if consumed)\n    const handlers = this.listeners.get(event.type);\n    if (handlers) {\n      handlers.forEach(handler => handler(event));\n    }\n  }\n\n  /**\n   * Create event from user interaction\n   */\n  createEvent(type: string, detail: Record<string, any>, source: DiagramComponent): DiagramEvent {\n    return new DiagramEvent(type, detail, source);\n  }\n\n  /**\n   * Clear all listeners\n   */\n  clear(): void {\n    this.listeners.clear();\n  }\n}\n","import Ajv, { ErrorObject, ValidateFunction } from 'ajv';\nimport type { DiagramConfig } from '../types/interfaces';\n\n// Import all schemas\nimport diagramSchema from '../schemas/diagram.schema.json';\nimport tenframeSchema from '../schemas/components/tenframe.schema.json';\nimport sliderSchema from '../schemas/components/slider.schema.json';\nimport gridlayoutSchema from '../schemas/components/gridlayout.schema.json';\nimport textSchema from '../schemas/components/text.schema.json';\nimport pointSchema from '../schemas/components/point.schema.json';\nimport lineSchema from '../schemas/components/line.schema.json';\nimport circleSchema from '../schemas/components/circle.schema.json';\nimport squareSchema from '../schemas/components/square.schema.json';\nimport binSchema from '../schemas/components/bin.schema.json';\nimport dotpoolSchema from '../schemas/components/dotpool.schema.json';\n\nexport interface ValidationError {\n  path: string;\n  message: string;\n  keyword?: string;\n  params?: Record<string, any>;\n}\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors?: ValidationError[];\n}\n\n/**\n * Schema validator for BlitzDiagram configurations\n * Uses JSON Schema to validate diagram structure before instantiation\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private validateDiagram: ValidateFunction;\n\n  constructor() {\n    // Initialize AJV with strict mode\n    this.ajv = new Ajv({\n      allErrors: true,\n      verbose: true,\n      strict: true,\n      strictSchema: true,\n      allowUnionTypes: true\n    });\n\n    // Register all component schemas\n    this.ajv.addSchema(tenframeSchema);\n    this.ajv.addSchema(sliderSchema);\n    this.ajv.addSchema(gridlayoutSchema);\n    this.ajv.addSchema(textSchema);\n    this.ajv.addSchema(pointSchema);\n    this.ajv.addSchema(lineSchema);\n    this.ajv.addSchema(circleSchema);\n    this.ajv.addSchema(squareSchema);\n    this.ajv.addSchema(binSchema);\n    this.ajv.addSchema(dotpoolSchema);\n\n    // Compile main diagram schema\n    this.validateDiagram = this.ajv.compile(diagramSchema);\n  }\n\n  /**\n   * Validate a diagram configuration\n   * @param config - The diagram configuration to validate\n   * @returns Validation result with errors if invalid\n   */\n  validate(config: unknown): ValidationResult {\n    const valid = this.validateDiagram(config);\n    \n    if (!valid && this.validateDiagram.errors) {\n      const errors = this.formatErrors(this.validateDiagram.errors);\n      return { valid: false, errors };\n    }\n\n    return { valid: true };\n  }\n\n  /**\n   * Validate and throw if invalid\n   * @param config - The diagram configuration to validate\n   * @throws {ValidationException} if validation fails\n   */\n  validateOrThrow(config: unknown): asserts config is DiagramConfig {\n    const result = this.validate(config);\n    \n    if (!result.valid) {\n      const errorMessages = result.errors!\n        .map(e => `${e.path}: ${e.message}`)\n        .join('\\n');\n      \n      throw new ValidationException(\n        `Diagram validation failed:\\n${errorMessages}`,\n        result.errors!\n      );\n    }\n  }\n\n  /**\n   * Format AJV errors into a more readable structure\n   */\n  private formatErrors(errors: ErrorObject[]): ValidationError[] {\n    return errors.map(error => ({\n      path: error.instancePath || '/',\n      message: error.message || 'Validation failed',\n      keyword: error.keyword,\n      params: error.params\n    }));\n  }\n\n  /**\n   * Get human-readable error message\n   */\n  getErrorMessage(result: ValidationResult): string {\n    if (result.valid) {\n      return 'Validation passed';\n    }\n\n    return result.errors!\n      .map(e => `  • ${e.path || 'root'}: ${e.message}`)\n      .join('\\n');\n  }\n}\n\n/**\n * Custom exception for validation errors\n */\nexport class ValidationException extends Error {\n  constructor(\n    message: string,\n    public readonly errors: ValidationError[]\n  ) {\n    super(message);\n    this.name = 'ValidationException';\n    Object.setPrototypeOf(this, ValidationException.prototype);\n  }\n}\n\n// Export singleton instance\nexport const schemaValidator: SchemaValidator = new SchemaValidator();\n","import type {\n  DiagramConfig,\n  GridLayoutConfig,\n  ItemConfig,\n  ResolvedDiagramConfig,\n  ResolvedItemConfig,\n} from '../types/interfaces';\n\nfunction isGridLayoutConfig(config: ItemConfig): config is GridLayoutConfig {\n  return config.type === 'gridlayout';\n}\n\nfunction makeInstanceId(baseId: string, occurrencePath: string): string {\n  return `${baseId}__${occurrencePath.replace(/[^a-zA-Z0-9_-]+/g, '_')}`;\n}\n\nexport function resolveDiagramConfig(config: DiagramConfig): ResolvedDiagramConfig {\n  const rootName = config.root;\n  const items = config.items;\n\n  if (!rootName) {\n    throw new Error('Diagram config requires root');\n  }\n\n  if (!items || typeof items !== 'object') {\n    throw new Error('Diagram config requires items');\n  }\n\n  const resolving = new Set<string>();\n  const resolveItem = (itemName: string, occurrencePath: string): ResolvedItemConfig => {\n    const itemConfig = items[itemName];\n    if (!itemConfig) {\n      throw new Error(`Unknown item reference: ${itemName}`);\n    }\n\n    if (resolving.has(itemName)) {\n      throw new Error(`Circular item reference detected at \"${itemName}\"`);\n    }\n\n    resolving.add(itemName);\n\n    try {\n      const baseId = itemConfig.id ?? itemName;\n      const instanceId = makeInstanceId(baseId, occurrencePath);\n\n      if (!isGridLayoutConfig(itemConfig)) {\n        return {\n          ...itemConfig,\n          id: instanceId,\n        };\n      }\n\n      const cells = itemConfig.cells;\n      if (!Array.isArray(cells) || cells.length === 0) {\n        throw new Error(`Grid item \"${itemName}\" requires non-empty cells`);\n      }\n\n      const columnCount = Array.isArray(cells[0]) ? cells[0].length : 0;\n      if (columnCount < 1) {\n        throw new Error(`Grid item \"${itemName}\" requires at least one column`);\n      }\n\n      const children: ResolvedItemConfig[] = [];\n      for (const [rowIndex, row] of cells.entries()) {\n        if (!Array.isArray(row) || row.length !== columnCount) {\n          throw new Error(`Grid item \"${itemName}\" must use a rectangular cells matrix`);\n        }\n\n        for (const [columnIndex, childRef] of row.entries()) {\n          if (typeof childRef !== 'string' || childRef.trim() === '') {\n            throw new Error(`Grid item \"${itemName}\" contains an invalid cell reference`);\n          }\n          children.push(\n            resolveItem(\n              childRef,\n              `${occurrencePath}_r${rowIndex}_c${columnIndex}_${childRef}`,\n            ),\n          );\n        }\n      }\n\n      return {\n        ...itemConfig,\n        id: instanceId,\n        rowandcolumns: [cells.length, columnCount],\n        children,\n      };\n    } finally {\n      resolving.delete(itemName);\n    }\n  };\n\n  const rootItem = items[rootName];\n  if (!rootItem) {\n    throw new Error(`Unknown root item: ${rootName}`);\n  }\n  if (!isGridLayoutConfig(rootItem)) {\n    throw new Error(`Root item \"${rootName}\" must be a gridlayout`);\n  }\n\n  const resolvedRoot = resolveItem(rootName, `root_${rootName}`);\n  if (resolvedRoot.type !== 'gridlayout') {\n    throw new Error(`Root item \"${rootName}\" must resolve to a gridlayout`);\n  }\n\n  return {\n    ...config,\n    components: [resolvedRoot],\n  };\n}","import { componentRegistry } from './ComponentRegistry';\nimport { EventSystem } from './EventSystem';\nimport { DiagramComponent, DiagramEventData } from './DiagramComponent';\nimport { schemaValidator } from '../validation/SchemaValidator';\nimport { resolveDiagramConfig } from './configResolver';\nimport type {\n  Variables,\n  JXGBoard,\n  DiagramConfig,\n  ResolvedDiagramConfig,\n  ResolvedItemConfig,\n} from '../types/interfaces';\n\n// Declare global JXG for JSXGraph\ndeclare const JXG: {\n  JSXGraph: {\n    initBoard(containerId: string, options: object): JXGBoard;\n    freeBoard(board: JXGBoard): void;\n  };\n  COORDS_BY_SCREEN: number;\n  Coords: new (type: number, pos: number[], board: JXGBoard) => {\n    usrCoords: number[];\n  };\n};\n\n/** Canvas configuration */\ninterface CanvasConfig {\n  width?: number;\n  height?: number;\n  boundingbox?: [number, number, number, number];\n}\n\n/** Extended diagram configuration with canvas */\ninterface BlitzDiagramConfig extends DiagramConfig {\n  canvas?: CanvasConfig;\n  showAxes?: boolean;\n  variables?: Variables;\n  debug?: boolean;\n}\n\n/**\n * BlitzDiagram Web Component\n * Custom HTML element that renders declarative JSON as interactive diagram\n */\nexport class BlitzDiagram extends HTMLElement {\n  board: JXGBoard | null = null;\n  rootComponent: DiagramComponent | null = null;\n  eventSystem: EventSystem;\n  variables: Variables = {};\n  debug: boolean = false;\n\n  constructor() {\n    super();\n    this.eventSystem = new EventSystem();\n    this._ensureGlobalStyles();\n  }\n\n  /**\n   * Called when element is added to DOM\n   */\n  connectedCallback(): void {\n    // Defer initialization to allow innerHTML to be fully parsed\n    // This is necessary when diagrams are inserted via innerHTML or template rendering\n    setTimeout(() => {\n      try {\n        const config = this._getConfig();\n        this.debug = config.debug === true;\n        if (this.debug) {\n          console.log('[BlitzDiagram] Initializing with config:', config);\n        }\n        this._initialize(config);\n      } catch (error) {\n        console.error('Failed to initialize diagram:', error);\n        this._showError((error as Error).message);\n      }\n    }, 0);\n  }\n\n  /**\n   * Called when element is removed from DOM\n   */\n  disconnectedCallback(): void {\n    this._cleanup();\n  }\n\n  /**\n   * Initialize diagram from config\n   * @param config - Diagram configuration\n   */\n  private _initialize(config: BlitzDiagramConfig): void {\n    const runtimeConfig = resolveDiagramConfig(config);\n\n    // Create container div\n    const container = document.createElement('div');\n    container.id = this._generateId();\n    container.style.width = '100%';\n    container.style.height = '100%';\n    this.appendChild(container);\n\n    // Get canvas configuration\n    const canvas = runtimeConfig.canvas || {\n      width: 800,\n      height: 600,\n      boundingbox: [-10, 10, 10, -10] as [number, number, number, number],\n    };\n\n    // Initialize JSXGraph board\n    this.board = JXG.JSXGraph.initBoard(container.id, {\n      boundingbox: canvas.boundingbox,\n      axis: runtimeConfig.showAxes !== false,\n      showCopyright: false,\n      showNavigation: false,\n      keepaspectratio: true,  // Maintain aspect ratio - prevents distortion\n      pan: { \n        enabled: false  // Disable board panning to allow object dragging\n      },\n      zoom: { enabled: false },\n    });\n\n    // Set initial variables\n    this.variables = runtimeConfig.variables || {};\n\n    // Create root component (diagram itself is a component)\n    this.rootComponent = this._createComponentTree(\n      { ...runtimeConfig, type: runtimeConfig.type || 'diagram' },\n      this.variables\n    );\n\n    // Render\n    if (this.rootComponent) {\n      this.rootComponent.render();\n    }\n\n    // DON'T call board.update() here - it suspends isDraggable on movable points\n    // Each component that needs update will call it individually\n\n    // Emit ready event\n    this.dispatchEvent(new CustomEvent('diagram-ready', {\n      detail: { board: this.board }\n    }));\n  }\n\n  /**\n   * Inject global styles used by the interactive diagram once per document\n   */\n  private _ensureGlobalStyles(): void {\n    if (typeof document === 'undefined') {\n      return;\n    }\n\n    if (document.getElementById('blitz-diagram-styles')) {\n      return;\n    }\n\n    const style = document.createElement('style');\n    style.id = 'blitz-diagram-styles';\n    style.textContent = `\n      blitz-diagram .jxg-text-no-pointer,\n      blitz-diagram .jxg-grid-line,\n      blitz-diagram .jxg-grid-point {\n        pointer-events: none !important;\n      }\n    `;\n    document.head?.appendChild(style);\n  }\n\n  /**\n   * Create component tree from config\n   * @param config - Component configuration\n   * @param state - Initial state\n   * @returns Created component or null\n   */\n  private _createComponentTree(config: ResolvedDiagramConfig | ResolvedItemConfig, state: Variables): DiagramComponent | null {\n    if (!this.board) return null;\n    \n    const component = componentRegistry.create(config, this.board, state);\n    \n    if (!component) {\n      return null;\n    }\n\n    // Pass debug flag to component\n    component.debug = this.debug;\n    \n    if (this.debug) {\n      console.log('[BlitzDiagram] Created component:', component.type, component.id, 'config:', config);\n    }\n\n    // Setup event propagation\n    component.onEvent = (event: DiagramEventData) => {\n      this._handleComponentEvent(event);\n    };\n\n    // Create children\n    const configWithComponents = config as ResolvedDiagramConfig;\n    if (configWithComponents.components) {\n      configWithComponents.components.forEach(childConfig => {\n        const child = this._createComponentTree(childConfig, component.getState());\n        if (child) {\n          component.addChild(child);\n        }\n      });\n    }\n\n    return component;\n  }\n\n  /**\n   * Setup JSXGraph board event handlers\n   * Note: Currently disabled as they interfere with JSXGraph native dragging\n   */\n  private _setupBoardEvents(): void {\n    if (!this.board) return;\n    \n    // Mouse down - initiate hit testing\n    this.board.on('down', (evt: Event) => {\n      const coords = this._getCoords(evt);\n      if (this.debug) {\n        console.log('[Board] down at', coords);\n      }\n      this._handleBoardEvent('mousedown', coords);\n    });\n\n    // Mouse move - for hover, drag\n    this.board.on('move', (evt: Event) => {\n      const coords = this._getCoords(evt);\n      if (this.debug) {\n        console.log('[Board] move at', coords);\n      }\n      this._handleBoardEvent('mousemove', coords);\n    });\n\n    // Mouse up - end drag, click\n    this.board.on('up', (evt: Event) => {\n      const coords = this._getCoords(evt);\n      if (this.debug) {\n        console.log('[Board] up at', coords);\n      }\n      this._handleBoardEvent('mouseup', coords);\n    });\n  }\n\n  /**\n   * Handle board-level event (mouse, touch)\n   * @param type - Event type\n   * @param coords - Coordinates in board space\n   */\n  private _handleBoardEvent(type: string, coords: { x: number; y: number }): void {\n    // Hit test to find target component\n    const target = this._hitTest(coords.x, coords.y);\n    \n    if (target) {\n      const event = this.eventSystem.createEvent(type, coords, target);\n      \n      // Build bubble path from target to root\n      const bubblePath = this._buildBubblePath(target);\n      \n      // Emit with bubbling\n      this.eventSystem.emit(event, bubblePath);\n    }\n  }\n\n  /**\n   * Handle component event\n   * @param event - Event data\n   */\n  private _handleComponentEvent(event: DiagramEventData): void {\n    if (this.debug) {\n      console.log('[BlitzDiagram] Component event:', event.type, event.detail);\n    }\n\n    // Re-emit as custom DOM event\n    this.dispatchEvent(new CustomEvent(event.type, {\n      detail: event.detail,\n      bubbles: true,\n    }));\n\n    // Handle special events\n    if (event.type === 'variable-change') {\n      if (this.debug) {\n        console.log('[BlitzDiagram] Variable change:', event.detail.name, '=', event.detail.value);\n      }\n      this.variables[event.detail.name] = event.detail.value;\n      \n      // Update all components to reflect variable change\n      if (this.rootComponent) {\n        if (this.debug) {\n          console.log('[BlitzDiagram] Updating component tree');\n        }\n        this._updateComponentTree(this.rootComponent);\n      }\n    }\n  }\n\n  /**\n   * Recursively update component tree with new variables\n   * @param component - Component to update\n   */\n  private _updateComponentTree(component: DiagramComponent): void {\n    if (this.debug) {\n      console.log('[BlitzDiagram] Updating component:', component.type, component.id);\n    }\n    \n    // Pass debug flag to component\n    component.debug = this.debug;\n    \n    // Update component with new state\n    component.parentState = this.variables;\n    \n    // Avoid destroying/recreating:\n    // - Top-level container (diagram/2d/3d)\n    // - Interactive elements that manage their own state (slider)\n    // All other components (tenframe, text, gridlayout, etc.) should update\n    if (!['diagram', '2d', '3d', 'slider'].includes(component.type)) {\n      component.update(this.variables);\n    }\n    \n    // Update children (but gridlayout already updates its own children)\n    if (component.type !== 'gridlayout') {\n      component.children.forEach(child => this._updateComponentTree(child));\n    }\n  }\n\n  /**\n   * Hit test - find most specific component at (x, y)\n   * @param x - X coordinate\n   * @param y - Y coordinate\n   * @returns Most specific component at coordinates or null\n   */\n  private _hitTest(x: number, y: number): DiagramComponent | null {\n    const hits: DiagramComponent[] = [];\n    \n    const testComponent = (component: DiagramComponent): void => {\n      if (component.hitTest(x, y)) {\n        hits.push(component);\n      }\n      component.children.forEach(child => testComponent(child));\n    };\n\n    if (this.rootComponent) {\n      testComponent(this.rootComponent);\n    }\n\n    // Sort by specificity (highest first)\n    hits.sort((a, b) => b.getSpecificity() - a.getSpecificity());\n\n    return hits[0] || null;\n  }\n\n  /**\n   * Build bubble path from component to root\n   * @param component - Starting component\n   * @returns Array of components from target to root\n   */\n  private _buildBubblePath(component: DiagramComponent): DiagramComponent[] {\n    const path: DiagramComponent[] = [component];\n    \n    // Walk up tree (simplified - would need parent references)\n    // For now, just return target + root\n    if (this.rootComponent && component !== this.rootComponent) {\n      path.push(this.rootComponent);\n    }\n\n    return path;\n  }\n\n  /**\n   * Get board coordinates from mouse event\n   * @param evt - Mouse/touch event\n   * @returns Coordinates in board space\n   */\n  private _getCoords(evt: Event): { x: number; y: number } {\n    if (!this.board) return { x: 0, y: 0 };\n    \n    const pos = (this.board as any).getMousePosition(evt);\n    const coords = new JXG.Coords(JXG.COORDS_BY_SCREEN, pos, this.board);\n    return {\n      x: coords.usrCoords[1],\n      y: coords.usrCoords[2],\n    };\n  }\n\n  /**\n   * Get configuration from data attribute or child script tag\n   * @returns Parsed configuration\n   */\n  private _getConfig(): BlitzDiagramConfig {\n    let config: any;\n\n    // Try data-config attribute\n    const dataConfig = this.getAttribute('data-config');\n    if (dataConfig) {\n      // Some template/rendering layers can double curly braces (\"{\" -> \"{{\"}).\n      // Normalize by collapsing any doubled braces before parsing as JSON.\n      const normalizedConfig = dataConfig.replace(/{{/g, '{').replace(/}}/g, '}');\n\n      try {\n        config = JSON.parse(normalizedConfig);\n      } catch (e) {\n        console.error('[BlitzDiagram] data-config parse failed:', e);\n        console.error('[BlitzDiagram] Full value:', dataConfig);\n        console.error('[BlitzDiagram] Normalized value:', normalizedConfig);\n        throw e;\n      }\n    } else {\n      // Try script tag child\n      const script = this.querySelector('script[type=\"application/json\"]');\n      if (script) {\n        const jsonText = script.textContent || '{}';\n        try {\n          config = JSON.parse(jsonText);\n        } catch (e) {\n          console.error('[BlitzDiagram] JSON parse failed:', e);\n          console.error('[BlitzDiagram] Full JSON:', jsonText);\n          throw e;\n        }\n      } else {\n        throw new Error('No configuration found (data-config or script tag)');\n      }\n    }\n\n    // Validate schema before returning\n    try {\n      schemaValidator.validateOrThrow(config);\n      // After validation, config is guaranteed to match BlitzDiagramConfig\n      return config;\n    } catch (error) {\n      console.error('[BlitzDiagram] Schema validation failed:', error);\n      throw new Error(`Invalid diagram configuration: ${(error as Error).message}`);\n    }\n  }\n\n  /**\n   * Cleanup resources\n   */\n  private _cleanup(): void {\n    if (this.rootComponent) {\n      this.rootComponent.destroy();\n      this.rootComponent = null;\n    }\n\n    if (this.board) {\n      JXG.JSXGraph.freeBoard(this.board);\n      this.board = null;\n    }\n\n    this.eventSystem.clear();\n  }\n\n  /**\n   * Show error message\n   * @param message - Error message to display\n   */\n  private _showError(message: string): void {\n    this.innerHTML = `\n      <div style=\"padding: 20px; background: #fee; border: 1px solid #c00; border-radius: 4px;\">\n        <strong>Error loading diagram:</strong><br>\n        ${message}\n      </div>\n    `;\n  }\n\n  /**\n   * Generate unique ID\n   * @returns Generated ID\n   */\n  private _generateId(): string {\n    return `diagram_${Math.random().toString(36).substr(2, 9)}`;\n  }\n\n  // Public API\n\n  /**\n   * Get variable value\n   * @param name - Variable name\n   * @returns Variable value\n   */\n  getVariable(name: string): string | number | boolean | undefined {\n    return this.variables[name];\n  }\n\n  /**\n   * Get multiple variables\n   * @param names - Variable names\n   * @returns Object with requested variables\n   */\n  getVariables(names: string[]): Variables {\n    const result: Variables = {};\n    names.forEach(name => {\n      result[name] = this.variables[name];\n    });\n    return result;\n  }\n\n  /**\n   * Set variable value\n   * @param name - Variable name\n   * @param value - Variable value\n   */\n  setVariable(name: string, value: string | number | boolean): void {\n    this.variables[name] = value;\n    if (this.rootComponent) {\n      this.rootComponent.setVariable(name, value);\n    }\n  }\n\n  /**\n   * Get current diagram state\n   * @returns Current state with variables\n   */\n  getState(): { variables: Variables } {\n    return {\n      variables: { ...this.variables },\n    };\n  }\n}\n\n// Note: Custom element registration happens in index.js after all component registrations\n","/**\n * Safe expression evaluator for ${variable} syntax\n * Supports basic math and comparisons without eval()\n */\n\nimport type { Variables } from '../types/interfaces';\n\nconst ALLOWED_OPERATORS: string[] = ['+', '-', '*', '/', '%', '>', '<', '>=', '<=', '==', '!=', '&&', '||', '!'];\nconst ALLOWED_FUNCTIONS: string[] = ['Math.min', 'Math.max', 'Math.abs', 'Math.floor', 'Math.ceil', 'Math.round', 'Math.sqrt'];\nconst ALLOWED_METHODS: string[] = ['toFixed', 'toPrecision', 'toExponential', 'toString'];\n\n/** Math functions available in expressions */\ninterface MathFunctions {\n  min: typeof Math.min;\n  max: typeof Math.max;\n  abs: typeof Math.abs;\n  floor: typeof Math.floor;\n  ceil: typeof Math.ceil;\n  round: typeof Math.round;\n  sqrt: typeof Math.sqrt;\n}\n\n/** Result of expression validation */\nexport interface ValidationResult {\n  valid: boolean;\n  error: string | null;\n}\n\n/**\n * Evaluate template expression like \"${x + y}\"\n * @param template - Template string\n * @param context - Variable values\n * @returns Evaluated result\n */\nexport function evaluateExpression(template: string | number | boolean, context: Variables): string | number | boolean {\n  if (typeof template !== 'string') {\n    return template;\n  }\n\n  // If the entire template is just a single expression, return the raw value (preserving type)\n  const singleExprMatch = /^\\$\\{([^}]+)\\}$/.exec(template);\n  if (singleExprMatch) {\n    try {\n      return evaluateSafeExpression(singleExprMatch[1].trim(), context);\n    } catch (error) {\n      console.warn(`Expression evaluation failed: ${singleExprMatch[1]}`, error);\n      return template;\n    }\n  }\n\n  // Replace ${...} with evaluated values (convert to string for template substitution)\n  return template.replace(/\\$\\{([^}]+)\\}/g, (match: string, expr: string) => {\n    try {\n      return String(evaluateSafeExpression(expr.trim(), context));\n    } catch (error) {\n      console.warn(`Expression evaluation failed: ${expr}`, error);\n      return match; // Return original if evaluation fails\n    }\n  });\n}\n\n/**\n * Evaluate a single expression safely\n * @param expr - Expression like \"x + y\" or \"Math.min(a, b)\"\n * @param context - Variable values\n * @returns Evaluated result\n */\nfunction evaluateSafeExpression(expr: string, context: Variables): string | number | boolean {\n  // Simple variable reference\n  if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(expr)) {\n    // Return 0 for undefined variables (common in initialization)\n    return context[expr] !== undefined ? context[expr] : 0;\n  }\n\n  // Number literal\n  if (/^-?\\d+(\\.\\d+)?$/.test(expr)) {\n    return parseFloat(expr);\n  }\n\n  // String literal\n  if (/^[\"'].*[\"']$/.test(expr)) {\n    return expr.slice(1, -1);\n  }\n\n  // Boolean literal\n  if (expr === 'true') return true;\n  if (expr === 'false') return false;\n\n  // For now, use a very restricted Function constructor approach\n  // This is still somewhat risky but much safer than eval()\n  // TODO: Replace with proper expression parser library\n  \n  // Build safe context with only allowed variables, defaulting undefined to 0\n  const safeContext: Record<string, string | number | boolean> = {};\n  for (const key of Object.keys(context)) {\n    safeContext[key] = context[key] !== undefined ? context[key] : 0;\n  }\n  \n  // Extract variable names from expression and provide defaults for missing ones\n  const varNamePattern = /\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b/g;\n  let match: RegExpExecArray | null;\n  while ((match = varNamePattern.exec(expr)) !== null) {\n    const varName = match[1];\n    // Skip Math functions and keywords\n    if (!['Math', 'min', 'max', 'abs', 'floor', 'ceil', 'round', 'sqrt', 'true', 'false'].includes(varName)) {\n      if (safeContext[varName] === undefined) {\n        safeContext[varName] = 0; // Default missing variables to 0\n      }\n    }\n  }\n  \n  // Add Math functions\n  const mathFunctions: MathFunctions = {\n    min: Math.min,\n    max: Math.max,\n    abs: Math.abs,\n    floor: Math.floor,\n    ceil: Math.ceil,\n    round: Math.round,\n    sqrt: Math.sqrt,\n  };\n\n  // Validate expression doesn't contain dangerous patterns\n  const dangerousPattern = containsDangerousPatterns(expr);\n  if (dangerousPattern) {\n    throw new Error(`Unsafe expression: ${expr} (contains ${dangerousPattern})`);\n  }\n\n  try {\n    // Create function with whitelisted context\n    const keys = Object.keys(safeContext);\n    const values = keys.map(k => safeContext[k]);\n    \n    // eslint-disable-next-line @typescript-eslint/no-implied-eval\n    const func = new Function(...keys, 'Math', `return (${expr})`) as (...args: any[]) => any;\n    return func(...values, mathFunctions);\n  } catch (error) {\n    throw new Error(`Failed to evaluate: ${expr}`);\n  }\n}\n\n/**\n * Check for dangerous patterns in expression\n * @param expr - Expression to check\n * @returns Error message if dangerous, null otherwise\n */\nfunction containsDangerousPatterns(expr: string): string | null {\n  const dangerous: Array<{pattern: RegExp, name: string}> = [\n    {pattern: /\\beval\\b/, name: 'eval'},\n    {pattern: /\\bFunction\\b/, name: 'Function'},\n    {pattern: /\\brequire\\b/, name: 'require'},\n    {pattern: /\\bimport\\b/, name: 'import'},\n    {pattern: /\\bwindow\\b/, name: 'window'},\n    {pattern: /\\bdocument\\b/, name: 'document'},\n    {pattern: /\\bprocess\\b/, name: 'process'},\n    {pattern: /\\b__\\w+__\\b/, name: 'dunder methods'},\n    {pattern: /[;{}]/, name: 'statement separators'},\n  ];\n\n  for (const {pattern, name} of dangerous) {\n    if (pattern.test(expr)) {\n      return name;\n    }\n  }\n  return null;\n}\n\n/**\n * Validate expression is safe to evaluate\n * @param expr - Expression to validate\n * @returns Validation result\n */\nexport function validateExpression(expr: string): ValidationResult {\n  const dangerousPattern = containsDangerousPatterns(expr);\n  if (dangerousPattern) {\n    return {\n      valid: false,\n      error: `Expression contains unsafe pattern: ${dangerousPattern}`,\n    };\n  }\n\n  // Check operators are whitelisted\n  const tokens = expr.split(/[\\s()[\\],]/);\n  for (const token of tokens) {\n    if (token && !isAllowedToken(token)) {\n      return {\n        valid: false,\n        error: `Token not allowed: ${token}`,\n      };\n    }\n  }\n\n  return { valid: true, error: null };\n}\n\n/**\n * Check if token is allowed\n * @param token - Token to check\n * @returns True if token is allowed\n */\nfunction isAllowedToken(token: string): boolean {\n  // Empty token\n  if (!token) return true;\n  \n  // Variable name or Math\n  if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token)) return true;\n  \n  // Number\n  if (/^-?\\d+(\\.\\d+)?$/.test(token)) return true;\n  \n  // Operator\n  if (ALLOWED_OPERATORS.includes(token)) return true;\n  \n  // Math function (Math.max, Math.min, etc)\n  if (token.startsWith('Math.')) {\n    const method = token.substring(5);\n    return ['min', 'max', 'abs', 'floor', 'ceil', 'round', 'sqrt'].includes(method);\n  }\n  \n  // Method call (e.g., .toFixed)\n  if (ALLOWED_METHODS.some(m => token === m || token === `.${m}`)) return true;\n  \n  // Dot for method chaining\n  if (token === '.') return true;\n\n  return false;\n}\n","import type {\n  BaseComponentConfig,\n  Variables,\n  Expression,\n  JXGBoard,\n  JXGElement,\n} from '../types/interfaces';\n\n// Import expression evaluator\nimport { evaluateExpression as evalExpr } from '../utils/expressionEvaluator';\n\n/** Event data passed to handlers */\nexport interface DiagramEventData {\n  type: string;\n  detail: Record<string, any>;\n  source: DiagramComponent;\n  consumed: boolean;\n  timestamp: number;\n}\n\n/**\n * Base class for all diagram components\n * Provides uniform interface for rendering, events, state, and composition\n */\nexport class DiagramComponent<TConfig extends BaseComponentConfig = BaseComponentConfig> {\n  readonly id: string;\n  readonly type: string;\n  config: TConfig;\n  readonly board: JXGBoard;\n\n  parentState: Variables;\n  localState: Variables;\n  children: DiagramComponent[];\n  elements: JXGElement[];\n  jsxElements: JXGElement[]; // Alias for backward compatibility\n  eventHandlers: Record<string, (event: DiagramEventData) => boolean>;\n  debug: boolean;\n  isDragging: boolean;\n  onEvent?: (event: DiagramEventData) => void;\n\n  constructor(config: TConfig, board: JXGBoard, parentState: Variables = {}) {\n    this.config = config;\n    this.board = board;\n    this.id = config.id || this._generateId();\n    this.type = config.type;\n    this.parentState = parentState;\n    this.localState = {};\n    this.children = [];\n    this.elements = [];\n    this.jsxElements = this.elements; // Alias\n    this.eventHandlers = {};\n    this.debug = config.debug === true;\n    this.isDragging = false;\n  }\n\n  /**\n   * Render the component on the board\n   * Override in subclasses to create JSXGraph elements\n   */\n  render(): JXGElement[] | JXGElement | void {\n    throw new Error(`${this.type} must implement render()`);\n  }\n\n  /**\n   * Update component when state changes\n   */\n  update(newState: Variables): void {\n    // Skip update if component is currently being dragged\n    if (this.isDragging) {\n      if (this.debug) {\n        console.log(`[${this.type}:${this.id}] Skipping update - currently being dragged`);\n      }\n      return;\n    }\n\n    if (this.debug) {\n      console.log(`[${this.type}:${this.id}] Update called with:`, newState);\n    }\n    this.localState = { ...this.localState, ...newState };\n    this._rerender();\n  }\n\n  /**\n   * Clean up JSXGraph elements and event listeners\n   */\n  destroy(): void {\n    // Remove all JSXGraph elements\n    this.elements.forEach(el => {\n      if (el && this.board.objects[el.id]) {\n        this.board.removeObject(el);\n      }\n    });\n    this.elements = [];\n    this.jsxElements = this.elements;\n\n    // Destroy children\n    this.children.forEach(child => child.destroy());\n    this.children = [];\n\n    // Clear event handlers\n    this.eventHandlers = {};\n  }\n\n  /**\n   * Hit test - does point (x, y) intersect this component?\n   */\n  hitTest(x: number, y: number): boolean {\n    return this.elements.some(el => {\n      if (el.hasPoint) {\n        return el.hasPoint(x, y);\n      }\n      return false;\n    });\n  }\n\n  /**\n   * Get component specificity for hit testing priority\n   * Higher values = higher priority (more specific)\n   */\n  getSpecificity(): number {\n    const defaults: Record<string, number> = {\n      point: 100,\n      text: 90,\n      line: 80,\n      circle: 50,\n      polygon: 40,\n      container: 10,\n    };\n    return defaults[this.type] || 50;\n  }\n\n  /**\n   * Handle user interaction event\n   */\n  handleEvent(event: DiagramEventData): boolean {\n    const handler = this.eventHandlers[event.type];\n    if (handler) {\n      return handler.call(this, event);\n    }\n    return false;\n  }\n\n  /**\n   * Get current component state (merged parent + local)\n   */\n  getState(): Variables {\n    return {\n      ...this.parentState,\n      ...this.localState,\n    };\n  }\n\n  /**\n   * Get value of a specific variable\n   */\n  getVariable(name: string): number | string | boolean | undefined {\n    const state = this.getState();\n    return state[name];\n  }\n\n  /**\n   * Set variable value\n   */\n  setVariable(name: string, value: number | string | boolean): void {\n    if (this.debug) {\n      console.log(`[${this.type}:${this.id}] setVariable:`, name, '=', value);\n    }\n    this.localState[name] = value;\n    this.update(this.localState);\n    this._emitEvent('variable-change', { name, value });\n  }\n\n  /**\n   * Add child component\n   */\n  addChild(component: DiagramComponent): void {\n    this.children.push(component);\n  }\n\n  /**\n   * Evaluate expression with current state\n   */\n  evaluateExpression(expression: Expression): number | string | boolean {\n    if (typeof expression !== 'string') {\n      return expression;\n    }\n\n    // Check if it's a template literal ${...}\n    if (!expression.includes('${')) {\n      return expression;\n    }\n\n    return evalExpr(expression, this.getState());\n  }\n\n  /**\n   * Emit event (bubbles to parent)\n   */\n  protected _emitEvent(type: string, detail: Record<string, any>): void {\n    if (this.onEvent) {\n      this.onEvent({\n        type,\n        detail,\n        source: this,\n        consumed: false,\n        timestamp: Date.now(),\n      });\n    }\n  }\n\n  /**\n   * Re-render component (update JSXGraph elements)\n   */\n  protected _rerender(): void {\n    if (this.debug) {\n      console.log(`[${this.type}:${this.id}] _rerender called`);\n    }\n    this.destroy();\n    this.render();\n  }\n\n  /**\n   * Generate unique ID\n   */\n  private _generateId(): string {\n    return `${this.type}_${Math.random().toString(36).substr(2, 9)}`;\n  }\n}\n","import { DiagramComponent } from '../core/DiagramComponent';\nimport type { ResolvedDiagramConfig, Variables, JXGBoard } from '../types/interfaces';\n\n/**\n * Diagram container component\n * The root component that contains all other components\n */\nexport class Diagram extends DiagramComponent<ResolvedDiagramConfig> {\n  constructor(config: ResolvedDiagramConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): void {\n    // The diagram itself doesn't render JSXGraph elements\n    // It's just a container for child components\n    \n    // Render all children\n    this.children.forEach(child => {\n      child.render();\n    });\n  }\n\n  getSpecificity(): number {\n    return 1; // Lowest priority - diagram is the background container\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { PointConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\n// Declare global JXG for JSXGraph constants\ndeclare const JXG: {\n  COORDS_BY_USER: number;\n};\n\ninterface ExtendedPointConfig extends PointConfig {\n  position?: [number | string, number | string];\n  movable?: boolean;\n  label?: string;\n  strokeColor?: string;\n  attributes?: Record<string, any>;\n  xVariable?: string;\n  yVariable?: string;\n}\n\ninterface JXGPoint extends JXGElement {\n  X(): number;\n  Y(): number;\n  setLabel(label: string): void;\n  moveTo(coords: [number, number], duration: number): void;\n  coords: {\n    setCoordinates(type: number, coords: [number, number]): void;\n  };\n}\n\n/**\n * Point component\n * Supports both fixed and movable points via config.movable property\n */\nexport class Point extends DiagramComponent<ExtendedPointConfig> {\n  isDragging: boolean = false;\n\n  constructor(config: ExtendedPointConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGPoint {\n    const config = this.config;\n    const position = config.position || config.coordinates || [0, 0];\n    const x = this.evaluateExpression(position[0]);\n    const y = this.evaluateExpression(position[1]);\n\n    const isMovable = config.movable === true;\n    \n    // Evaluate label if it contains expressions\n    const label = config.label || config.name ? this.evaluateExpression(config.label || config.name || '') : '';\n    \n    const attributes = {\n      name: label,\n      size: config.size || (isMovable ? 3 : 2),\n      fillColor: config.color || (isMovable ? '#3498db' : '#000'),\n      strokeColor: config.strokeColor || (isMovable ? '#2980b9' : '#000'),\n      fixed: !isMovable,\n      layer: 9, // Higher than text (8) to ensure points are always on top\n      ...config.attributes,\n    };\n\n    const point = this.board.create('point', [x, y], attributes) as JXGPoint;\n    \n    this.jsxElements.push(point);\n\n    // If movable, set up drag event handlers for variable updates\n    if (isMovable) {\n      point.on('down', () => {\n        this.isDragging = true;\n      });\n\n      point.on('drag', () => {\n        // Update variables directly without triggering component update\n        if (config.xVariable) {\n          this.localState[config.xVariable] = point.X();\n          this._emitEvent('variable-change', { name: config.xVariable, value: point.X() });\n        }\n        if (config.yVariable) {\n          this.localState[config.yVariable] = point.Y();\n          this._emitEvent('variable-change', { name: config.yVariable, value: point.Y() });\n        }\n        \n        // Update label during drag if it contains expressions\n        if (config.label) {\n          const updatedLabel = this.evaluateExpression(config.label);\n          point.setLabel(String(updatedLabel));\n        }\n      });\n\n      point.on('up', () => {\n        this.isDragging = false;\n        \n        // Final variable update directly without triggering component update\n        if (config.xVariable) {\n          this.localState[config.xVariable] = point.X();\n          this._emitEvent('variable-change', { name: config.xVariable, value: point.X() });\n        }\n        if (config.yVariable) {\n          this.localState[config.yVariable] = point.Y();\n          this._emitEvent('variable-change', { name: config.yVariable, value: point.Y() });\n        }\n        \n        // Final label update\n        if (config.label) {\n          const updatedLabel = this.evaluateExpression(config.label);\n          point.setLabel(String(updatedLabel));\n          this.board.update();\n        }\n      });\n    }\n\n    return point;\n  }\n\n  /**\n   * Update point position in place without recreating\n   */\n  protected _rerender(): void {\n    // Don't rerender while dragging\n    if (this.isDragging) {\n      if (this.debug) {\n        console.log(`[Point:${this.id}] Skipping rerender - currently being dragged`);\n      }\n      return;\n    }\n\n    if (this.jsxElements.length > 0) {\n      const config = this.config;\n      const position = config.position || config.coordinates || [0, 0];\n      const x = Number(this.evaluateExpression(position[0]));\n      const y = Number(this.evaluateExpression(position[1]));\n\n      if (this.debug) {\n        console.log(`[Point:${this.id}] Updating position to (${x}, ${y})`);\n      }\n\n      const point = this.jsxElements[0] as JXGPoint;\n      if (point.moveTo) {\n        point.moveTo([x, y], 0);\n      } else {\n        point.coords.setCoordinates(JXG.COORDS_BY_USER, [x, y]);\n      }\n      \n      // Update label if it contains expressions\n      if (config.label) {\n        const updatedLabel = this.evaluateExpression(config.label);\n        point.setLabel(String(updatedLabel));\n      }\n      \n      this.board.update();\n    } else {\n      this.render();\n    }\n  }\n\n  getSpecificity(): number {\n    return 100;\n  }\n}\n\n// Alias for backward compatibility\nexport class MovablePoint extends Point {\n  constructor(config: ExtendedPointConfig, board: JXGBoard, parentState: Variables = {}) {\n    super({ ...config, movable: true }, board, parentState);\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { SquareConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\ninterface ExtendedSquareConfig extends SquareConfig {\n  strokeWidth?: number;\n  strokeColor?: string;\n  attributes?: Record<string, any>;\n}\n\n/**\n * Square (rectangle) component\n */\nexport class Square extends DiagramComponent<ExtendedSquareConfig> {\n  constructor(config: ExtendedSquareConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGElement {\n    const config = this.config;\n    const position = config.position || [0, 0];\n    const widthExpr = this.evaluateExpression(config.width || 1);\n    const heightExpr = config.height !== undefined \n      ? this.evaluateExpression(config.height) \n      : widthExpr;\n\n    const x = this.evaluateExpression(position[0]);\n    const y = this.evaluateExpression(position[1]);\n\n    const numWidth = typeof widthExpr === 'number' ? widthExpr : parseFloat(String(widthExpr)) || 1;\n    const numHeight = typeof heightExpr === 'number' ? heightExpr : parseFloat(String(heightExpr)) || numWidth;\n    const numX = typeof x === 'number' ? x : parseFloat(String(x)) || 0;\n    const numY = typeof y === 'number' ? y : parseFloat(String(y)) || 0;\n\n    // Create polygon (4 corners)\n    const points: [number, number][] = [\n      [numX, numY],\n      [numX + numWidth, numY],\n      [numX + numWidth, numY - numHeight],\n      [numX, numY - numHeight],\n    ];\n\n    const attributes = {\n      strokeColor: config.strokeColor || config.color || '#000',\n      strokeWidth: config.strokeWidth || 2,\n      fillColor: config.fillColor || 'none',\n      fillOpacity: config.fillOpacity || 0.3,\n      borders: {\n        strokeColor: config.strokeColor || config.color || '#000',\n        strokeWidth: config.strokeWidth || 2,\n      },\n      vertices: {\n        visible: false,\n        withLabel: false,\n        name: ''\n      },\n      ...config.attributes,\n    };\n\n    const square = this.board.create('polygon', points, attributes);\n    this.jsxElements.push(square);\n\n    return square;\n  }\n\n  getSpecificity(): number {\n    // Specificity inversely proportional to area\n    const widthExpr = this.evaluateExpression(this.config.width || 1);\n    const heightExpr = this.config.height !== undefined \n      ? this.evaluateExpression(this.config.height) \n      : widthExpr;\n    const numWidth = typeof widthExpr === 'number' ? widthExpr : parseFloat(String(widthExpr)) || 1;\n    const numHeight = typeof heightExpr === 'number' ? heightExpr : parseFloat(String(heightExpr)) || numWidth;\n    const area = numWidth * numHeight;\n    return Math.max(10, 100 - area * 10);\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { SliderConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\ninterface ExtendedSliderConfig extends SliderConfig {\n  label?: string;\n  color?: string;\n  strokeWidth?: number;\n  gliderSize?: number;\n  size?: number;\n  snapWidth?: number;\n  precision?: number;\n  attributes?: Record<string, any>;\n  tickStep?: number;\n  tickColor?: string;\n  tickLabelSize?: number;\n  tickLabelColor?: string;\n  tickLabelOffset?: number;\n}\n\ninterface JXGSlider extends JXGElement {\n  Value(): number;\n  setValue(value: number): void;\n}\n\n/**\n * Slider component for numeric input\n * Supports integer and real modes with optional tick labels\n */\nexport class Slider extends DiagramComponent<ExtendedSliderConfig> {\n  isInitializing: boolean = true;\n  isDragging: boolean = false;\n\n  constructor(config: ExtendedSliderConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGSlider {\n    const config = this.config;\n    \n    // Slider configuration\n    const position = config.position || [0, 0, 5];\n    const x1 = Number(this.evaluateExpression(position[0]));\n    const y1 = Number(this.evaluateExpression(position[1]));\n    const x2 = Number(this.evaluateExpression(position[2] || x1 + 5));\n    const y2 = y1; // Horizontal slider\n    \n    const min = config.min || 0;\n    const max = config.max || 10;\n    const initialValue = Number(this.evaluateExpression(config.value || min));\n    \n    // Mode: 'integer' (default) or 'real'\n    const mode = config.mode || 'integer';\n    const snapWidth = mode === 'integer' ? 1 : (config.snapWidth || 0);\n    \n    // Glider (circle) configuration\n    const gliderColor = config.gliderColor || config.color || '#3498db';\n    const gliderOpacity = config.gliderOpacity !== undefined ? config.gliderOpacity : 0.7;\n    const gliderSize = config.gliderSize || config.size || 6;\n    \n    // Create slider\n    const slider = this.board.create('slider', [\n      [x1, y1],\n      [x2, y2],\n      [min, initialValue, max]\n    ], {\n      // Render label separately so it stays within the board and doesn't clip\n      name: '',\n      // Hide JSXGraph's built-in label/value readout (it shows on the right)\n      withLabel: false,\n      label: { visible: false },\n      snapWidth: snapWidth,\n      strokeColor: config.color || '#3498db',\n      strokeWidth: config.strokeWidth || 3,\n      fillColor: gliderColor,\n      fillOpacity: gliderOpacity,\n      highlightStrokeColor: gliderColor, // Keep same color on highlight\n      highlightFillColor: gliderColor, // Keep same color on highlight\n      size: gliderSize,\n      layer: 9,\n      precision: mode === 'integer' ? 0 : (config.precision || 2),\n      withTicks: false, // Disable JSXGraph's default ticks\n      ticks: { visible: false }, // Ensure ticks are hidden\n      // Two-line slider track:\n      // - baseline: faint full length\n      // - highline: active segment proportional to the current value\n      baseline: {\n        strokeColor: config.tickColor || '#9aa0a6',\n        strokeOpacity: 0.35,\n        strokeWidth: config.strokeWidth || 3,\n        visible: true\n      },\n      highline: {\n        strokeColor: config.color || '#3498db',\n        strokeOpacity: 1,\n        strokeWidth: config.strokeWidth || 3,\n        visible: true\n      },\n      point1: { visible: false },\n      point2: { visible: false },\n      ...config.attributes\n    }) as JXGSlider;\n    \n    this.jsxElements.push(slider);\n    \n    // Force update to ensure clean rendering\n    this.board.update();\n\n    // Slider label (separate text element to avoid clipping in tight bounding boxes)\n    if (config.label) {\n      const labelY = y1 + 0.25;\n      const label = this.board.create('text', [x1, labelY, config.label], {\n        fontSize: 14,\n        color: '#333',\n        anchorX: 'left',\n        anchorY: 'bottom',\n        fixed: true,\n        highlight: false,\n        layer: 10,\n        cssClass: 'jxg-text-no-pointer'\n      });\n      this.jsxElements.push(label);\n    }\n    \n    // Add tick marks with labels if requested\n    if (config.showTicks) {\n      const tickStep = config.tickStep ?? 1;\n      const showTickLabels = config.showTickLabels !== false;\n      const tickLabelSize = config.tickLabelSize ?? 12;\n      const tickLabelColor = config.tickLabelColor || '#666';\n      // Negative offset means \"below\" the slider baseline in JSXGraph coordinates.\n      const tickLabelOffset = config.tickLabelOffset ?? -0.25;\n\n      // Scale tick length relative to tick spacing.\n      // Requirement: tick marks should be at most ~1/4 of the distance between ticks.\n      const safeRange = (max - min) === 0 ? 1 : (max - min);\n      const tickSpacingX = Math.abs(x2 - x1) * (tickStep / safeRange);\n      const tickFullLength = Math.min(0.3, tickSpacingX * 0.25);\n      const tickHalfLength = tickFullLength / 2;\n      \n      for (let i = min; i <= max; i += tickStep) {\n        const t = (i - min) / (max - min);\n        const tickX = x1 + t * (x2 - x1);\n        const tickY = y1;\n        \n        // Create small tick mark\n        const tickMark = this.board.create('segment', [\n          [tickX, tickY - tickHalfLength],\n          [tickX, tickY + tickHalfLength]\n        ], {\n          strokeColor: config.tickColor || '#999',\n          strokeWidth: 2,\n          fixed: true,\n          highlight: false,\n          layer: 8\n        });\n        \n        this.jsxElements.push(tickMark);\n        \n        // Add label if requested\n        if (showTickLabels) {\n          const label = this.board.create('text', [tickX, tickY + tickLabelOffset, i.toString()], {\n            fontSize: tickLabelSize,\n            color: tickLabelColor,\n            anchorX: 'middle',\n            // Place labels below the slider: anchor from the top so text flows downward.\n            anchorY: 'top',\n            fixed: true,\n            highlight: false,\n            layer: 8,\n            cssClass: 'jxg-text-no-pointer'\n          });\n          \n          this.jsxElements.push(label);\n        }\n      }\n    }\n    \n    // Update variable on drag\n    if (config.variable) {\n      slider.on('drag', () => {\n        const rawValue = slider.Value();\n        const value = mode === 'integer' ? Math.round(rawValue) : rawValue;\n        this.localState[config.variable] = value;\n        this._emitEvent('variable-change', { name: config.variable, value });\n      });\n      \n      slider.on('down', () => {\n        this.isDragging = true;\n      });\n      \n      slider.on('up', () => {\n        this.isDragging = false;\n      });\n      \n      // Set initial variable value without triggering update\n      const initValue = mode === 'integer' ? Math.round(initialValue) : initialValue;\n      this.localState[config.variable] = initValue;\n      \n      // Emit initial value after a brief delay to ensure slider is fully rendered\n      setTimeout(() => {\n        this.isInitializing = false;\n        this._emitEvent('variable-change', { name: config.variable, value: initValue });\n      }, 0);\n    }\n    \n    return slider;\n  }\n\n  /**\n   * Update slider value without recreating\n   */\n  protected _rerender(): void {\n    if (this.isDragging || this.isInitializing) {\n      return;\n    }\n    \n    if (this.jsxElements.length > 0) {\n      const config = this.config;\n      const slider = this.jsxElements[0] as JXGSlider;\n      const newValue = Number(this.evaluateExpression(config.value));\n      \n      if (slider.Value() !== newValue) {\n        slider.setValue(newValue);\n        this.board.update();\n      }\n    } else {\n      this.render();\n    }\n  }\n\n  getSpecificity(): number {\n    return 100; // Interactive element\n  }\n}\n","// Core\nimport { BlitzDiagram } from './core/BlitzDiagram';\nimport { DiagramComponent } from './core/DiagramComponent';\nimport { componentRegistry } from './core/ComponentRegistry';\n\n// Validation\nimport { SchemaValidator } from './validation/SchemaValidator';\nimport type { ValidationResult, ValidationError } from './validation/SchemaValidator';\n\n// Schemas - for AI agents and external validators\nexport * as schemas from './schemas/index';\n\n// Components\nimport { Diagram } from './components/Diagram';\nimport { Point, MovablePoint, Line, Circle, Square, Grid as GeometricGrid, Text } from './components/geometric/index';\nimport { TenFrame } from './components/educational/TenFrame';\nimport Bin from './components/educational/Bin';\nimport DraggableDot from './components/educational/DraggableDot';\nimport DropBin from './components/educational/DropBin';\nimport DotPool from './components/educational/DotPool';\nimport { Slider } from './components/interactive/Slider';\nimport GridLayout from './components/layout/Grid';\n\n// Register all components\ncomponentRegistry.register('point', Point);\ncomponentRegistry.register('movablepoint', MovablePoint);\ncomponentRegistry.register('line', Line);\ncomponentRegistry.register('circle', Circle);\ncomponentRegistry.register('square', Square);\ncomponentRegistry.register('rectangle', Square); // Alias\ncomponentRegistry.register('geometricgrid', GeometricGrid);\ncomponentRegistry.register('text', Text);\ncomponentRegistry.register('tenframe', TenFrame);\ncomponentRegistry.register('bin', Bin);\ncomponentRegistry.register('draggabledot', DraggableDot);\ncomponentRegistry.register('dropbin', DropBin);\ncomponentRegistry.register('dotpool', DotPool);\ncomponentRegistry.register('slider', Slider);\ncomponentRegistry.register('gridlayout', GridLayout);\n\n// Diagram container\ncomponentRegistry.register('diagram', Diagram);\ncomponentRegistry.register('2d', Diagram);\ncomponentRegistry.register('3d', Diagram);\n\n// Auto-register web component AFTER all registrations are complete\nif (typeof window !== 'undefined' && typeof customElements !== 'undefined') {\n  if (!customElements.get('blitz-diagram')) {\n    customElements.define('blitz-diagram', BlitzDiagram);\n  }\n}\n\n// Export for direct use\nexport {\n  BlitzDiagram,\n  DiagramComponent,\n  componentRegistry,\n  SchemaValidator,\n  // Type exports for TypeScript users\n  ValidationResult,\n  ValidationError,\n};\n\n// Export as default for UMD bundle\nexport default {\n  BlitzDiagram,\n  DiagramComponent,\n  componentRegistry,\n  SchemaValidator,\n};\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { LineConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\n// Declare global JXG for JSXGraph constants\ndeclare const JXG: {\n  COORDS_BY_USER: number;\n};\n\ninterface ExtendedLineConfig extends LineConfig {\n  point1?: [number | string, number | string];\n  point2?: [number | string, number | string];\n  start?: [number | string, number | string];\n  end?: [number | string, number | string];\n  width?: number;\n  extend?: boolean;\n  attributes?: Record<string, any>;\n}\n\ninterface JXGLine extends JXGElement {\n  point1: {\n    setPosition(type: number, coords: [number, number]): void;\n  };\n  point2: {\n    setPosition(type: number, coords: [number, number]): void;\n  };\n}\n\n/**\n * Line component\n */\nexport class Line extends DiagramComponent<ExtendedLineConfig> {\n  constructor(config: ExtendedLineConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGLine {\n    const config = this.config;\n    const p1 =\n      config.point1 ||\n      (config.points && config.points[0]) ||\n      config.start ||\n      [0, 0];\n    const p2 =\n      config.point2 ||\n      (config.points && config.points[1]) ||\n      config.end ||\n      [1, 1];\n\n    const x1 = this.evaluateExpression(p1[0]);\n    const y1 = this.evaluateExpression(p1[1]);\n    const x2 = this.evaluateExpression(p2[0]);\n    const y2 = this.evaluateExpression(p2[1]);\n\n    const attributes = {\n      strokeColor: config.color || '#000',\n      strokeWidth: config.width || config.strokeWidth || 2,\n      straightFirst: config.extend !== false,\n      straightLast: config.extend !== false,\n      ...config.attributes,\n    };\n\n    const line = this.board.create('line', [[x1, y1], [x2, y2]], attributes) as JXGLine;\n    this.jsxElements.push(line);\n\n    return line;\n  }\n\n  /**\n   * Update line positions in place without recreating\n   */\n  protected _rerender(): void {\n    if (this.jsxElements.length > 0) {\n      const config = this.config;\n      const p1 =\n        config.point1 ||\n        (config.points && config.points[0]) ||\n        config.start ||\n        [0, 0];\n      const p2 =\n        config.point2 ||\n        (config.points && config.points[1]) ||\n        config.end ||\n        [1, 1];\n\n      const x1 = Number(this.evaluateExpression(p1[0]));\n      const y1 = Number(this.evaluateExpression(p1[1]));\n      const x2 = Number(this.evaluateExpression(p2[0]));\n      const y2 = Number(this.evaluateExpression(p2[1]));\n\n      // Update the line's point positions\n      const line = this.jsxElements[0] as JXGLine;\n      line.point1.setPosition(JXG.COORDS_BY_USER, [x1, y1]);\n      line.point2.setPosition(JXG.COORDS_BY_USER, [x2, y2]);\n      \n      this.board.update();\n    } else {\n      // First render\n      this.render();\n    }\n  }\n\n  getSpecificity(): number {\n    return 80; // Lines have medium priority\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { CircleConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\ninterface ExtendedCircleConfig extends CircleConfig {\n  width?: number;\n  strokeWidth?: number;\n  strokeColor?: string;\n  attributes?: Record<string, any>;\n}\n\n/**\n * Circle component\n */\nexport class Circle extends DiagramComponent<ExtendedCircleConfig> {\n  constructor(config: ExtendedCircleConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGElement {\n    const config = this.config;\n    const center = config.center || [0, 0];\n    const radius = this.evaluateExpression(config.radius || 1);\n\n    const cx = this.evaluateExpression(center[0]);\n    const cy = this.evaluateExpression(center[1]);\n\n    const attributes = {\n      strokeColor: config.strokeColor || config.color || '#000',\n      strokeWidth: config.strokeWidth || config.width || 2,\n      fillColor: config.fillColor || 'none',\n      fillOpacity: config.fillOpacity || 0.3,\n      ...config.attributes,\n    };\n\n    const circle = this.board.create('circle', [[cx, cy], radius], attributes);\n    this.jsxElements.push(circle);\n\n    return circle;\n  }\n\n  getSpecificity(): number {\n    // Specificity inversely proportional to area\n    const radius = this.evaluateExpression(this.config.radius || 1);\n    const numRadius = typeof radius === 'number' ? radius : parseFloat(String(radius)) || 1;\n    const area = Math.PI * numRadius * numRadius;\n    return Math.max(10, 100 - area); // Smaller circles = higher priority\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { BaseComponentConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\ninterface GeometricGridConfig extends BaseComponentConfig {\n  type: 'geometricgrid';\n  xMin?: number;\n  xMax?: number;\n  yMin?: number;\n  yMax?: number;\n  step?: number;\n  color?: string;\n  width?: number;\n  showPoints?: boolean;\n  attributes?: Record<string, any>;\n}\n\n/**\n * Grid component - creates a grid of points or lines\n */\nexport class Grid extends DiagramComponent<GeometricGridConfig> {\n  constructor(config: GeometricGridConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): void {\n    const config = this.config;\n    const xMin = config.xMin || -5;\n    const xMax = config.xMax || 5;\n    const yMin = config.yMin || -5;\n    const yMax = config.yMax || 5;\n    const step = config.step || 1;\n\n    const ensureCssClass = (existing: string | undefined, cls: string): string => {\n      if (!existing || existing.trim().length === 0) {\n        return cls;\n      }\n      return existing.split(/\\s+/).includes(cls) ? existing : `${existing} ${cls}`;\n    };\n\n    const attributes: Record<string, any> = {\n      strokeColor: config.color || '#ccc',\n      strokeWidth: config.width || 1,\n      fixed: true,\n      highlight: false,\n      layer: 0, // Put grid on background layer\n      ...config.attributes,\n    };\n    attributes.cssClass = ensureCssClass(attributes.cssClass, 'jxg-grid-line');\n\n    // Vertical lines\n    for (let x = xMin; x <= xMax; x += step) {\n      const line = this.board.create('line', [[x, yMin], [x, yMax]], {\n        ...attributes,\n        straightFirst: false,\n        straightLast: false,\n      });\n      this.jsxElements.push(line);\n    }\n\n    // Horizontal lines\n    for (let y = yMin; y <= yMax; y += step) {\n      const line = this.board.create('line', [[xMin, y], [xMax, y]], {\n        ...attributes,\n        straightFirst: false,\n        straightLast: false,\n      });\n      this.jsxElements.push(line);\n    }\n\n    // Optionally create intersection points\n    if (config.showPoints) {\n      for (let x = xMin; x <= xMax; x += step) {\n        for (let y = yMin; y <= yMax; y += step) {\n          const point = this.board.create('point', [x, y], {\n            size: 1,\n            fillColor: config.color || '#999',\n            strokeColor: config.color || '#999',\n            fixed: true,\n            cssClass: ensureCssClass(undefined, 'jxg-grid-point'),\n          });\n          this.jsxElements.push(point);\n        }\n      }\n    }\n  }\n\n  /**\n   * Grid never needs to update - override to prevent destroy/recreate\n   */\n  protected _rerender(): void {\n    // Grid is static, never update it\n    if (this.jsxElements.length === 0) {\n      this.render();\n    }\n  }\n\n  getSpecificity(): number {\n    return 5; // Grid has low priority (background element)\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { TextConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\ninterface ExtendedTextConfig extends TextConfig {\n  fixed?: boolean;\n  align?: string;\n  valign?: string;\n  anchorX?: string;\n  anchorY?: string;\n  fontWeight?: string;\n  layer?: number;\n  attributes?: Record<string, any>;\n}\n\ninterface JXGText extends JXGElement {\n  setText(content: string): void;\n}\n\n/**\n * Text label component\n */\nexport class Text extends DiagramComponent<ExtendedTextConfig> {\n  private _lastContent: string | number | boolean | null = null;\n\n  private _normalizeAnchorX(value: unknown): 'left' | 'middle' | 'right' {\n    if (typeof value !== 'string') {\n      return 'middle';\n    }\n\n    const v = value.trim().toLowerCase();\n    if (v === 'middle' || v === 'center' || v === 'centre') return 'middle';\n    if (v === 'left' || v === 'start') return 'left';\n    if (v === 'right' || v === 'end') return 'right';\n\n    return 'middle';\n  }\n\n  private _normalizeAnchorY(value: unknown): 'top' | 'middle' | 'bottom' {\n    if (typeof value !== 'string') {\n      return 'middle';\n    }\n\n    const v = value.trim().toLowerCase();\n    if (v === 'middle' || v === 'center' || v === 'centre') return 'middle';\n    if (v === 'top') return 'top';\n    if (v === 'bottom') return 'bottom';\n\n    return 'middle';\n  }\n\n  constructor(config: ExtendedTextConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGText {\n    const config = this.config;\n    const position = config.position || [0, 0];\n    const content = this.evaluateExpression(config.content || '');\n\n    const x = Number(this.evaluateExpression(position[0]));\n    const y = Number(this.evaluateExpression(position[1]));\n\n    const attributes = {\n      fontSize: config.fontSize || 14,\n      color: config.color || '#000',\n      fontWeight: config.fontWeight,\n      fixed: config.fixed !== false,\n      anchorX: this._normalizeAnchorX(config.anchorX ?? config.align),\n      anchorY: this._normalizeAnchorY(config.anchorY ?? config.valign),\n      highlight: false, // Don't highlight on hover\n      layer: config.layer || 8, // Lower layer than points\n      cssClass: 'jxg-text-no-pointer', // Add CSS class for pointer-events\n      ...config.attributes,\n    };\n\n    const text = this.board.create('text', [x, y, content], attributes) as JXGText;\n    this.jsxElements.push(text);\n    this._lastContent = content;\n\n    return text;\n  }\n\n  /**\n   * Update text content in place without recreating\n   */\n  protected _rerender(): void {\n    const config = this.config;\n    const newContent = this.evaluateExpression(config.content || '');\n    \n    // Skip if content hasn't changed\n    if (newContent === this._lastContent) {\n      return;\n    }\n    \n    if (this.jsxElements.length > 0) {\n      const text = this.jsxElements[0] as JXGText;\n      text.setText(String(newContent));\n      this._lastContent = newContent;\n      this.board.update();\n    } else {\n      this.render();\n    }\n  }\n\n  getSpecificity(): number {\n    return 90; // Text has high priority (small bounded element)\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport { Slider } from '../interactive/Slider';\nimport type { TenFrameConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\ninterface ColorMapping {\n  color: string;\n  count: number;\n}\n\ninterface SliderConfig {\n  enabled?: boolean;\n  position?: 'below' | 'above' | 'right' | 'left';\n  offset?: number;\n  min?: number;\n  max?: number;\n  variable?: string;\n  label?: string;\n  color?: string;\n  strokeWidth?: number;\n  gliderSize?: number;\n  gliderOpacity?: number;\n  showTicks?: boolean;\n  showTickLabels?: boolean;\n  tickStep?: number;\n  tickLabelSize?: number;\n  tickLabelColor?: string;\n  tickLabelOffset?: number;\n}\n\ninterface ExtendedTenFrameConfig extends TenFrameConfig {\n  mode?: 'five' | 'ten';\n  maxCapacity?: number;\n  cellSpacing?: number;\n  strokeColor?: string;\n  strokeWidth?: number;\n  fillColor?: string;\n  colorMap?: Array<{ color: string; count: number | string }>;\n  label?: string;\n  labelSize?: number;\n  labelColor?: string;\n  labelPosition?: 'above' | 'below' | 'belowSlider';\n  labelOffset?: number;\n  slider?: SliderConfig;\n}\n\n/**\n * Ten Frame component for representing numbers 0-30\n * Displays up to 3 rows of 10 cells each\n * Optionally includes an integrated slider for interaction\n */\nexport class TenFrame extends DiagramComponent<ExtendedTenFrameConfig> {\n  private _updateTimeout: ReturnType<typeof setTimeout> | null = null;\n  private _lastValue: number | null = null;\n  private _slider: Slider | null = null;\n\n  constructor(config: ExtendedTenFrameConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): void {\n    const config = this.config;\n    \n    // Evaluate value expression\n    const value = Math.round(Number(this.evaluateExpression(config.value || 0)));\n    \n    // Mode: 'ten' (10 cells per row) or 'five' (5 cells per row, default)\n    const mode = config.mode || 'five';\n    const cellsPerRow = mode === 'five' ? 5 : 10;\n    \n    // Maximum capacity (default 15 for 'five' mode, 30 for 'ten' mode)\n    const maxCapacity = config.maxCapacity || (mode === 'five' ? 15 : 30);\n    \n    // Validate range\n    if (value < 0 || value > maxCapacity) {\n      console.error(`TenFrame value ${value} out of range [0-${maxCapacity}]`);\n      return;\n    }\n    \n    // Position and size configuration\n    const x = Number(this.evaluateExpression(config.position?.[0] || 0));\n    const y = Number(this.evaluateExpression(config.position?.[1] || 0));\n    const cellSize = config.cellSize || 0.8;\n    const cellSpacing = config.cellSpacing || 0.1;\n    const strokeColor = config.strokeColor || '#000';\n    const strokeWidth = config.strokeWidth || 2;\n    const fillColor = config.fillColor || '#4CAF50';\n    const emptyColor = config.emptyColor || '#fff';\n    \n    // Evaluate colorMap if provided\n    let evaluatedColorMap: ColorMapping[] | null = null;\n    if (config.colorMap && Array.isArray(config.colorMap)) {\n      evaluatedColorMap = config.colorMap.map((mapping: { color: string; count: number | string }) => ({\n        color: mapping.color,\n        count: Math.round(Number(this.evaluateExpression(mapping.count)))\n      }));\n    }\n    \n    // Calculate number of rows to render\n    const maxRows = Math.ceil(maxCapacity / cellsPerRow);\n    // In 'five' mode, always show at least 2 rows (10 cells)\n    const minRows = mode === 'five' ? 2 : 1;\n    const rowsToRender = Math.max(minRows, Math.min(maxRows, Math.ceil(value / cellsPerRow)));\n\n    const frameWidth = cellsPerRow * (cellSize + cellSpacing) - cellSpacing;\n    const frameHeight = rowsToRender * (cellSize + cellSpacing) - cellSpacing;\n    \n    for (let row = 0; row < rowsToRender; row++) {\n      for (let col = 0; col < cellsPerRow; col++) {\n        const cellIndex = row * cellsPerRow + col;\n        const cellX = x + col * (cellSize + cellSpacing);\n        const cellY = y - row * (cellSize + cellSpacing);\n        \n        // Determine if this cell is filled\n        const isFilled = cellIndex < value;\n        \n        // Determine fill color\n        let cellFillColor = emptyColor;\n        if (isFilled) {\n          if (evaluatedColorMap) {\n            // Use color map: [{color: '#color', count: n}, ...]\n            let accumulated = 0;\n            for (const mapping of evaluatedColorMap) {\n              accumulated += mapping.count;\n              if (cellIndex < accumulated) {\n                cellFillColor = mapping.color;\n                break;\n              }\n            }\n          } else {\n            cellFillColor = fillColor;\n          }\n        }\n        \n        // Create fixed rectangle using 4 corner points\n        const p1 = this.board.create('point', [cellX, cellY], {\n          visible: false,\n          fixed: true,\n          withLabel: false,\n          name: ''\n        });\n        const p2 = this.board.create('point', [cellX + cellSize, cellY], {\n          visible: false,\n          fixed: true,\n          withLabel: false,\n          name: ''\n        });\n        const p3 = this.board.create('point', [cellX + cellSize, cellY - cellSize], {\n          visible: false,\n          fixed: true,\n          withLabel: false,\n          name: ''\n        });\n        const p4 = this.board.create('point', [cellX, cellY - cellSize], {\n          visible: false,\n          fixed: true,\n          withLabel: false,\n          name: ''\n        });\n        \n        const rect = this.board.create('polygon', [p1, p2, p3, p4], {\n          fillColor: cellFillColor,\n          fillOpacity: 1,\n          strokeColor: strokeColor,\n          strokeWidth: strokeWidth,\n          borders: { fixed: true },\n          vertices: { fixed: true },\n          fixed: true,\n          highlight: false,\n          hasInnerPoints: false,\n          layer: 5,\n          cssClass: 'jxg-grid-line'\n        });\n        \n        this.jsxElements.push(p1, p2, p3, p4, rect);\n      }\n    }\n\n    // Add integrated slider if configured\n    const sliderLayout = config.slider?.enabled\n      ? this._renderSlider(x, y, cellSize, cellSpacing, cellsPerRow, rowsToRender, frameWidth, frameHeight)\n      : null;\n\n    // Add label if provided (positioning handled here; do not lay out labels externally)\n    if (config.label) {\n      const labelText = this.evaluateExpression(config.label);\n      const labelX = x + frameWidth / 2;\n      // Default behavior: labels should be below the tenframe.\n      // If an integrated slider is enabled, default to belowSlider so it naturally\n      // sits under the slider + tick labels.\n      const labelPosition = config.labelPosition || (config.slider?.enabled ? 'belowSlider' : 'below');\n\n      const defaultAboveOffset = cellSize * 0.6;\n      const defaultBelowOffset = cellSize * 0.9;\n      const defaultBelowSliderOffset = cellSize * 1.3;\n\n      let labelY = y + defaultAboveOffset;\n      if (labelPosition === 'below') {\n        const offset = config.labelOffset ?? defaultBelowOffset;\n        labelY = y - frameHeight - offset;\n      } else if (labelPosition === 'belowSlider') {\n        const offset = config.labelOffset ?? defaultBelowSliderOffset;\n\n        if (sliderLayout) {\n          const tickLabelOffset = this.config.slider?.tickLabelOffset ?? -(cellSize * 0.6);\n          labelY = sliderLayout.sliderY + tickLabelOffset - offset;\n        } else {\n          labelY = y - frameHeight - offset;\n        }\n      } else {\n        const offset = config.labelOffset ?? defaultAboveOffset;\n        labelY = y + offset;\n      }\n\n      const text = this.board.create('text', [labelX, labelY, labelText], {\n        fontSize: config.labelSize || 16,\n        color: config.labelColor || '#000',\n        anchorX: 'middle',\n        anchorY: 'middle',\n        fixed: true,\n        highlight: false,\n        layer: 8,\n        cssClass: 'jxg-text-no-pointer'\n      });\n\n      this.jsxElements.push(text);\n    }\n  }\n  \n  /**\n   * Render integrated slider for the ten frame\n   */\n  private _renderSlider(\n    x: number,\n    y: number,\n    cellSize: number,\n    cellSpacing: number,\n    cellsPerRow: number,\n    rowsToRender: number,\n    frameWidth: number,\n    _frameHeight: number\n  ): { sliderX1: number; sliderY: number; sliderX2: number } {\n    const sliderConfig = this.config.slider!;\n    const mode = this.config.mode || 'five';\n    const maxCapacity = this.config.maxCapacity || (mode === 'five' ? 15 : 30);\n    \n    // Calculate slider position based on configuration\n    const position = sliderConfig.position || 'below';\n    // Default offset should be relative to the tenframe scale so it works in both\n    // \"board\" units and \"normalized\" (0..1) coordinates.\n    const offset = sliderConfig.offset ?? (cellSize * 0.9);\n    \n    let sliderX1: number, sliderY: number, sliderX2: number;\n\n    // Requirement: slider should be wider than the tenframe.\n    // For below/above layouts, render it at least 2x the tenframe width.\n    const widthFactor = (position === 'below' || position === 'above') ? 2 : 1;\n    const sliderWidth = frameWidth * widthFactor;\n    \n    switch (position) {\n      case 'below':\n        sliderX1 = x + (frameWidth - sliderWidth) / 2;\n        sliderY = y - rowsToRender * (cellSize + cellSpacing) - offset;\n        sliderX2 = sliderX1 + sliderWidth;\n        break;\n      case 'above':\n        sliderX1 = x + (frameWidth - sliderWidth) / 2;\n        sliderY = y + offset;\n        sliderX2 = sliderX1 + sliderWidth;\n        break;\n      case 'right':\n        sliderX1 = x + frameWidth + offset;\n        sliderY = y - (rowsToRender * (cellSize + cellSpacing)) / 2;\n        sliderX2 = sliderX1 + frameWidth;\n        break;\n      case 'left':\n        sliderX1 = x - offset - frameWidth;\n        sliderY = y - (rowsToRender * (cellSize + cellSpacing)) / 2;\n        sliderX2 = x - offset;\n        break;\n      default:\n        sliderX1 = x;\n        sliderY = y - rowsToRender * (cellSize + cellSpacing) - offset;\n        sliderX2 = x + frameWidth;\n    }\n    \n    // Create slider component\n    const sliderComponentConfig = {\n      type: 'slider' as const,\n      position: [sliderX1, sliderY, sliderX2] as [number, number, number],\n      min: sliderConfig.min ?? 0,\n      max: sliderConfig.max ?? maxCapacity,\n      value: this.config.value,\n      variable: sliderConfig.variable || 'n',\n      label: sliderConfig.label || '',\n      mode: 'integer' as const,\n      color: sliderConfig.color || this.config.fillColor || '#4CAF50',\n      gliderColor: sliderConfig.color || this.config.fillColor || '#4CAF50',\n      strokeWidth: sliderConfig.strokeWidth,\n      gliderSize: sliderConfig.gliderSize,\n      gliderOpacity: sliderConfig.gliderOpacity,\n      showTicks: sliderConfig.showTicks ?? true,\n      showTickLabels: sliderConfig.showTickLabels ?? true,\n      tickStep: sliderConfig.tickStep ?? 1,\n      tickLabelSize: sliderConfig.tickLabelSize,\n      tickLabelColor: sliderConfig.tickLabelColor,\n      tickLabelOffset: sliderConfig.tickLabelOffset\n    };\n    \n    this._slider = new Slider(sliderComponentConfig, this.board, this.getState());\n    \n    // Setup event propagation from slider\n    this._slider.onEvent = (event) => {\n      this._emitEvent(event.type, event.detail);\n    };\n    \n    const sliderElement = this._slider.render();\n    void sliderElement;\n\n    return { sliderX1, sliderY, sliderX2 };\n  }\n\n  /**\n   * Handle updates when variables change\n   */\n  update(newConfig?: Partial<ExtendedTenFrameConfig>): void {\n    // Update parent state for expression evaluation\n    if (newConfig) {\n      this.config = { ...this.config, ...newConfig };\n    }\n    this._rerender();\n  }\n\n  /**\n   * Update ten frame with debouncing for smooth updates\n   */\n  protected _rerender(): void {\n    const config = this.config;\n    const newValue = Math.round(Number(this.evaluateExpression(config.value || 0)));\n    \n    // Skip if value hasn't changed\n    if (newValue === this._lastValue) {\n      return;\n    }\n    \n    // Clear any pending update\n    if (this._updateTimeout) {\n      clearTimeout(this._updateTimeout);\n    }\n    \n    // Debounce updates to avoid jerkiness during rapid changes\n    this._updateTimeout = setTimeout(() => {\n      this._lastValue = newValue;\n\n      // Simpler + correct: fully recreate on value changes.\n      // This avoids leaking slider instances and keeps layout consistent.\n      this.destroy();\n      this.render();\n      this._updateTimeout = null;\n    }, 50); // 50ms debounce\n  }\n  \n  /**\n   * Override destroy to clean up slider\n   */\n  destroy(): void {\n    if (this._updateTimeout) {\n      clearTimeout(this._updateTimeout);\n      this._updateTimeout = null;\n    }\n\n    if (this._slider) {\n      this._slider.destroy();\n      this._slider = null;\n    }\n\n    super.destroy();\n  }\n\n  getSpecificity(): number {\n    return 20; // Background element\n  }\n}\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { BinConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\n/**\n * Bin Component - A container that displays a specified number of dots inside\n * \n * Properties:\n * - position: [x, y] - Center position of the bin\n * - count: number - Number of dots to display (0-9)\n * - color: string - Color of the bin border and dots\n * - width: number - Width of the bin (default: 2.5)\n * - height: number - Height of the bin (default: 2.5)\n */\nclass Bin extends DiagramComponent<BinConfig> {\n  constructor(config: BinConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n  }\n\n  render(): JXGElement[] {\n    const x = Number(this.evaluateExpression(this.config.position[0]));\n    const y = Number(this.evaluateExpression(this.config.position[1]));\n    const count = Number(this.evaluateExpression(this.config.count || 0));\n    const color = this.config.color || '#000000';\n    const width = this.config.width || 2.5;\n    const height = this.config.height || 2.5;\n\n    // Don't render anything if count is 0\n    if (count <= 0) {\n      return this.elements;\n    }\n\n    // Create bin rectangle (container)\n    const left = x - width / 2;\n    const right = x + width / 2;\n    const top = y + height / 2;\n    const bottom = y - height / 2;\n\n    // Create the four corners of the rectangle\n    const p1 = this.board.create('point', [left, top], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n    const p2 = this.board.create('point', [right, top], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n    const p3 = this.board.create('point', [right, bottom], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n    const p4 = this.board.create('point', [left, bottom], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n\n    // Create the rectangle polygon\n    const rectangle = this.board.create('polygon', [p1, p2, p3, p4], {\n      strokeColor: color,\n      strokeWidth: 3,\n      fillColor: 'none',\n      vertices: {\n        visible: false,\n        withLabel: false,\n        name: ''\n      }\n    });\n\n    this.elements.push(p1, p2, p3, p4, rectangle);\n\n    // Create dots inside the bin based on count\n    // Arrange dots in a grid pattern (up to 3x3)\n    if (count > 0 && count <= 9) {\n      const cols = Math.min(3, count);\n      const rows = Math.ceil(count / 3);\n      \n      const dotSpacingX = width / (cols + 1);\n      const dotSpacingY = height / (rows + 1);\n      \n      let dotIndex = 0;\n      for (let row = 0; row < rows && dotIndex < count; row++) {\n        const dotsInRow = Math.min(3, count - dotIndex);\n        for (let col = 0; col < dotsInRow; col++) {\n          const dotX = left + (col + 1) * dotSpacingX;\n          const dotY = top - (row + 1) * dotSpacingY;\n          \n          const dot = this.board.create('point', [dotX, dotY], {\n            size: 4,\n            fillColor: color,\n            strokeColor: color,\n            fixed: true,\n            withLabel: false,\n            name: ''\n          });\n          \n          this.elements.push(dot);\n          dotIndex++;\n        }\n      }\n    }\n\n    return this.elements;\n  }\n\n  update(variables: Variables): void {\n    // Merge new variables into parentState (don't replace entirely)\n    this.parentState = { ...this.parentState, ...variables };\n    \n    // Remove old elements\n    this.elements.forEach(el => {\n      if (el && this.board.objectsList && this.board.objectsList.includes(el)) {\n        this.board.removeObject(el);\n      }\n    });\n    this.elements = [];\n\n    // Recreate with new values\n    this.render();\n  }\n}\n\nexport default Bin;\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { DraggableDotConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\n/**\n * DraggableDot Component - A dot that can be dragged between bins\n */\nclass DraggableDot extends DiagramComponent<DraggableDotConfig> {\n  dot: JXGElement | null = null;\n  originalPosition: [number, number];\n  currentBinId: string | null;\n  dotId: string;\n\n  constructor(config: DraggableDotConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n    this.originalPosition = config.position;\n    this.currentBinId = config.binId || null;\n    this.dotId = config.dotId;\n  }\n\n  render(): JXGElement[] {\n    const x = Number(this.evaluateExpression(this.config.position[0]));\n    const y = Number(this.evaluateExpression(this.config.position[1]));\n    const color = this.config.color || '#3498db';\n    const size = this.config.size || 5;\n\n    this.dot = this.board.create('point', [x, y], {\n      size: size,\n      fillColor: color,\n      strokeColor: color,\n      strokeWidth: 2,\n      fixed: false,\n      withLabel: false,\n      name: '',\n      highlightFillColor: color,\n      highlightStrokeColor: '#000',\n      showInfobox: false,\n      attractors: [], // Will be set by parent\n      attractorDistance: 0.5,\n      snatchDistance: 1.0,\n    });\n\n    this.elements.push(this.dot);\n\n    // Setup drag events\n    this.dot.on('drag', () => {\n      this._onDrag();\n    });\n\n    this.dot.on('up', () => {\n      this._onDragEnd();\n    });\n\n    return this.elements;\n  }\n\n  private _onDrag(): void {\n    // Emit drag event for parent to handle\n    this._emitEvent('dot-drag', {\n      dotId: this.dotId,\n      x: (this.dot as any).X(),\n      y: (this.dot as any).Y(),\n    });\n  }\n\n  private _onDragEnd(): void {\n    // Emit drop event for parent to handle bin assignment\n    this._emitEvent('dot-drop', {\n      dotId: this.dotId,\n      x: (this.dot as any).X(),\n      y: (this.dot as any).Y(),\n      previousBinId: this.currentBinId,\n    });\n  }\n\n  /** Move dot to a specific position */\n  moveTo(x: number, y: number): void {\n    if (this.dot) {\n      (this.dot as any).moveTo([x, y], 200);\n    }\n  }\n\n  /** Set the current bin this dot belongs to */\n  setBinId(binId: string | null): void {\n    this.currentBinId = binId;\n  }\n\n  /** Get current position */\n  getPosition(): [number, number] {\n    if (this.dot) {\n      return [(this.dot as any).X(), (this.dot as any).Y()];\n    }\n    return this.originalPosition;\n  }\n\n  update(variables: Variables): void {\n    this.parentState = { ...this.parentState, ...variables };\n  }\n}\n\nexport default DraggableDot;\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { DropBinConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\n/**\n * DropBin Component - A container that can receive draggable dots\n */\nclass DropBin extends DiagramComponent<DropBinConfig> {\n  binId: string;\n  width: number;\n  height: number;\n  center: [number, number];\n\n  constructor(config: DropBinConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n    this.binId = config.binId;\n    this.width = config.width || 3;\n    this.height = config.height || 3;\n    this.center = [config.position[0], config.position[1]];\n  }\n\n  render(): JXGElement[] {\n    const x = Number(this.evaluateExpression(this.config.position[0]));\n    const y = Number(this.evaluateExpression(this.config.position[1]));\n    this.center = [x, y];\n    \n    const color = this.config.color || '#3498db';\n    const label = this.config.label || '';\n\n    const left = x - this.width / 2;\n    const right = x + this.width / 2;\n    const top = y + this.height / 2;\n    const bottom = y - this.height / 2;\n\n    // Create the four corners of the rectangle\n    const p1 = this.board.create('point', [left, top], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n    const p2 = this.board.create('point', [right, top], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n    const p3 = this.board.create('point', [right, bottom], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n    const p4 = this.board.create('point', [left, bottom], {\n      visible: false,\n      withLabel: false,\n      name: ''\n    });\n\n    // Create the rectangle polygon\n    const rectangle = this.board.create('polygon', [p1, p2, p3, p4], {\n      strokeColor: color,\n      strokeWidth: 3,\n      fillColor: color,\n      fillOpacity: 0.1,\n      vertices: {\n        visible: false,\n        withLabel: false,\n        name: ''\n      },\n      borders: {\n        strokeColor: color,\n        strokeWidth: 3,\n      }\n    });\n\n    this.elements.push(p1, p2, p3, p4, rectangle);\n\n    // Add label below bin\n    if (label) {\n      const labelText = this.board.create('text', [x, bottom - 0.5, label], {\n        fontSize: 16,\n        anchorX: 'middle',\n        anchorY: 'top',\n        fixed: true,\n        cssClass: 'jxg-text-no-pointer',\n      });\n      this.elements.push(labelText);\n    }\n\n    return this.elements;\n  }\n\n  /** Check if a point is inside this bin */\n  containsPoint(px: number, py: number): boolean {\n    const [x, y] = this.center;\n    const halfW = this.width / 2;\n    const halfH = this.height / 2;\n    \n    return px >= x - halfW && px <= x + halfW && \n           py >= y - halfH && py <= y + halfH;\n  }\n\n  /** Get a position for placing a dot at given index */\n  getDotPosition(index: number, totalDots: number): [number, number] {\n    const [cx, cy] = this.center;\n    const margin = 0.4;\n    const availableWidth = this.width - margin * 2;\n    const availableHeight = this.height - margin * 2;\n    \n    // Arrange in a grid pattern\n    const cols = Math.ceil(Math.sqrt(totalDots));\n    const rows = Math.ceil(totalDots / cols);\n    \n    const col = index % cols;\n    const row = Math.floor(index / cols);\n    \n    const spacingX = cols > 1 ? availableWidth / (cols - 1) : 0;\n    const spacingY = rows > 1 ? availableHeight / (rows - 1) : 0;\n    \n    const startX = cx - availableWidth / 2;\n    const startY = cy + availableHeight / 2;\n    \n    const dotX = cols > 1 ? startX + col * spacingX : cx;\n    const dotY = rows > 1 ? startY - row * spacingY : cy;\n    \n    return [dotX, dotY];\n  }\n\n  /** Get bin bounds */\n  getBounds(): { left: number; right: number; top: number; bottom: number } {\n    const [x, y] = this.center;\n    return {\n      left: x - this.width / 2,\n      right: x + this.width / 2,\n      top: y + this.height / 2,\n      bottom: y - this.height / 2,\n    };\n  }\n\n  update(variables: Variables): void {\n    this.parentState = { ...this.parentState, ...variables };\n  }\n}\n\nexport default DropBin;\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport type { DotPoolConfig, Variables, JXGBoard, JXGElement } from '../../types/interfaces';\n\n/** Internal state for a bin */\ninterface BinState {\n  id: string;\n  cx: number;\n  cy: number;\n  width: number;\n  height: number;\n  elements: JXGElement[];\n  dotIds: string[];\n  countLabel?: JXGElement;  // Dynamic count label\n}\n\n/** Internal state for a dot */\ninterface DotState {\n  id: string;\n  point: JXGElement;\n  currentBinId: string;\n}\n\n/**\n * DotPool Component - A fully declarative drag-and-drop dot distribution system\n * \n * Creates a pool of draggable dots in a source bin that can be distributed\n * to multiple target bins. All behavior is automatic based on the config.\n */\nclass DotPool extends DiagramComponent<DotPoolConfig> {\n  private sourceBin: BinState | null = null;\n  private targetBins: BinState[] = [];\n  private dots: DotState[] = [];\n  private lastCount: number = 0;\n  private lastTargetCount: number = 0;\n  private successLabel: JXGElement | null = null;\n  private sourceCountLabel: JXGElement | null = null;\n\n  render(): JXGElement[] {\n    const count = Number(this.evaluateExpression(this.config.count)) || 0;\n    const targetCount = Number(this.evaluateExpression(this.config.targets.count)) || 0;\n    \n    this.lastCount = count;\n    this.lastTargetCount = targetCount;\n\n    // Create source bin\n    this.createSourceBin();\n    \n    // Create target bins\n    this.createTargetBins(targetCount);\n    \n    // Create dots in source bin\n    this.createDots(count);\n    \n    // Create success indicator\n    this.createSuccessIndicator();\n    \n    // Initial count update\n    this.updateAllCounts();\n\n    return this.elements;\n  }\n\n  private createSourceBin(): void {\n    const src = this.config.source;\n    const cx = Number(this.evaluateExpression(src.position[0]));\n    const cy = Number(this.evaluateExpression(src.position[1]));\n    const width = src.width;\n    const height = src.height;\n    const color = src.color || '#3498db';\n    const label = src.label ? String(this.evaluateExpression(src.label)) : '';\n\n    const binElements = this.createBinVisual(cx, cy, width, height, color, label);\n    \n    this.sourceBin = {\n      id: 'source',\n      cx, cy, width, height,\n      elements: binElements,\n      dotIds: []\n    };\n    \n    binElements.forEach(el => this.elements.push(el));\n    \n    // Add count label below source bin (if enabled)\n    const showCounts = this.config.showCounts !== false; // default true\n    if (showCounts) {\n      const halfH = height / 2;\n      this.sourceCountLabel = this.board.create('text', [cx, cy - halfH - 0.6, ''], {\n        fontSize: 16,\n        anchorX: 'middle',\n        anchorY: 'top',\n        fixed: true,\n        cssClass: 'jxg-text-no-pointer'\n      });\n      this.elements.push(this.sourceCountLabel);\n    }\n  }\n\n  private createTargetBins(count: number): void {\n    const cfg = this.config.targets;\n    const startX = cfg.startPosition[0];\n    const startY = cfg.startPosition[1];\n    const width = cfg.width;\n    const height = cfg.height;\n    const color = cfg.color || '#27ae60';\n    const columns = cfg.columns || 5;\n    const spacingX = cfg.spacingX || 3.5;\n    const spacingY = cfg.spacingY || 4;\n    const labelTemplate = cfg.labelTemplate || '';\n    \n    // Get expected count per bin (k)\n    const expectedPerBin = Number(this.evaluateExpression('${k}')) || 0;\n\n    for (let i = 0; i < count; i++) {\n      const col = i % columns;\n      const row = Math.floor(i / columns);\n      const cx = startX + col * spacingX;\n      const cy = startY - row * spacingY;\n      \n      // Evaluate label template with 'i' in context\n      let label = '';\n      if (labelTemplate) {\n        const labelContext = { ...this.getState(), i };\n        label = String(this.evaluateExpressionWithContext(labelTemplate, labelContext));\n      }\n\n      const binElements = this.createBinVisual(cx, cy, width, height, color, label);\n      \n      // Add count label below this target bin (if enabled)\n      const showCounts = this.config.showCounts !== false; // default true\n      let countLabel: JXGElement | undefined;\n      if (showCounts) {\n        const halfH = height / 2;\n        countLabel = this.board.create('text', [cx, cy - halfH - 0.4, ''], {\n          fontSize: 14,\n          anchorX: 'middle',\n          anchorY: 'top',\n          fixed: true,\n          cssClass: 'jxg-text-no-pointer'\n        });\n        binElements.push(countLabel);\n      }\n      \n      const binState: BinState = {\n        id: `target-${i}`,\n        cx, cy, width, height,\n        elements: binElements,\n        dotIds: [],\n        countLabel: countLabel\n      };\n      \n      this.targetBins.push(binState);\n      binElements.forEach(el => this.elements.push(el));\n    }\n  }\n\n  private createBinVisual(cx: number, cy: number, width: number, height: number, color: string, label: string): JXGElement[] {\n    const elements: JXGElement[] = [];\n    const halfW = width / 2;\n    const halfH = height / 2;\n\n    // Corner points (invisible)\n    const p1 = this.board.create('point', [cx - halfW, cy + halfH], { visible: false, withLabel: false, name: '' });\n    const p2 = this.board.create('point', [cx + halfW, cy + halfH], { visible: false, withLabel: false, name: '' });\n    const p3 = this.board.create('point', [cx + halfW, cy - halfH], { visible: false, withLabel: false, name: '' });\n    const p4 = this.board.create('point', [cx - halfW, cy - halfH], { visible: false, withLabel: false, name: '' });\n\n    // Polygon\n    const poly = this.board.create('polygon', [p1, p2, p3, p4], {\n      strokeColor: color,\n      strokeWidth: 3,\n      fillColor: color,\n      fillOpacity: 0.1,\n      vertices: { visible: false, withLabel: false, name: '' }\n    });\n\n    elements.push(p1, p2, p3, p4, poly);\n\n    // Label above bin\n    if (label) {\n      const labelEl = this.board.create('text', [cx, cy + halfH + 0.4, label], {\n        fontSize: 14,\n        anchorX: 'middle',\n        anchorY: 'bottom',\n        fixed: true,\n        cssClass: 'jxg-text-no-pointer'\n      });\n      elements.push(labelEl);\n    }\n\n    return elements;\n  }\n\n  private createDots(count: number): void {\n    const dotColor = this.config.dotColor || '#e74c3c';\n    const dotSize = this.config.dotSize || 5;\n\n    for (let i = 0; i < count; i++) {\n      const dotId = `dot-${i}`;\n      const [x, y] = this.getDotPositionInBin(this.sourceBin!, i, count);\n\n      const point = this.board.create('point', [x, y], {\n        size: dotSize,\n        fillColor: dotColor,\n        strokeColor: dotColor,\n        strokeWidth: 2,\n        fixed: false,\n        withLabel: false,\n        name: '',\n        highlightFillColor: dotColor,\n        highlightStrokeColor: '#000',\n        showInfobox: false\n      });\n\n      const dotState: DotState = {\n        id: dotId,\n        point: point,\n        currentBinId: 'source'\n      };\n\n      // Handle drag end\n      point.on('up', () => this.handleDotDrop(dotState));\n\n      this.dots.push(dotState);\n      this.sourceBin!.dotIds.push(dotId);\n      this.elements.push(point);\n    }\n  }\n\n  private handleDotDrop(dotState: DotState): void {\n    const x = (dotState.point as any).X();\n    const y = (dotState.point as any).Y();\n    const previousBinId = dotState.currentBinId;\n\n    // Find which bin the dot is in\n    let newBinId: string | null = null;\n\n    // Check source bin\n    if (this.isInsideBin(x, y, this.sourceBin!)) {\n      newBinId = 'source';\n    }\n\n    // Check target bins\n    if (!newBinId) {\n      for (const bin of this.targetBins) {\n        if (this.isInsideBin(x, y, bin)) {\n          newBinId = bin.id;\n          break;\n        }\n      }\n    }\n\n    // If dropped outside all bins, snap back to previous\n    if (!newBinId) {\n      this.rearrangeDotsInBin(previousBinId);\n      return;\n    }\n\n    // Update bin assignments if changed\n    if (newBinId !== previousBinId) {\n      // Remove from previous bin\n      const prevBin = this.getBinById(previousBinId);\n      if (prevBin) {\n        const idx = prevBin.dotIds.indexOf(dotState.id);\n        if (idx !== -1) prevBin.dotIds.splice(idx, 1);\n      }\n\n      // Add to new bin\n      const newBin = this.getBinById(newBinId);\n      if (newBin && !newBin.dotIds.includes(dotState.id)) {\n        newBin.dotIds.push(dotState.id);\n      }\n\n      dotState.currentBinId = newBinId;\n\n      // Rearrange both bins\n      this.rearrangeDotsInBin(previousBinId);\n      this.rearrangeDotsInBin(newBinId);\n    } else {\n      // Dropped in same bin - just rearrange\n      this.rearrangeDotsInBin(previousBinId);\n    }\n    \n    // Update all count labels\n    this.updateAllCounts();\n  }\n\n  private isInsideBin(x: number, y: number, bin: BinState): boolean {\n    const halfW = bin.width / 2;\n    const halfH = bin.height / 2;\n    return x >= bin.cx - halfW && x <= bin.cx + halfW &&\n           y >= bin.cy - halfH && y <= bin.cy + halfH;\n  }\n\n  private getBinById(id: string): BinState | null {\n    if (id === 'source') return this.sourceBin;\n    return this.targetBins.find(b => b.id === id) || null;\n  }\n\n  private rearrangeDotsInBin(binId: string): void {\n    const bin = this.getBinById(binId);\n    if (!bin) return;\n\n    const dotsInBin = this.dots.filter(d => d.currentBinId === binId);\n    dotsInBin.forEach((dotState, index) => {\n      const [newX, newY] = this.getDotPositionInBin(bin, index, dotsInBin.length);\n      (dotState.point as any).moveTo([newX, newY], 200);\n    });\n  }\n\n  private getDotPositionInBin(bin: BinState, index: number, total: number): [number, number] {\n    if (total === 0 || total === 1) return [bin.cx, bin.cy];\n\n    const margin = 0.4;\n    const availableWidth = bin.width - margin * 2;\n    const availableHeight = bin.height - margin * 2;\n\n    const cols = Math.ceil(Math.sqrt(total));\n    const rows = Math.ceil(total / cols);\n\n    const col = index % cols;\n    const row = Math.floor(index / cols);\n\n    const spacingX = cols > 1 ? availableWidth / (cols - 1) : 0;\n    const spacingY = rows > 1 ? availableHeight / (rows - 1) : 0;\n\n    const startX = bin.cx - availableWidth / 2;\n    const startY = bin.cy + availableHeight / 2;\n\n    const x = cols > 1 ? startX + col * spacingX : bin.cx;\n    const y = rows > 1 ? startY - row * spacingY : bin.cy;\n\n    return [x, y];\n  }\n\n  /** Evaluate expression with custom context (for label templates) */\n  private evaluateExpressionWithContext(template: string, context: Variables): string | number | boolean {\n    // Simple ${...} replacement\n    return template.replace(/\\$\\{([^}]+)\\}/g, (match, expr) => {\n      try {\n        // Build safe evaluator\n        const keys = Object.keys(context);\n        const values = keys.map(k => context[k]);\n        const func = new Function(...keys, `return (${expr})`);\n        return String(func(...values));\n      } catch (e) {\n        return match;\n      }\n    });\n  }\n\n  /** Create success indicator that shows when division is complete */\n  private createSuccessIndicator(): void {\n    const showSuccessIndicator = this.config.showSuccessIndicator !== false; // default true\n    if (!showSuccessIndicator) return;\n    \n    // Position success label in the center-top area\n    const cfg = this.config.targets;\n    const startX = cfg.startPosition[0];\n    const columns = cfg.columns || 5;\n    const spacingX = cfg.spacingX || 3.5;\n    const centerX = startX + (Math.min(this.lastTargetCount, columns) - 1) * spacingX / 2;\n    \n    this.successLabel = this.board.create('text', [centerX, 10.5, ''], {\n      fontSize: 20,\n      anchorX: 'middle',\n      anchorY: 'middle',\n      fixed: true,\n      cssClass: 'jxg-text-no-pointer'\n    });\n    this.elements.push(this.successLabel);\n  }\n\n  /** Update all count labels and success indicator */\n  private updateAllCounts(): void {\n    const expectedPerBin = Number(this.evaluateExpression('${k}')) || 0;\n    const totalDots = this.lastCount;\n    \n    // Update source bin count\n    const sourceCount = this.sourceBin?.dotIds.length || 0;\n    if (this.sourceCountLabel) {\n      (this.sourceCountLabel as any).setText(`Remaining: ${sourceCount}`);\n    }\n    \n    // Update each target bin count\n    let allCorrect = true;\n    let totalDistributed = 0;\n    \n    for (const bin of this.targetBins) {\n      const count = bin.dotIds.length;\n      totalDistributed += count;\n      \n      const isCorrect = count === expectedPerBin;\n      if (count > 0 && !isCorrect) {\n        allCorrect = false;\n      }\n      if (count === 0) {\n        allCorrect = false;\n      }\n      \n      // Update count label with color coding\n      if (bin.countLabel) {\n        const color = count === 0 ? '#999' : (isCorrect ? '#27ae60' : '#e74c3c');\n        const checkMark = isCorrect ? ' ✓' : (count > expectedPerBin ? ' ↑' : (count > 0 ? ' ↓' : ''));\n        (bin.countLabel as any).setText(`${count}/${expectedPerBin}${checkMark}`);\n        bin.countLabel.setAttribute({ strokeColor: color });\n      }\n    }\n    \n    // Update success indicator\n    if (this.successLabel) {\n      if (allCorrect && sourceCount === 0 && totalDistributed === totalDots) {\n        (this.successLabel as any).setText('🎉 Perfect! Each group has exactly ' + expectedPerBin + ' dots!');\n        this.successLabel.setAttribute({ strokeColor: '#27ae60' });\n      } else if (totalDistributed > 0) {\n        const distributed = totalDots - sourceCount;\n        (this.successLabel as any).setText(`Distributed: ${distributed}/${totalDots}`);\n        this.successLabel.setAttribute({ strokeColor: '#666' });\n      } else {\n        (this.successLabel as any).setText('Drag dots to the group bins →');\n        this.successLabel.setAttribute({ strokeColor: '#999' });\n      }\n    }\n  }\n\n  update(variables: Variables): void {\n    this.parentState = { ...this.parentState, ...variables };\n    \n    const newCount = Number(this.evaluateExpression(this.config.count)) || 0;\n    const newTargetCount = Number(this.evaluateExpression(this.config.targets.count)) || 0;\n    \n    // Only rebuild if counts changed\n    if (newCount !== this.lastCount || newTargetCount !== this.lastTargetCount) {\n      this.destroy();\n      this.sourceBin = null;\n      this.targetBins = [];\n      this.dots = [];\n      this.elements = [];\n      this.successLabel = null;\n      this.sourceCountLabel = null;\n      this.render();\n    }\n  }\n}\n\nexport default DotPool;\n","import { DiagramComponent } from '../../core/DiagramComponent';\nimport { componentRegistry } from '../../core/ComponentRegistry';\nimport type { ResolvedGridLayoutConfig, Variables, JXGBoard, JXGElement, BaseComponentConfig } from '../../types/interfaces';\n\n// Declare global JXG for JSXGraph board creation/destruction\ndeclare const JXG: {\n  JSXGraph: {\n    initBoard(containerId: string, options: object): JXGBoard;\n    freeBoard(board: JXGBoard): void;\n  };\n};\n\n/**\n * Grid Layout Component - Arranges children in a grid pattern\n * \n * REQUIRED at root level: All diagrams must have GridLayout as the root component.\n * \n * Properties:\n * - rowandcolumns: [rows, columns] - Explicit grid dimensions (required)\n * - spacing: number - Space between items (default: 0.5)\n * - spacingX: number - Horizontal spacing (overrides spacing)\n * - spacingY: number - Vertical spacing (overrides spacing)\n * - rowFactors: number[] - Proportional row height factors (optional)\n * - columnFactors: number[] - Proportional column width factors (optional)\n * - sizeFactors: number[] - Apply same factors to both dimensions (optional)\n * - children: array - Child component configurations (each cell can be a single component or an array of components)\n * \n * Sizing Modes:\n * 1. Equal sizing (default): All rows/columns equal size\n * 2. Row height control: Use rowFactors\n * 3. Column width control: Use columnFactors\n * 4. Independent control: Use both rowFactors and columnFactors\n * 5. Unified control: Use sizeFactors for both dimensions\n * \n * Grid Cells:\n * - Each cell can contain either a single child component or an array of components\n * - To stack elements vertically within a cell, use a nested GridLayout with rowandcolumns: [N, 1]\n * - Root GridLayout always fills entire canvas (no position property)\n */\nclass GridLayout extends DiagramComponent<ResolvedGridLayoutConfig> {\n  childComponents: DiagramComponent[];\n  elements: JXGElement[];\n  private _cellBoards: JXGBoard[];\n  private _cellOverlayEl: HTMLElement | null;\n\n  constructor(config: ResolvedGridLayoutConfig, board: JXGBoard, parentState: Variables = {}) {\n    super(config, board, parentState);\n    this.childComponents = [];\n    this.elements = [];\n    this._cellBoards = [];\n    this._cellOverlayEl = null;\n  }\n\n  private _cleanupCellBoards(): void {\n    // Destroy child components first (they refer to their own boards)\n    this.childComponents.forEach(child => child.destroy());\n    this.childComponents = [];\n\n    // Free JSXGraph boards\n    this._cellBoards.forEach(b => {\n      try {\n        JXG.JSXGraph.freeBoard(b);\n      } catch {\n        // Best-effort cleanup\n      }\n    });\n    this._cellBoards = [];\n\n    // Remove overlay DOM\n    if (this._cellOverlayEl && this._cellOverlayEl.parentElement) {\n      this._cellOverlayEl.parentElement.removeChild(this._cellOverlayEl);\n    }\n    this._cellOverlayEl = null;\n  }\n\n  private _invertNormalizedY(value: number | string): number | string {\n    if (typeof value === 'number') {\n      return 1 - value;\n    }\n\n    const trimmed = value.trim();\n    // Numeric strings\n    const asNum = Number(trimmed);\n    if (!Number.isNaN(asNum) && trimmed !== '') {\n      return 1 - asNum;\n    }\n\n    // Expression strings: wrap\n    if (trimmed.startsWith('${') && trimmed.endsWith('}')) {\n      const inner = trimmed.slice(2, -1);\n      return `\\${'{'}1 - (${inner})\\}`;\n    }\n\n    // Fallback: treat as expression-like\n    return `\\${'{'}1 - (${trimmed})\\}`;\n  }\n\n  private _transformConfigForNormalizedUnits(config: any): any {\n    if (!config || typeof config !== 'object') {\n      return config;\n    }\n\n    // Deep clone\n    const cloned = Array.isArray(config) ? config.map(v => this._transformConfigForNormalizedUnits(v)) : { ...config };\n\n    if (Array.isArray(cloned)) {\n      return cloned;\n    }\n\n    const type = cloned.type;\n\n    // Recurse into children/components for containers\n    if (type === 'gridlayout' && Array.isArray(cloned.children)) {\n      cloned.children = cloned.children.map((c: any) => this._transformConfigForNormalizedUnits(c));\n    }\n    if ((type === 'diagram' || type === '2d' || type === '3d') && Array.isArray(cloned.components)) {\n      cloned.components = cloned.components.map((c: any) => this._transformConfigForNormalizedUnits(c));\n    }\n\n    const invertPair = (pair: any): any => {\n      if (!Array.isArray(pair) || pair.length < 2) return pair;\n      return [pair[0], this._invertNormalizedY(pair[1])];\n    };\n\n    // Component-specific coordinate fields (normalized coords assume y grows downward)\n    if (Array.isArray(cloned.position) && cloned.position.length >= 2) {\n      cloned.position = invertPair(cloned.position);\n    }\n    if (Array.isArray(cloned.center) && cloned.center.length >= 2) {\n      cloned.center = invertPair(cloned.center);\n    }\n    if (Array.isArray(cloned.start) && cloned.start.length >= 2) {\n      cloned.start = invertPair(cloned.start);\n    }\n    if (Array.isArray(cloned.end) && cloned.end.length >= 2) {\n      cloned.end = invertPair(cloned.end);\n    }\n    if (Array.isArray(cloned.points) && cloned.points.length >= 2) {\n      cloned.points = cloned.points.map((p: any) => invertPair(p));\n    }\n\n    return cloned;\n  }\n\n  private _needsWideNormalizedBoard(config: any): boolean {\n    if (!config || typeof config !== 'object') {\n      return false;\n    }\n\n    if (Array.isArray(config)) {\n      return config.some(c => this._needsWideNormalizedBoard(c));\n    }\n\n    const type = config.type;\n\n    // TenFrame with integrated slider enabled: we render the slider 2x tenframe width.\n    // That requires a wider normalized board so it doesn't clip.\n    if (type === 'tenframe' && config.slider && config.slider.enabled === true) {\n      const pos = config.slider.position || 'below';\n      return pos === 'below' || pos === 'above';\n    }\n\n    if (type === 'gridlayout' && Array.isArray(config.children)) {\n      return config.children.some((c: any) => this._needsWideNormalizedBoard(c));\n    }\n\n    if ((type === 'diagram' || type === '2d' || type === '3d') && Array.isArray(config.components)) {\n      return config.components.some((c: any) => this._needsWideNormalizedBoard(c));\n    }\n\n    return false;\n  }\n\n  /**\n   * Calculate proportional sizes based on factors\n   * @param factors - Array of proportional factors [1, 2, 1]\n   * @param availableSpace - Total space available for distribution\n   * @param spacing - Space between elements\n   * @returns Array of actual sizes\n   */\n  private calculateProportionalSizes(factors: number[], availableSpace: number, spacing: number): number[] {\n    const count = factors.length;\n    const totalSpacing = (count - 1) * spacing;\n    const contentSpace = availableSpace - totalSpacing;\n    const factorSum = factors.reduce((sum, f) => sum + f, 0);\n    \n    return factors.map(factor => (factor / factorSum) * contentSpace);\n  }\n\n  /**\n   * Get cumulative offsets for positioning\n   * @param sizes - Array of element sizes\n   * @param spacing - Space between elements\n   * @returns Array of cumulative offsets [0, size1+spacing, size1+size2+2*spacing, ...]\n   */\n  private getCumulativeOffsets(sizes: number[], spacing: number): number[] {\n    const offsets: number[] = [0];\n    for (let i = 0; i < sizes.length - 1; i++) {\n      offsets.push(offsets[i] + sizes[i] + spacing);\n    }\n    return offsets;\n  }\n\n  private _getGridDimensions(cellCount: number): { rows: number; columns: number } {\n    const rowandcolumns = (this.config as any).rowandcolumns as unknown;\n    if (!Array.isArray(rowandcolumns) || rowandcolumns.length !== 2) {\n      const legacyColumns = Number((this.config as any).columns);\n      const columns = Number.isInteger(legacyColumns) && legacyColumns > 0\n        ? legacyColumns\n        : 1;\n      return {\n        rows: Math.max(1, Math.ceil(cellCount / columns)),\n        columns,\n      };\n    }\n\n    const [rowsRaw, columnsRaw] = rowandcolumns;\n    const rows = Number(rowsRaw);\n    const columns = Number(columnsRaw);\n\n    if (!Number.isInteger(rows) || rows < 1 || !Number.isInteger(columns) || columns < 1) {\n      throw new Error(`GridLayout rowandcolumns must be two positive integers. Received: ${JSON.stringify(rowandcolumns)}`);\n    }\n\n    const capacity = rows * columns;\n    if (cellCount > capacity) {\n      throw new Error(`GridLayout has ${cellCount} cell(s), but rowandcolumns defines capacity ${rows}x${columns} (${capacity}).`);\n    }\n\n    return { rows, columns };\n  }\n\n  private _createComponentTree(config: BaseComponentConfig, board: JXGBoard, state: Variables): DiagramComponent | null {\n    const component = componentRegistry.create(config, board, state);\n    if (!component) {\n      return null;\n    }\n\n    // Setup event propagation from child to this layout\n    component.onEvent = (event) => {\n      this._emitEvent(event.type, event.detail);\n    };\n\n    const anyConfig = config as any;\n    if (Array.isArray(anyConfig.components)) {\n      anyConfig.components.forEach((childConfig: BaseComponentConfig) => {\n        const child = this._createComponentTree(childConfig, board, component.getState());\n        if (child) {\n          component.addChild(child);\n        }\n      });\n    }\n\n    return component;\n  }\n\n  render(): JXGElement[] {\n    // For root GridLayout, use canvas boundingbox. For nested, use position.\n    const bbox = this.board.getBoundingBox();\n    const isRoot = !this.config.position;\n\n    // Optional multi-board mode: each cell gets its own JSXGraph board.\n    // Currently supported only at the root GridLayout (fills the diagram container).\n    if (isRoot && this.config.multiBoard === true) {\n      this._cleanupCellBoards();\n\n      const containerObj = (this.board as any).containerObj as HTMLElement | undefined;\n      if (!containerObj) {\n        return [];\n      }\n\n      // Overlay grid container above the root board\n      const overlay = document.createElement('div');\n      overlay.style.position = 'absolute';\n      overlay.style.inset = '0';\n      overlay.style.display = 'grid';\n      overlay.style.zIndex = '1';\n      overlay.style.width = '100%';\n      overlay.style.height = '100%';\n      overlay.style.pointerEvents = 'auto';\n\n      // Ensure container is positionable\n      if (getComputedStyle(containerObj).position === 'static') {\n        containerObj.style.position = 'relative';\n      }\n\n      const childConfigs = this.config.children || [];\n      const { rows, columns } = this._getGridDimensions(childConfigs.length);\n\n      overlay.style.gridTemplateColumns = `repeat(${columns}, 1fr)`;\n      overlay.style.gridTemplateRows = `repeat(${rows}, 1fr)`;\n      overlay.style.gap = '0px';\n\n      containerObj.appendChild(overlay);\n      this._cellOverlayEl = overlay;\n\n      const cellUnits = this.config.cellUnits || 'board';\n      const cellFit = this.config.cellFit || 'contain';\n      const debugCellBounds = this.config.debugCellBounds === true;\n\n      childConfigs.forEach((childConfigOrArray, index: number) => {\n        const cell = document.createElement('div');\n        cell.style.width = '100%';\n        cell.style.height = '100%';\n        cell.style.minWidth = '0';\n        cell.style.minHeight = '0';\n        cell.style.overflow = 'hidden';\n        overlay.appendChild(cell);\n\n        // Each cell gets its own board\n        const cellId = `bd_cell_${Math.random().toString(36).slice(2)}`;\n        cell.id = cellId;\n\n        const boardOptions: any = {\n          axis: false,\n          showCopyright: false,\n          showNavigation: false,\n          keepaspectratio: cellFit !== 'stretch',\n          pan: { enabled: false },\n          zoom: { enabled: false },\n        };\n\n        // Handle both single component and array of components for board setup\n        const firstConfig = Array.isArray(childConfigOrArray) ? childConfigOrArray[0] : childConfigOrArray;\n\n        if (cellUnits === 'normalized') {\n          const boardWidth = this._needsWideNormalizedBoard(firstConfig) ? 2 : 1;\n          boardOptions.boundingbox = [0, 1, boardWidth, 0];\n        } else {\n          // Default to the parent board bbox\n          boardOptions.boundingbox = bbox;\n        }\n\n        const cellBoard = JXG.JSXGraph.initBoard(cellId, boardOptions);\n        this._cellBoards.push(cellBoard);\n\n        // Debug: draw the cell board bounding box\n        if (debugCellBounds) {\n          const bb = (cellBoard as any).getBoundingBox?.() as [number, number, number, number] | undefined;\n          const [left, top, right, bottom] = bb || (cellUnits === 'normalized'\n            ? ([0, 1, this._needsWideNormalizedBoard(firstConfig) ? 2 : 1, 0] as [number, number, number, number])\n            : (bbox as unknown as [number, number, number, number]));\n\n          const p1 = cellBoard.create('point', [left, top], { visible: false, fixed: true, withLabel: false, name: '' });\n          const p2 = cellBoard.create('point', [right, top], { visible: false, fixed: true, withLabel: false, name: '' });\n          const p3 = cellBoard.create('point', [right, bottom], { visible: false, fixed: true, withLabel: false, name: '' });\n          const p4 = cellBoard.create('point', [left, bottom], { visible: false, fixed: true, withLabel: false, name: '' });\n          cellBoard.create('polygon', [p1, p2, p3, p4], {\n            fillColor: 'none',\n            fillOpacity: 0,\n            strokeColor: '#ff00ff',\n            strokeOpacity: 0.6,\n            strokeWidth: 2,\n            dash: 2,\n            fixed: true,\n            highlight: false,\n            hasInnerPoints: false,\n            layer: 2,\n            borders: { fixed: true },\n            vertices: { visible: false, fixed: true }\n          });\n        }\n\n        // Handle both single component and array of components\n        const childConfigsInCell = Array.isArray(childConfigOrArray) ? childConfigOrArray : [childConfigOrArray];\n\n        childConfigsInCell.forEach((childConfig) => {\n          if (!componentRegistry.has(childConfig.type)) {\n            return;\n          }\n\n        // Multi-board + normalized units: auto-center components that rely on `position` when omitted.\n        // TenFrame in particular defaults to (0,0) which clips outside the [0,1] cell board.\n        let configForBoardInput: any = childConfig;\n        if (cellUnits === 'normalized') {\n          const anyConfig = childConfig as any;\n          const hasExplicitPosition = Array.isArray(anyConfig.position) && anyConfig.position !== 'auto';\n\n          if (childConfig.type === 'tenframe' && !hasExplicitPosition) {\n            const bb = (cellBoard as any).getBoundingBox?.() as [number, number, number, number] | undefined;\n            const [left, top, right, bottom] = bb || ([0, 1, this._needsWideNormalizedBoard(childConfig) ? 2 : 1, 0] as [number, number, number, number]);\n\n            const cellWidth = right - left;\n            const cellHeight = top - bottom;\n\n            const tenAny = childConfig as any;\n            const mode = tenAny.mode || 'five';\n            const cellsPerRow = mode === 'ten' ? 10 : 5;\n            const cellSize = Number(this.evaluateExpression(tenAny.cellSize ?? 0.8));\n            const cellSpacing = Number(this.evaluateExpression(tenAny.cellSpacing ?? 0.1));\n            const frameWidth = cellsPerRow * (cellSize + cellSpacing) - cellSpacing;\n\n            const rawValue = Number(this.evaluateExpression(tenAny.value ?? 0));\n            const value = Math.max(0, Math.round(Number.isFinite(rawValue) ? rawValue : 0));\n            const maxCapacity = Number(this.evaluateExpression(tenAny.maxCapacity ?? (mode === 'five' ? 15 : 30)));\n            const safeCapacity = Number.isFinite(maxCapacity) && maxCapacity > 0 ? maxCapacity : (mode === 'five' ? 15 : 30);\n            const maxRows = Math.max(1, Math.ceil(safeCapacity / cellsPerRow));\n            const minRows = mode === 'five' ? 2 : 1;\n            const rowsToRender = Math.max(minRows, Math.min(maxRows, Math.ceil(value / cellsPerRow || 1)));\n            const frameHeight = rowsToRender * (cellSize + cellSpacing) - cellSpacing;\n\n            let extraAbove = 0;\n            let extraBelow = 0;\n            if (tenAny.slider && tenAny.slider.enabled === true) {\n              const sliderPos = tenAny.slider.position || 'below';\n              const sliderOffset = Number(this.evaluateExpression(tenAny.slider.offset ?? (cellSize * 0.9)));\n              const tickLabelOffset = Number(this.evaluateExpression(tenAny.slider.tickLabelOffset ?? -(cellSize * 0.6)));\n              const tickTextHeight = cellSize * 0.45;\n              const labelBelowSlider = tenAny.label && (tenAny.labelPosition === 'belowSlider');\n              const labelOffset = Number(this.evaluateExpression(tenAny.labelOffset ?? (cellSize * 0.9)));\n              const labelTextHeight = cellSize * 0.55;\n              const sliderBand = Math.max(cellSize * 0.5, Math.abs(tickLabelOffset) + tickTextHeight);\n              const labelBand = labelBelowSlider ? (labelOffset + labelTextHeight) : 0;\n\n              if (sliderPos === 'below') {\n                extraBelow = Math.max(0, sliderOffset) + sliderBand + labelBand;\n              } else if (sliderPos === 'above') {\n                extraAbove = Math.max(0, sliderOffset) + sliderBand + labelBand;\n              }\n            }\n\n            const effectiveHeight = frameHeight + extraAbove + extraBelow;\n\n            const centeredX = left + Math.max(0, (cellWidth - frameWidth) / 2);\n            const centeredTopMargin = Math.max(0, (cellHeight - effectiveHeight) / 2);\n\n            // Authoring in normalized units assumes y grows downward; it will be inverted by _transformConfigForNormalizedUnits.\n            const yDown = centeredTopMargin + extraAbove;\n\n            configForBoardInput = {\n              ...childConfig,\n              position: [centeredX, yDown]\n            };\n          }\n        }\n\n        const configForBoard =\n          cellUnits === 'normalized'\n            ? this._transformConfigForNormalizedUnits(configForBoardInput)\n            : configForBoardInput;\n\n          const childComponent = this._createComponentTree(configForBoard, cellBoard, this.getState());\n          if (childComponent) {\n            childComponent.render();\n            this.childComponents.push(childComponent);\n          }\n        }); // end forEach childConfigsInCell\n      }); // end forEach childConfigs (cells)\n\n      return [];\n    }\n\n    const startX = this.config.position ? Number(this.evaluateExpression(this.config.position[0])) : bbox[0];\n    const startY = this.config.position ? Number(this.evaluateExpression(this.config.position[1])) : bbox[1];\n    const defaultSpacing = this.config.spacing !== undefined ? this.config.spacing : 0.5;\n    const spacingX = this.config.spacingX !== undefined ? this.config.spacingX : defaultSpacing;\n    const spacingY = this.config.spacingY !== undefined ? this.config.spacingY : defaultSpacing;\n    const childConfigs = this.config.children || [];\n    const { rows, columns } = this._getGridDimensions(childConfigs.length);\n\n    // Determine sizing factors\n    let rowFactors: number[] | undefined;\n    let columnFactors: number[] | undefined;\n\n    if (this.config.sizeFactors) {\n      // Unified mode: same factors for both dimensions\n      rowFactors = this.config.sizeFactors.slice(0, rows);\n      columnFactors = this.config.sizeFactors.slice(0, columns);\n    } else {\n      // Independent mode\n      rowFactors = this.config.rowFactors;\n      columnFactors = this.config.columnFactors;\n    }\n\n    // Fill missing factors with 1.0 (equal sizing)\n    if (rowFactors && rowFactors.length < rows) {\n      rowFactors = [...rowFactors, ...Array(rows - rowFactors.length).fill(1)];\n    }\n    if (columnFactors && columnFactors.length < columns) {\n      columnFactors = [...columnFactors, ...Array(columns - columnFactors.length).fill(1)];\n    }\n\n    // Check if factors are all equal (effectively no proportional sizing needed)\n    const allEqual = (arr: number[]) => arr.every(v => v === arr[0]);\n    const useProportionalColumns = columnFactors && !allEqual(columnFactors);\n    const useProportionalRows = rowFactors && !allEqual(rowFactors);\n\n    // Calculate grid dimensions\n    // Calculate actual sizes and offsets\n    let columnSizes: number[];\n    let columnOffsets: number[];\n    let rowSizes: number[];\n    let rowOffsets: number[];\n\n    const regionWidth = !isRoot && typeof (this.config as any).width === 'number'\n      ? Number((this.config as any).width)\n      : (bbox[2] - bbox[0]);\n    const regionHeight = !isRoot && typeof (this.config as any).height === 'number'\n      ? Number((this.config as any).height)\n      : (bbox[1] - bbox[3]);\n\n    const hasExplicitRegionSize = !isRoot && typeof (this.config as any).width === 'number' && typeof (this.config as any).height === 'number';\n\n    if (useProportionalColumns) {\n      // Proportional column sizing\n      const defaultCellWidth = spacingX;\n      const totalDefaultWidth = columns * defaultCellWidth + (columns - 1) * spacingX;\n      columnSizes = this.calculateProportionalSizes(columnFactors!, totalDefaultWidth, spacingX);\n      columnOffsets = this.getCumulativeOffsets(columnSizes, spacingX);\n    } else if (isRoot || hasExplicitRegionSize) {\n      // Root GridLayout OR nested layout with explicit region size: fill available region width\n      const totalWidth = regionWidth;\n      const totalSpacing = (columns - 1) * spacingX;\n      const cellWidth = (totalWidth - totalSpacing) / columns;\n      columnSizes = Array.from({length: columns}, () => cellWidth);\n      columnOffsets = this.getCumulativeOffsets(columnSizes, spacingX);\n    } else {\n      // Nested GridLayout: spacing defines both cell size and step (backward compatible)\n      // Offsets: 0, spacing, 2*spacing, 3*spacing, ...\n      columnSizes = Array.from({length: columns}, () => spacingX);\n      columnOffsets = Array.from({length: columns}, (_, i) => i * spacingX);\n    }\n\n    if (useProportionalRows) {\n      // Proportional row sizing\n      const defaultCellHeight = spacingY;\n      const totalDefaultHeight = rows * defaultCellHeight + (rows - 1) * spacingY;\n      rowSizes = this.calculateProportionalSizes(rowFactors!, totalDefaultHeight, spacingY);\n      rowOffsets = this.getCumulativeOffsets(rowSizes, spacingY);\n    } else if (isRoot || hasExplicitRegionSize) {\n      // Root GridLayout OR nested layout with explicit region size: fill available region height\n      const totalHeight = regionHeight;\n      const totalSpacing = (rows - 1) * spacingY;\n      const cellHeight = (totalHeight - totalSpacing) / rows;\n      rowSizes = Array.from({length: rows}, () => cellHeight);\n      rowOffsets = this.getCumulativeOffsets(rowSizes, spacingY);\n    } else {\n      // Nested GridLayout: spacing defines both cell size and step (backward compatible)\n      // Offsets: 0, spacing, 2*spacing, 3*spacing, ...\n      rowSizes = Array.from({length: rows}, () => spacingY);\n      rowOffsets = Array.from({length: rows}, (_, i) => i * spacingY);\n    }\n\n    // Clear any existing child components by calling their destroy method\n    this.childComponents.forEach(child => {\n      child.destroy();\n    });\n    this.childComponents = [];\n    this.elements = [];\n\n    // Create each child component at calculated grid positions\n    childConfigs.forEach((childConfigOrArray, index: number) => {\n      const row = Math.floor(index / columns);\n      const col = index % columns;\n      \n      // Calculate cell boundaries\n      const cellX = startX + columnOffsets[col];\n      const cellY = startY - rowOffsets[row];\n      const cellWidth = columnSizes[col];\n      const cellHeight = rowSizes[row];\n\n      // Debug: draw cell bounds on the current board (single-board mode)\n      if (this.config.debugCellBounds === true) {\n        const left = cellX;\n        const top = cellY;\n        const right = cellX + cellWidth;\n        const bottom = cellY - cellHeight;\n\n        const p1 = this.board.create('point', [left, top], { visible: false, fixed: true, withLabel: false, name: '' });\n        const p2 = this.board.create('point', [right, top], { visible: false, fixed: true, withLabel: false, name: '' });\n        const p3 = this.board.create('point', [right, bottom], { visible: false, fixed: true, withLabel: false, name: '' });\n        const p4 = this.board.create('point', [left, bottom], { visible: false, fixed: true, withLabel: false, name: '' });\n        const outline = this.board.create('polygon', [p1, p2, p3, p4], {\n          fillColor: 'none',\n          fillOpacity: 0,\n          strokeColor: '#ff00ff',\n          strokeOpacity: 0.6,\n          strokeWidth: 2,\n          dash: 2,\n          fixed: true,\n          highlight: false,\n          hasInnerPoints: false,\n          layer: 2,\n          borders: { fixed: true },\n          vertices: { visible: false, fixed: true }\n        });\n\n        this.jsxElements.push(p1, p2, p3, p4, outline);\n      }\n\n      // Handle both single component and array of components\n      const childConfigs = Array.isArray(childConfigOrArray) ? childConfigOrArray : [childConfigOrArray];\n\n      childConfigs.forEach((childConfig) => {\n        // Clone child config and determine positioning mode\n        let configWithPosition: any;\n      \n      // Check if child has explicit position (not \"auto\" and exists)\n      const childConfigAny = childConfig as any;\n      const hasExplicitPosition = childConfigAny.position && \n        childConfigAny.position !== 'auto' &&\n        Array.isArray(childConfigAny.position);\n      \n      if (childConfig.type === 'slider') {\n        // Sliders need [x1, y, x2] format\n        if (hasExplicitPosition && childConfigAny.position.length === 3) {\n          // Explicit position - treat as relative to cell origin\n          const [relX1, relY, relX2] = childConfigAny.position as [number, number, number];\n          configWithPosition = {\n            ...childConfig,\n            position: [cellX + relX1, cellY - relY, cellX + relX2]\n          };\n        } else {\n          // Auto-fill mode - span most of cell width\n          const sliderMargin = cellWidth * 0.05;\n          configWithPosition = {\n            ...childConfig,\n            position: [cellX + sliderMargin, cellY - cellHeight / 2, cellX + cellWidth - sliderMargin]\n          };\n        }\n      } else if (childConfig.type === 'gridlayout') {\n        // Nested gridlayouts\n        if (hasExplicitPosition) {\n          // Explicit position - relative to cell origin\n          const [relX, relY] = childConfigAny.position as [number, number];\n          configWithPosition = {\n            ...childConfig,\n            position: [cellX + relX, cellY - relY]\n          };\n        } else {\n          // Auto-fill mode - fill entire cell (this enables centered placement of its children)\n          const gridConfigAny = childConfig as any;\n          configWithPosition = {\n            ...childConfig,\n            position: [cellX, cellY],\n            width: gridConfigAny.width || cellWidth,\n            height: gridConfigAny.height || cellHeight\n          };\n        }\n      } else {\n        // Standard components (tenframe, text, etc.)\n        if (hasExplicitPosition) {\n          // Root GridLayout is used as the required diagram container.\n          // Treat explicit positions as absolute at root level so authors can\n          // place elements in a global coordinate system (SVG-like).\n          // For nested GridLayouts, keep explicit positions relative to cell origin.\n          if (isRoot) {\n            configWithPosition = { ...childConfig };\n          } else {\n            const [relX, relY] = childConfigAny.position as [number, number];\n            configWithPosition = {\n              ...childConfig,\n              position: [cellX + relX, cellY - relY]\n            };\n          }\n        } else {\n          // Auto-fill mode\n          // Most components treat `position` as a center point, but some educational\n          // components (notably `tenframe`) treat it as a top-left anchor.\n          if (childConfig.type === 'tenframe') {\n            const tenAny = childConfig as any;\n            const mode = tenAny.mode || 'five';\n            const cellsPerRow = mode === 'ten' ? 10 : 5;\n            const cellSize = Number(this.evaluateExpression(tenAny.cellSize ?? 0.8));\n            const cellSpacing = Number(this.evaluateExpression(tenAny.cellSpacing ?? 0.1));\n            const frameWidth = cellsPerRow * (cellSize + cellSpacing) - cellSpacing;\n\n            // Estimate the *visible* rows based on the current value and the TenFrame rules.\n            const rawValue = Number(this.evaluateExpression(tenAny.value ?? 0));\n            const value = Math.max(0, Math.round(Number.isFinite(rawValue) ? rawValue : 0));\n            const maxCapacity = Number(this.evaluateExpression(tenAny.maxCapacity ?? (mode === 'five' ? 15 : 30)));\n            const safeCapacity = Number.isFinite(maxCapacity) && maxCapacity > 0 ? maxCapacity : (mode === 'five' ? 15 : 30);\n            const maxRows = Math.max(1, Math.ceil(safeCapacity / cellsPerRow));\n            const minRows = mode === 'five' ? 2 : 1;\n            const rowsToRender = Math.max(minRows, Math.min(maxRows, Math.ceil(value / cellsPerRow || 1)));\n\n            const frameHeight = rowsToRender * (cellSize + cellSpacing) - cellSpacing;\n\n            // If the tenframe includes an integrated slider, it increases the effective footprint.\n            // Center the *combined* visible footprint inside the grid cell.\n            let extraAbove = 0;\n            let extraBelow = 0;\n\n            if (tenAny.slider && tenAny.slider.enabled === true) {\n              const sliderPos = tenAny.slider.position || 'below';\n              const sliderOffset = Number(this.evaluateExpression(tenAny.slider.offset ?? (cellSize * 0.9)));\n              const tickLabelOffset = Number(this.evaluateExpression(tenAny.slider.tickLabelOffset ?? -(cellSize * 0.6)));\n\n              // Rough but stable estimate for tick label text height in user coords.\n              const tickTextHeight = cellSize * 0.45;\n\n              // If TenFrame label is placed below the slider, include that space too.\n              const labelBelowSlider = tenAny.label && (tenAny.labelPosition === 'belowSlider');\n              const labelOffset = Number(this.evaluateExpression(tenAny.labelOffset ?? (cellSize * 0.9)));\n              const labelTextHeight = cellSize * 0.55;\n\n              // slider band thickness (baseline/ticks/labels) below the frame.\n              const sliderBand = Math.max(cellSize * 0.5, Math.abs(tickLabelOffset) + tickTextHeight);\n              const labelBand = labelBelowSlider ? (labelOffset + labelTextHeight) : 0;\n\n              if (sliderPos === 'below') {\n                extraBelow = Math.max(0, sliderOffset) + sliderBand + labelBand;\n              } else if (sliderPos === 'above') {\n                extraAbove = Math.max(0, sliderOffset) + sliderBand + labelBand;\n              }\n            }\n\n            const effectiveHeight = frameHeight + extraAbove + extraBelow;\n\n            // Center the frame within the available cell width (fallback to a small margin).\n            const centeredX = cellX + Math.max(0, (cellWidth - frameWidth) / 2);\n            const centeredTopMargin = Math.max(0, (cellHeight - effectiveHeight) / 2);\n\n            // tenframe uses a top-left anchor.\n            const anchoredY = cellY - centeredTopMargin - extraAbove;\n\n            configWithPosition = {\n              ...childConfig,\n              position: [centeredX, anchoredY],\n              _cellWidth: cellWidth,\n              _cellHeight: cellHeight\n            };\n          } else {\n            // Default: center in cell\n            configWithPosition = {\n              ...childConfig,\n              position: [cellX + cellWidth / 2, cellY - cellHeight / 2],\n              _cellWidth: cellWidth,\n              _cellHeight: cellHeight\n            };\n          }\n        }\n      }\n\n        const childComponent = this._createComponentTree(configWithPosition as BaseComponentConfig, this.board, this.getState());\n        if (childComponent) {\n          const elements = childComponent.render();\n          this.childComponents.push(childComponent);\n\n          if (Array.isArray(elements)) {\n            elements.forEach(el => {\n              if (el && !this.elements.includes(el)) {\n                this.elements.push(el);\n              }\n            });\n          }\n        }\n      }); // end inner forEach (childConfigs in cell)\n    }); // end outer forEach (cells)\n\n    return this.elements;\n  }\n\n  update(variables: Variables): void {\n    const updateTree = (component: DiagramComponent): void => {\n      component.parentState = this.parentState;\n\n      // Avoid destroying/recreating:\n      // - Container components that only group children\n      // - Interactive elements that manage their own state\n      if (!['diagram', '2d', '3d', 'slider'].includes(component.type)) {\n        component.update(variables);\n      }\n\n      // Update children (but gridlayout already updates its own children)\n      if (component.type !== 'gridlayout') {\n        component.children.forEach(child => updateTree(child));\n      }\n    };\n\n    // Merge new variables into parentState (don't replace entirely)\n    this.parentState = { ...this.parentState, ...variables };\n\n    // Multi-board mode: children live on separate boards; push state safely.\n    if (!this.config.position && this.config.multiBoard === true) {\n      this.childComponents.forEach(child => updateTree(child));\n      return;\n    }\n\n    // Single-board mode: update existing children instead of destroying/recreating them\n    this.childComponents.forEach(child => updateTree(child));\n  }\n\n  destroy(): void {\n    this._cleanupCellBoards();\n    super.destroy();\n  }\n}\n\nexport default GridLayout;\n"],"names":["root","factory","exports","module","define","amd","this","Object","defineProperty","value","validate_1","code_1","util_1","additionalProperties_1","def","keyword","type","schemaType","code","cxt","gen","schema","parentSchema","data","it","opts","removeAdditional","undefined","additionalProperties","default","KeywordCxt","allProps","allSchemaProperties","prop","definedProperties","add","unevaluated","length","props","mergeEvaluated","toHash","properties","filter","p","alwaysValidSchema","valid","name","hasDefault","applyPropertySchema","if","propertyInData","ownProperties","allErrors","else","var","endIf","ok","useDefaults","compositeRule","subschema","schemaProp","dataProp","reportTypeError","checkDataTypes","checkDataType","coerceAndCheckDataType","getJSONTypes","getSchemaTypes","DataType","rules_1","applicability_1","errors_1","codegen_1","ts","types","Array","isArray","every","isJSONType","Error","join","includes","nullable","push","coerceTo","coerceTypes","t","COERCIBLE","has","coerceToTypes","checkTypes","schemaHasRulesForType","wrongType","strictNumbers","Wrong","dataType","let","_","coerced","assign","coerceSpecificType","elseIf","parentData","parentDataProperty","expr","assignParentData","coerceData","Set","strictNums","correct","Correct","EQ","operators","NEQ","cond","numCond","not","_cond","nil","and","dataTypes","array","object","notObj","null","number","integer","typeError","message","params","schemaValue","schemaCode","schemaRefOrVal","getTypeErrorContext","reportError","isUUID","URN_REG","supportedSchemeNames","wsIsSecure","wsComponent","secure","scheme","httpParse","component","host","error","httpSerialize","String","toLowerCase","port","path","http","domainHost","parse","serialize","ws","resourceName","query","split","fragment","SCHEMES","https","wss","urn","urnComponent","options","matches","match","nid","nss","schemeHandler","getSchemeHandler","uriComponent","skipEscape","skipNormalize","uuidComponent","uuid","tolerant","setPrototypeOf","isValidSchemeName","indexOf","getRules","jsonTypes","x","groups","rules","string","boolean","post","all","keywords","$data","str","u","unicodeRegExp","regExp","usePattern","fail$data","validateTuple","before","items","validateArray","extraItems","schArr","sch","errSchemaPath","l","fullTuple","minItems","maxItems","strictTuples","msg","checkStrictMode","checkStrictTuple","len","const","forEach","i","dataType_1","equal_1","j","itemTypes","loopN","item","indices","for","break","loopN2","eql","useFunc","outer","label","block$data","setParams","some","comp","op","GT","LT","trackErrors","ifClause","then","hasThen","hasSchema","hasElse","schValid","schCxt","createErrors","validateIf","reset","validateClause","mergeValidEvaluated","pass","regexpCode","getEsmExportName","getProperty","safeStringify","stringify","strConcat","addCodeArg","_Code","Name","IDENTIFIER","_CodeOrName","constructor","s","super","test","toString","emptyStr","names","_items","_a","_str","reduce","c","_names","strs","args","plus","res","mergeExprItems","splice","optimize","arg","a","b","slice","JSON","replace","c1","c2","key","rx","equal","keys","RegExp","source","flags","valueOf","prototype","hasOwnProperty","call","valCxt","instancePath","rootData","dynamicAnchors","vErrors","errors","self","scope","json","jsonPos","jsonLen","jsonPart","id_1","ref_1","core","getData","validateFunctionCode","boolSchema_1","dataType_2","defaults_1","keyword_1","subschema_1","names_1","resolve_1","validateFunction","validateName","schemaEnv","body","es5","func","$async","funcSourceUrl","dynamicRef","destructureValCxtES5","destructureValCxt","schId","schemaId","process","schemaCxtHasRules","RULES","isSchemaObj","checkKeywords","checkUnknownRules","$ref","ignoreKeywordsWithRef","schemaHasRulesButRef","logger","warn","checkRefsAndKeywords","typeAndKeywords","errsCount","jtd","schemaKeywords","commentKeyword","$comment","schemaPath","rootName","scopeValue","ref","typeErrors","groupKeywords","group","shouldUseGroup","iterateKeywords","meta","strictTypes","includesType","strictTypesError","withTypes","narrowSchemaTypes","checkContextTypes","allowUnionTypes","checkMultipleTypes","rule","shouldUseRule","definition","hasApplicableType","kwdT","schTs","checkKeywordTypes","checkStrictTypes","block","keywordCode","assignDefaults","baseId","strictSchema","checkNoDefault","evaluated","resetEvaluated","ValidationError","return","throw","assignEvaluated","returnResults","topSchemaObjCode","topBoolOrEmptySchema","validateKeywordUsage","validSchemaType","allowUndefined","result","condition","successAction","failAction","failResult","fail","or","invalid$data","append","errorParams","errorPaths","_error","reportExtraError","$dataError","keyword$DataError","resetErrorsCount","obj","codeBlock","$dataValid","check$data","validateSchema","st","wrong$DataType","validateSchemaRef","invalid$DataSchema","appl","getSubschema","extendSubschemaData","extendSubschemaMode","nextContext","resolveUrl","uriResolver","updateContext","checkAsyncSchema","subSchemaObjCode","boolOrEmptySchema","subschemaCode","schemaCxt","toName","ruleType","validate","funcKeywordCode","macroKeywordCode","compile","JSON_POINTER","RELATIVE_JSON_POINTER","dataLevel","dataNames","dataPathArr","jsonPointer","exec","up","errorMsg","segments","segment","unescapeJsonPointer","pointerType","min","max","minContains","maxContains","next","validateItemsWithCount","count","validateItems","checkLimits","_valid","forRange","dataPropType","Type","Num","validateSchemaDeps","validatePropertyDeps","property","depsCount","deps","property_ies","missingProperty","propDeps","schDeps","propertyDeps","schemaDeps","splitDependencies","missing","hasProperty","depProp","checkReportMissingProp","checkMissingProp","reportMissingProp","MissingRefError","CodeGen","Ajv","core_1","draft7_1","discriminator_1","draft7MetaSchema","META_SUPPORT_DATA","META_SCHEMA_ID","_addVocabularies","v","addVocabulary","discriminator","addKeyword","_addDefaultMetaSchema","metaSchema","$dataMetaSchema","addMetaSchema","refs","defaultMeta","getSchema","enumerable","get","validation_error_1","ref_error_1","prec","multipleOfPrecision","invalid","ajv","validation","modifyData","useKeyword","macroSchema","macro","schemaRef","topSchemaRef","async","checkAsyncKeyword","validateRef","assignValid","_await","passCxt","passContext","passSchema","callValidateCode","modifying","reportErrs","ruleErrs","try","e","validateAsync","validateErrs","validateSync","errs","extendErrors","addErrs","dependencies","kwd","errorsText","callRef","getValidate","compile_1","env","callRootRef","schOrEnv","resolveRef","SchemaEnv","callValidate","schName","inlineRefSchema","addErrorsFrom","addEvaluatedFrom","schEvaluated","dynamicProps","dynamicItems","callAsyncRef","resolveSchema","getCompilingSchema","compileSchema","normalizeId","localRefs","_sch","rootId","getFullPath","lines","_ValidationError","scopeName","errorPath","sourceCode","_compilations","validateCode","scopeRefs","Function","makeValidate","scopeValues","_values","delete","inlineOrCompile","inlineRef","inlineRefs","schEnv","sameSchemaEnv","s1","s2","resolve","schemas","refPath","_getFullPath","getJsonPointer","id","schOrRef","schOrFunc","PREVENT_SCOPE_CHANGE","parsedRef","part","partSchema","unescapeFragment","ucs2length","pos","charCodeAt","additionalItems_1","prefixItems","validateAdditionalItems","useLoop","loopRequired","loopAllRequired","allErrorsMode","forOf","loopUntilMissing","exitOnErrorMode","strictRequired","requiredKey","noPropertyInData","codegen_2","$dataRefSchema","uri_1","defaultRegExp","META_IGNORE_OPTIONS","EXT_SCOPE_NAMES","removedOptions","errorDataPath","format","jsonPointers","extendRefs","missingRefs","processCode","strictDefaults","strictKeywords","uniqueItems","unknownFormats","cache","ajvErrors","deprecatedOptions","jsPropertySyntax","unicode","requiredOptions","o","_b","_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","loopEnum","messages","addUsedSchema","validateFormats","int32range","formats","_loading","_cache","Map","ValueScope","prefixes","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","missingSchema","missingRef","_loadSchema","addSchema","_validateSchema","_checkUnique","throwOrLogError","keyRef","getSchEnv","removeSchema","_removeAllSchemas","clear","cacheKey","definitions","kwdOrDef","checkKeyword","eachItem","addRule","keywordMetaschema","k","getKeyword","removeKeyword","findIndex","addFormat","separator","dataVar","map","text","keywordsJsonPointers","seg","schemaOrData","regex","getSchemaRefs","set","startsWith","_compileMetaSchema","currentOpts","checkOpts","opt","optsSchemas","defs","metaOpts","KEYWORD_NAME","ruleGroup","find","addBeforeRule","implements","_rule","$dataRef","anyOf","getErrorPath","setEvaluated","evaluatedPropsToName","escapeJsonPointer","escapeFragment","schemaHasRules","makeMergeEvaluated","mergeNames","mergeToName","mergeValues","resultToName","from","to","ps","arr","hash","decodeURIComponent","encodeURIComponent","xs","f","Math","snippets","mode","isNumber","dpType","propertyName","dataContextProps","_nextData","jtdDiscriminator","jtdMetadata","resolver","fmts","fDef","fType","callFormat","validData","invalidFmt","validate$DataFormat","formatDef","unknownMsg","unknownFormat","fmtType","fmtRef","fmtDef","fmt","getFormat","validCondition","validateFormat","bind","isIPv4","stringArrayToHexStripped","input","acc","nonSimpleDomain","consumeIsZone","buffer","consumeHextets","address","output","hex","normalizeIPv6","ind","findToken","isIPV6","ipv6","tokenCount","zone","endipv6Encountered","endIpv6","consume","cursor","getIPV6","newHost","escapedHost","recomposeAuthority","uriTokens","userinfo","unescape","ipV6res","normalizeComponentEncoding","esc","escape","removeDotSegments","nextSlash","pop","util_2","patterns","alwaysValidPatterns","checkProperties","allowMatchingProperties","checkMatchingProperties","pat","validateProperties","forIn","alwaysValid","Str","validatePatternProperties","items_1","validateUnion","schemaProperties","isOwnProperty","hasPropFunc","schemaMap","context","dataAndSchema","newRegExp","pattern","validArr","notValid","ops","KWDs","maximum","okStr","LTE","minimum","GTE","exclusiveMaximum","exclusiveMinimum","uri","validation_1","applicator_1","format_1","metadata_1","draft7Vocabularies","metadataVocabulary","contentVocabulary","passing","prefixItems_1","items2020_1","contains_1","dependencies_1","propertyNames_1","properties_1","patternProperties_1","not_1","anyOf_1","oneOf_1","allOf_1","if_1","thenElse_1","draft2020","applicator","types_1","discrError","tagName","DiscrError","Tag","tag","oneOf","mapping","applyTagSchema","oneOfMapping","topRequired","hasRequired","tagRequired","propSch","addMappings","required","addMapping","enum","tagValue","getMapping","Mapping","validateMapping","traverse","SIMPLE_INLINED","limit","hasRef","countKeys","REF_KEYWORDS","Infinity","normalize","TRAILING_SLASH_HASH","ANCHOR","baseIds","pathPrefix","schemaRefs","allKeys","jsonPtr","parentJsonPtr","fullPath","innerBaseId","addRef","_resolve","ambiguos","checkAmbiguosRef","addAnchor","anchor","$anchor","$dynamicAnchor","sch1","sch2","limitNumber_1","multipleOf_1","limitLength_1","pattern_1","limitProperties_1","required_1","limitItems_1","uniqueItems_1","const_1","enum_1","cb","_traverse","pre","rootSchema","parentKeyword","keyIndex","arrayKeywords","propsKeywords","escapeJsonPtr","skipKeywords","additionalItems","contains","propertyNames","allOf","$defs","patternProperties","multipleOf","maxLength","minLength","maxProperties","minProperties","ucs2length_1","ValueScopeName","Scope","varKinds","UsedValueState","ValueError","parent","_prefixes","_parent","nameOrPrefix","prefix","_newName","_nameGroup","index","nameStr","setValue","itemIndex","scopePath","line","_scope","_n","valueKey","vs","_name","getValue","keyOrRef","values","_reduceValues","scopeCode","usedValues","getCode","valueCode","nameSet","Started","Completed","assignDefault","defaultValue","childData","ty","resolveComponent","base","relative","skipNormalization","target","lastIndexOf","cmpts","reference","authority","absolutePath","URI_PARSE","parsed","isIP","parseInt","isNaN","ipv6result","unicodeSupport","URL","domainToASCII","encodeURI","fastUri","baseURI","relativeURI","schemelessOptions","resolved","uriA","uriB","getEql","vSchema","equalCode","additionalProperty","patProps","deleteAdditional","additionalPropertyCode","applyAdditionalSchema","definedProp","propsSchema","isAdditional","keywordError","addError","errObj","err","returnErrors","overrideAllErrors","errorObjectCode","verbose","E","keyValues","errorInstancePath","errorSchemaPath","extraErrorProps","errorObject","instPath","schPath","boolError","falseSchemaError","scope_1","code_2","scope_2","NOT","OR","AND","ADD","Node","optimizeNodes","optimizeNames","_constants","Def","varKind","rhs","render","constants","optimizeExpr","Assign","lhs","sideEffects","addExprNames","AssignOp","Label","Break","Throw","AnyCode","ParentNode","nodes","n","subtractNames","addNames","BlockNode","Root","Else","kind","If","ns","For","ForLoop","iteration","ForRange","ForIter","loop","iterable","Func","Return","Try","catch","finally","Catch","Finally","replaceName","par","extScope","_blockStarts","_extScope","_nodes","_root","prefixOrName","getScopeValue","_def","constant","_leafNode","_constant","thenBody","elseBody","_blockNode","_elseNode","_endBlockNode","_for","node","forBody","endFor","tryBody","catchCode","finallyCode","_currNode","nodeCount","endBlock","toClose","funcBody","endFunc","N1","N2","andCode","mappend","orCode","y","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","d","componentRegistry","components","register","componentClass","create","config","board","parentState","ComponentClass","getTypes","DiagramEvent","detail","consumed","timestamp","Date","now","isConsumed","EventSystem","listeners","on","handler","off","handlers","emit","event","bubblePath","handleEvent","createEvent","SchemaValidator","validateDiagram","formatErrors","validateOrThrow","errorMessages","ValidationException","getErrorMessage","schemaValidator","isGridLayoutConfig","BlitzDiagram","HTMLElement","rootComponent","variables","debug","eventSystem","_ensureGlobalStyles","connectedCallback","setTimeout","_getConfig","_initialize","_showError","disconnectedCallback","_cleanup","runtimeConfig","resolving","resolveItem","itemName","occurrencePath","itemConfig","instanceId","makeInstanceId","cells","columnCount","children","rowIndex","row","entries","columnIndex","childRef","trim","rowandcolumns","rootItem","resolvedRoot","resolveDiagramConfig","container","document","createElement","_generateId","style","width","height","appendChild","canvas","boundingbox","JXG","JSXGraph","initBoard","axis","showAxes","showCopyright","showNavigation","keepaspectratio","pan","enabled","zoom","_createComponentTree","dispatchEvent","CustomEvent","getElementById","textContent","head","state","onEvent","_handleComponentEvent","configWithComponents","childConfig","child","getState","addChild","_setupBoardEvents","evt","coords","_getCoords","_handleBoardEvent","_hitTest","_buildBubblePath","bubbles","_updateComponentTree","update","hits","testComponent","hitTest","sort","getSpecificity","getMousePosition","Coords","COORDS_BY_SCREEN","usrCoords","dataConfig","getAttribute","normalizedConfig","script","querySelector","jsonText","destroy","freeBoard","innerHTML","random","substr","getVariable","getVariables","setVariable","evaluateSafeExpression","parseFloat","safeContext","varNamePattern","varName","mathFunctions","abs","floor","ceil","round","sqrt","dangerousPattern","dangerous","containsDangerousPatterns","DiagramComponent","localState","elements","jsxElements","eventHandlers","isDragging","newState","_rerender","el","objects","removeObject","hasPoint","point","circle","polygon","_emitEvent","evaluateExpression","expression","template","singleExprMatch","Diagram","Point","position","coordinates","isMovable","movable","attributes","size","fillColor","color","strokeColor","fixed","layer","xVariable","X","yVariable","Y","updatedLabel","setLabel","Number","moveTo","setCoordinates","COORDS_BY_USER","Square","widthExpr","heightExpr","numWidth","numHeight","numX","numY","points","strokeWidth","fillOpacity","borders","vertices","visible","withLabel","square","area","Slider","isInitializing","x1","y1","x2","y2","initialValue","snapWidth","gliderColor","gliderOpacity","gliderSize","slider","highlightStrokeColor","highlightFillColor","precision","withTicks","ticks","baseline","tickColor","strokeOpacity","highline","point1","point2","labelY","fontSize","anchorX","anchorY","highlight","cssClass","showTicks","tickStep","showTickLabels","tickLabelSize","tickLabelColor","tickLabelOffset","safeRange","tickSpacingX","tickHalfLength","tickX","tickY","tickMark","variable","rawValue","Value","initValue","newValue","p1","start","p2","end","straightFirst","extend","straightLast","setPosition","center","radius","cx","cy","numRadius","PI","xMin","xMax","yMin","yMax","step","ensureCssClass","existing","cls","showPoints","_normalizeAnchorX","_normalizeAnchorY","_lastContent","content","fontWeight","align","valign","newContent","setText","_updateTimeout","_lastValue","_slider","cellsPerRow","maxCapacity","cellSize","cellSpacing","emptyColor","evaluatedColorMap","colorMap","maxRows","minRows","rowsToRender","frameWidth","frameHeight","col","cellIndex","cellX","cellY","cellFillColor","accumulated","p3","p4","rect","hasInnerPoints","sliderLayout","_renderSlider","labelText","labelX","labelPosition","defaultAboveOffset","defaultBelowOffset","defaultBelowSliderOffset","labelOffset","offset","sliderY","labelSize","labelColor","_frameHeight","sliderConfig","sliderX1","sliderX2","sliderWidth","sliderComponentConfig","newConfig","clearTimeout","left","right","top","bottom","rectangle","cols","rows","dotSpacingX","dotSpacingY","dotIndex","dotsInRow","dotX","dotY","dot","objectsList","originalPosition","currentBinId","binId","dotId","showInfobox","attractors","attractorDistance","snatchDistance","_onDrag","_onDragEnd","previousBinId","setBinId","getPosition","containsPoint","px","py","halfW","halfH","getDotPosition","totalDots","availableWidth","margin","availableHeight","getBounds","sourceBin","targetBins","dots","lastCount","lastTargetCount","successLabel","sourceCountLabel","targetCount","targets","createSourceBin","createTargetBins","createDots","createSuccessIndicator","updateAllCounts","src","binElements","createBinVisual","dotIds","showCounts","cfg","startX","startPosition","startY","columns","spacingX","spacingY","labelTemplate","labelContext","evaluateExpressionWithContext","countLabel","binState","poly","labelEl","dotColor","dotSize","getDotPositionInBin","dotState","handleDotDrop","newBinId","isInsideBin","bin","prevBin","getBinById","idx","newBin","rearrangeDotsInBin","dotsInBin","newX","newY","total","showSuccessIndicator","centerX","expectedPerBin","sourceCount","allCorrect","totalDistributed","isCorrect","checkMark","setAttribute","distributed","newCount","newTargetCount","childComponents","_cellBoards","_cellOverlayEl","_cleanupCellBoards","parentElement","removeChild","_invertNormalizedY","trimmed","asNum","endsWith","_transformConfigForNormalizedUnits","cloned","invertPair","pair","_needsWideNormalizedBoard","calculateProportionalSizes","factors","availableSpace","spacing","contentSpace","factorSum","sum","factor","getCumulativeOffsets","sizes","offsets","_getGridDimensions","cellCount","legacyColumns","isInteger","rowsRaw","columnsRaw","capacity","anyConfig","bbox","getBoundingBox","isRoot","multiBoard","containerObj","overlay","inset","display","zIndex","pointerEvents","getComputedStyle","childConfigs","gridTemplateColumns","gridTemplateRows","gap","cellUnits","cellFit","debugCellBounds","childConfigOrArray","cell","minWidth","minHeight","overflow","cellId","boardOptions","firstConfig","boardWidth","cellBoard","bb","dash","configForBoardInput","hasExplicitPosition","cellWidth","cellHeight","tenAny","isFinite","safeCapacity","extraAbove","extraBelow","sliderPos","sliderOffset","tickTextHeight","labelBelowSlider","labelTextHeight","sliderBand","labelBand","effectiveHeight","centeredX","yDown","configForBoard","childComponent","defaultSpacing","rowFactors","columnFactors","sizeFactors","fill","allEqual","useProportionalColumns","useProportionalRows","columnSizes","columnOffsets","rowSizes","rowOffsets","regionWidth","regionHeight","hasExplicitRegionSize","totalDefaultWidth","totalDefaultHeight","outline","configWithPosition","childConfigAny","relX1","relY","relX2","sliderMargin","relX","gridConfigAny","centeredTopMargin","anchoredY","_cellWidth","_cellHeight","updateTree","window","customElements"],"ignoreList":[],"sourceRoot":""}