Brunobkr/llama.cpp_AlgMor24_github

1"use strict";2Object.defineProperty(exports, "__esModule", { value: true });3exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;4var validate_1 = require("./compile/validate");5Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });6var codegen_1 = require("./compile/codegen");7Object.defineProperty(exports, "_", { enumerable: true, get: function () { return codegen_1._; } });8Object.defineProperty(exports, "str", { enumerable: true, get: function () { return codegen_1.str; } });9Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });10Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return codegen_1.nil; } });11Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return codegen_1.Name; } });12Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return codegen_1.CodeGen; } });13const validation_error_1 = require("./runtime/validation_error");14const ref_error_1 = require("./compile/ref_error");15const rules_1 = require("./compile/rules");16const compile_1 = require("./compile");17const codegen_2 = require("./compile/codegen");18const resolve_1 = require("./compile/resolve");19const dataType_1 = require("./compile/validate/dataType");20const util_1 = require("./compile/util");21const $dataRefSchema = require("./refs/data.json");22const uri_1 = require("./runtime/uri");23const defaultRegExp = (str, flags) => new RegExp(str, flags);24defaultRegExp.code = "new RegExp";25const META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];26const EXT_SCOPE_NAMES = new Set([27    "validate",28    "serialize",29    "parse",30    "wrapper",31    "root",32    "schema",33    "keyword",34    "pattern",35    "formats",36    "validate$data",37    "func",38    "obj",39    "Error",40]);41const removedOptions = {42    errorDataPath: "",43    format: "`validateFormats: false` can be used instead.",44    nullable: '"nullable" keyword is supported by default.',45    jsonPointers: "Deprecated jsPropertySyntax can be used instead.",46    extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",47    missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",48    processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",49    sourceCode: "Use option `code: {source: true}`",50    strictDefaults: "It is default now, see option `strict`.",51    strictKeywords: "It is default now, see option `strict`.",52    uniqueItems: '"uniqueItems" keyword is always validated.',53    unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",54    cache: "Map is used as cache, schema object as key.",55    serialize: "Map is used as cache, schema object as key.",56    ajvErrors: "It is default now.",57};58const deprecatedOptions = {59    ignoreKeywordsWithRef: "",60    jsPropertySyntax: "",61    unicode: '"minLength"/"maxLength" account for unicode characters by default.',62};63const MAX_EXPRESSION = 200;64// eslint-disable-next-line complexity65function requiredOptions(o) {66    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;67    const s = o.strict;68    const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;69    const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0;70    const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;71    const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;72    return {73        strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,74        strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,75        strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",76        strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",77        strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,78        code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },79        loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,80        loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,81        meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,82        messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,83        inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,84        schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",85        addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,86        validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,87        validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,88        unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,89        int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,90        uriResolver: uriResolver,91    };92}93class Ajv {94    constructor(opts = {}) {95        this.schemas = {};96        this.refs = {};97        this.formats = Object.create(null);98        this._compilations = new Set();99        this._loading = {};100        this._cache = new Map();101        opts = this.opts = { ...opts, ...requiredOptions(opts) };102        const { es5, lines } = this.opts.code;103        this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });104        this.logger = getLogger(opts.logger);105        const formatOpt = opts.validateFormats;106        opts.validateFormats = false;107        this.RULES = (0, rules_1.getRules)();108        checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");109        checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");110        this._metaOpts = getMetaSchemaOptions.call(this);111        if (opts.formats)112            addInitialFormats.call(this);113        this._addVocabularies();114        this._addDefaultMetaSchema();115        if (opts.keywords)116            addInitialKeywords.call(this, opts.keywords);117        if (typeof opts.meta == "object")118            this.addMetaSchema(opts.meta);119        addInitialSchemas.call(this);120        opts.validateFormats = formatOpt;121    }122    _addVocabularies() {123        this.addKeyword("$async");124    }125    _addDefaultMetaSchema() {126        const { $data, meta, schemaId } = this.opts;127        let _dataRefSchema = $dataRefSchema;128        if (schemaId === "id") {129            _dataRefSchema = { ...$dataRefSchema };130            _dataRefSchema.id = _dataRefSchema.$id;131            delete _dataRefSchema.$id;132        }133        if (meta && $data)134            this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);135    }136    defaultMeta() {137        const { meta, schemaId } = this.opts;138        return (this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : undefined);139    }140    validate(schemaKeyRef, // key, ref or schema object141    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents142    data // to be validated143    ) {144        let v;145        if (typeof schemaKeyRef == "string") {146            v = this.getSchema(schemaKeyRef);147            if (!v)148                throw new Error(`no schema with key or ref "${schemaKeyRef}"`);149        }150        else {151            v = this.compile(schemaKeyRef);152        }153        const valid = v(data);154        if (!("$async" in v))155            this.errors = v.errors;156        return valid;157    }158    compile(schema, _meta) {159        const sch = this._addSchema(schema, _meta);160        return (sch.validate || this._compileSchemaEnv(sch));161    }162    compileAsync(schema, meta) {163        if (typeof this.opts.loadSchema != "function") {164            throw new Error("options.loadSchema should be a function");165        }166        const { loadSchema } = this.opts;167        return runCompileAsync.call(this, schema, meta);168        async function runCompileAsync(_schema, _meta) {169            await loadMetaSchema.call(this, _schema.$schema);170            const sch = this._addSchema(_schema, _meta);171            return sch.validate || _compileAsync.call(this, sch);172        }173        async function loadMetaSchema($ref) {174            if ($ref && !this.getSchema($ref)) {175                await runCompileAsync.call(this, { $ref }, true);176            }177        }178        async function _compileAsync(sch) {179            try {180                return this._compileSchemaEnv(sch);181            }182            catch (e) {183                if (!(e instanceof ref_error_1.default))184                    throw e;185                checkLoaded.call(this, e);186                await loadMissingSchema.call(this, e.missingSchema);187                return _compileAsync.call(this, sch);188            }189        }190        function checkLoaded({ missingSchema: ref, missingRef }) {191            if (this.refs[ref]) {192                throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);193            }194        }195        async function loadMissingSchema(ref) {196            const _schema = await _loadSchema.call(this, ref);197            if (!this.refs[ref])198                await loadMetaSchema.call(this, _schema.$schema);199            if (!this.refs[ref])200                this.addSchema(_schema, ref, meta);201        }202        async function _loadSchema(ref) {203            const p = this._loading[ref];204            if (p)205                return p;206            try {207                return await (this._loading[ref] = loadSchema(ref));208            }209            finally {210                delete this._loading[ref];211            }212        }213    }214    // Adds schema to the instance215    addSchema(schema, // If array is passed, `key` will be ignored216    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`.217    _meta, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.218    _validateSchema = this.opts.validateSchema // false to skip schema validation. Used internally, option validateSchema should be used instead.219    ) {220        if (Array.isArray(schema)) {221            for (const sch of schema)222                this.addSchema(sch, undefined, _meta, _validateSchema);223            return this;224        }225        let id;226        if (typeof schema === "object") {227            const { schemaId } = this.opts;228            id = schema[schemaId];229            if (id !== undefined && typeof id != "string") {230                throw new Error(`schema ${schemaId} must be string`);231            }232        }233        key = (0, resolve_1.normalizeId)(key || id);234        this._checkUnique(key);235        this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);236        return this;237    }238    // Add schema that will be used to validate other schemas239    // options in META_IGNORE_OPTIONS are alway set to false240    addMetaSchema(schema, key, // schema key241    _validateSchema = this.opts.validateSchema // false to skip schema validation, can be used to override validateSchema option for meta-schema242    ) {243        this.addSchema(schema, key, true, _validateSchema);244        return this;245    }246    //  Validate schema against its meta-schema247    validateSchema(schema, throwOrLogError) {248        if (typeof schema == "boolean")249            return true;250        let $schema;251        $schema = schema.$schema;252        if ($schema !== undefined && typeof $schema != "string") {253            throw new Error("$schema must be a string");254        }255        $schema = $schema || this.opts.defaultMeta || this.defaultMeta();256        if (!$schema) {257            this.logger.warn("meta-schema not available");258            this.errors = null;259            return true;260        }261        const valid = this.validate($schema, schema);262        if (!valid && throwOrLogError) {263            const message = "schema is invalid: " + this.errorsText();264            if (this.opts.validateSchema === "log")265                this.logger.error(message);266            else267                throw new Error(message);268        }269        return valid;270    }271    // Get compiled schema by `key` or `ref`.272    // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)273    getSchema(keyRef) {274        let sch;275        while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")276            keyRef = sch;277        if (sch === undefined) {278            const { schemaId } = this.opts;279            const root = new compile_1.SchemaEnv({ schema: {}, schemaId });280            sch = compile_1.resolveSchema.call(this, root, keyRef);281            if (!sch)282                return;283            this.refs[keyRef] = sch;284        }285        return (sch.validate || this._compileSchemaEnv(sch));286    }287    // Remove cached schema(s).288    // If no parameter is passed all schemas but meta-schemas are removed.289    // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.290    // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.291    removeSchema(schemaKeyRef) {292        if (schemaKeyRef instanceof RegExp) {293            this._removeAllSchemas(this.schemas, schemaKeyRef);294            this._removeAllSchemas(this.refs, schemaKeyRef);295            return this;296        }297        switch (typeof schemaKeyRef) {298            case "undefined":299                this._removeAllSchemas(this.schemas);300                this._removeAllSchemas(this.refs);301                this._cache.clear();302                return this;303            case "string": {304                const sch = getSchEnv.call(this, schemaKeyRef);305                if (typeof sch == "object")306                    this._cache.delete(sch.schema);307                delete this.schemas[schemaKeyRef];308                delete this.refs[schemaKeyRef];309                return this;310            }311            case "object": {312                const cacheKey = schemaKeyRef;313                this._cache.delete(cacheKey);314                let id = schemaKeyRef[this.opts.schemaId];315                if (id) {316                    id = (0, resolve_1.normalizeId)(id);317                    delete this.schemas[id];318                    delete this.refs[id];319                }320                return this;321            }322            default:323                throw new Error("ajv.removeSchema: invalid parameter");324        }325    }326    // add "vocabulary" - a collection of keywords327    addVocabulary(definitions) {328        for (const def of definitions)329            this.addKeyword(def);330        return this;331    }332    addKeyword(kwdOrDef, def // deprecated333    ) {334        let keyword;335        if (typeof kwdOrDef == "string") {336            keyword = kwdOrDef;337            if (typeof def == "object") {338                this.logger.warn("these parameters are deprecated, see docs for addKeyword");339                def.keyword = keyword;340            }341        }342        else if (typeof kwdOrDef == "object" && def === undefined) {343            def = kwdOrDef;344            keyword = def.keyword;345            if (Array.isArray(keyword) && !keyword.length) {346                throw new Error("addKeywords: keyword must be string or non-empty array");347            }348        }349        else {350            throw new Error("invalid addKeywords parameters");351        }352        checkKeyword.call(this, keyword, def);353        if (!def) {354            (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));355            return this;356        }357        keywordMetaschema.call(this, def);358        const definition = {359            ...def,360            type: (0, dataType_1.getJSONTypes)(def.type),361            schemaType: (0, dataType_1.getJSONTypes)(def.schemaType),362        };363        (0, util_1.eachItem)(keyword, definition.type.length === 0364            ? (k) => addRule.call(this, k, definition)365            : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));366        return this;367    }368    getKeyword(keyword) {369        const rule = this.RULES.all[keyword];370        return typeof rule == "object" ? rule.definition : !!rule;371    }372    // Remove keyword373    removeKeyword(keyword) {374        // TODO return type should be Ajv375        const { RULES } = this;376        delete RULES.keywords[keyword];377        delete RULES.all[keyword];378        for (const group of RULES.rules) {379            const i = group.rules.findIndex((rule) => rule.keyword === keyword);380            if (i >= 0)381                group.rules.splice(i, 1);382        }383        return this;384    }385    // Add format386    addFormat(name, format) {387        if (typeof format == "string")388            format = new RegExp(format);389        this.formats[name] = format;390        return this;391    }392    errorsText(errors = this.errors, // optional array of validation errors393    { separator = ", ", dataVar = "data" } = {} // optional options with properties `separator` and `dataVar`394    ) {395        if (!errors || errors.length === 0)396            return "No errors";397        return errors398            .map((e) => `${dataVar}${e.instancePath} ${e.message}`)399            .reduce((text, msg) => text + separator + msg);400    }401    $dataMetaSchema(metaSchema, keywordsJsonPointers) {402        const rules = this.RULES.all;403        metaSchema = JSON.parse(JSON.stringify(metaSchema));404        for (const jsonPointer of keywordsJsonPointers) {405            const segments = jsonPointer.split("/").slice(1); // first segment is an empty string406            let keywords = metaSchema;407            for (const seg of segments)408                keywords = keywords[seg];409            for (const key in rules) {410                const rule = rules[key];411                if (typeof rule != "object")412                    continue;413                const { $data } = rule.definition;414                const schema = keywords[key];415                if ($data && schema)416                    keywords[key] = schemaOrData(schema);417            }418        }419        return metaSchema;420    }421    _removeAllSchemas(schemas, regex) {422        for (const keyRef in schemas) {423            const sch = schemas[keyRef];424            if (!regex || regex.test(keyRef)) {425                if (typeof sch == "string") {426                    delete schemas[keyRef];427                }428                else if (sch && !sch.meta) {429                    this._cache.delete(sch.schema);430                    delete schemas[keyRef];431                }432            }433        }434    }435    _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {436        let id;437        const { schemaId } = this.opts;438        if (typeof schema == "object") {439            id = schema[schemaId];440        }441        else {442            if (this.opts.jtd)443                throw new Error("schema must be object");444            else if (typeof schema != "boolean")445                throw new Error("schema must be object or boolean");446        }447        let sch = this._cache.get(schema);448        if (sch !== undefined)449            return sch;450        baseId = (0, resolve_1.normalizeId)(id || baseId);451        const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);452        sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });453        this._cache.set(sch.schema, sch);454        if (addSchema && !baseId.startsWith("#")) {455            // TODO atm it is allowed to overwrite schemas without id (instead of not adding them)456            if (baseId)457                this._checkUnique(baseId);458            this.refs[baseId] = sch;459        }460        if (validateSchema)461            this.validateSchema(schema, true);462        return sch;463    }464    _checkUnique(id) {465        if (this.schemas[id] || this.refs[id]) {466            throw new Error(`schema with key or id "${id}" already exists`);467        }468    }469    _compileSchemaEnv(sch) {470        if (sch.meta)471            this._compileMetaSchema(sch);472        else473            compile_1.compileSchema.call(this, sch);474        /* istanbul ignore if */475        if (!sch.validate)476            throw new Error("ajv implementation error");477        return sch.validate;478    }479    _compileMetaSchema(sch) {480        const currentOpts = this.opts;481        this.opts = this._metaOpts;482        try {483            compile_1.compileSchema.call(this, sch);484        }485        finally {486            this.opts = currentOpts;487        }488    }489}490Ajv.ValidationError = validation_error_1.default;491Ajv.MissingRefError = ref_error_1.default;492exports.default = Ajv;493function checkOptions(checkOpts, options, msg, log = "error") {494    for (const key in checkOpts) {495        const opt = key;496        if (opt in options)497            this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);498    }499}500function getSchEnv(keyRef) {501    keyRef = (0, resolve_1.normalizeId)(keyRef); // TODO tests fail without this line502    return this.schemas[keyRef] || this.refs[keyRef];503}504function addInitialSchemas() {505    const optsSchemas = this.opts.schemas;506    if (!optsSchemas)507        return;508    if (Array.isArray(optsSchemas))509        this.addSchema(optsSchemas);510    else511        for (const key in optsSchemas)512            this.addSchema(optsSchemas[key], key);513}514function addInitialFormats() {515    for (const name in this.opts.formats) {516        const format = this.opts.formats[name];517        if (format)518            this.addFormat(name, format);519    }520}521function addInitialKeywords(defs) {522    if (Array.isArray(defs)) {523        this.addVocabulary(defs);524        return;525    }526    this.logger.warn("keywords option as map is deprecated, pass array");527    for (const keyword in defs) {528        const def = defs[keyword];529        if (!def.keyword)530            def.keyword = keyword;531        this.addKeyword(def);532    }533}534function getMetaSchemaOptions() {535    const metaOpts = { ...this.opts };536    for (const opt of META_IGNORE_OPTIONS)537        delete metaOpts[opt];538    return metaOpts;539}540const noLogs = { log() { }, warn() { }, error() { } };541function getLogger(logger) {542    if (logger === false)543        return noLogs;544    if (logger === undefined)545        return console;546    if (logger.log && logger.warn && logger.error)547        return logger;548    throw new Error("logger must implement log, warn and error methods");549}550const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;551function checkKeyword(keyword, def) {552    const { RULES } = this;553    (0, util_1.eachItem)(keyword, (kwd) => {554        if (RULES.keywords[kwd])555            throw new Error(`Keyword ${kwd} is already defined`);556        if (!KEYWORD_NAME.test(kwd))557            throw new Error(`Keyword ${kwd} has invalid name`);558    });559    if (!def)560        return;561    if (def.$data && !("code" in def || "validate" in def)) {562        throw new Error('$data keyword must have "code" or "validate" function');563    }564}565function addRule(keyword, definition, dataType) {566    var _a;567    const post = definition === null || definition === void 0 ? void 0 : definition.post;568    if (dataType && post)569        throw new Error('keyword with "post" flag cannot have "type"');570    const { RULES } = this;571    let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);572    if (!ruleGroup) {573        ruleGroup = { type: dataType, rules: [] };574        RULES.rules.push(ruleGroup);575    }576    RULES.keywords[keyword] = true;577    if (!definition)578        return;579    const rule = {580        keyword,581        definition: {582            ...definition,583            type: (0, dataType_1.getJSONTypes)(definition.type),584            schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType),585        },586    };587    if (definition.before)588        addBeforeRule.call(this, ruleGroup, rule, definition.before);589    else590        ruleGroup.rules.push(rule);591    RULES.all[keyword] = rule;592    (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));593}594function addBeforeRule(ruleGroup, rule, before) {595    const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);596    if (i >= 0) {597        ruleGroup.rules.splice(i, 0, rule);598    }599    else {600        ruleGroup.rules.push(rule);601        this.logger.warn(`rule ${before} is not defined`);602    }603}604function keywordMetaschema(def) {605    let { metaSchema } = def;606    if (metaSchema === undefined)607        return;608    if (def.$data && this.opts.$data)609        metaSchema = schemaOrData(metaSchema);610    def.validateSchema = this.compile(metaSchema, true);611}612const $dataRef = {613    $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",614};615function schemaOrData(schema) {616    return { anyOf: [schema, $dataRef] };617}618//# sourceMappingURL=core.js.map