web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/ajv/dist/compile/names.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var names = require('../../../../_virtual/names.js');
+var index = require('./codegen/index.js');
+
+var hasRequiredNames;
+function requireNames() {
+  if (hasRequiredNames) return names.__exports;
+  hasRequiredNames = 1;
+  Object.defineProperty(names.__exports, "__esModule", {
+    value: true
+  });
+  const codegen_1 = index.__require();
+  const names$1 = {
+    // validation function arguments
+    data: new codegen_1.Name("data"),
+    // data passed to validation function
+    // args passed from referencing schema
+    valCxt: new codegen_1.Name("valCxt"),
+    // validation/data context - should not be used directly, it is destructured to the names below
+    instancePath: new codegen_1.Name("instancePath"),
+    parentData: new codegen_1.Name("parentData"),
+    parentDataProperty: new codegen_1.Name("parentDataProperty"),
+    rootData: new codegen_1.Name("rootData"),
+    // root data - same as the data passed to the first/top validation function
+    dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
+    // used to support recursiveRef and dynamicRef
+    // function scoped variables
+    vErrors: new codegen_1.Name("vErrors"),
+    // null or array of validation errors
+    errors: new codegen_1.Name("errors"),
+    // counter of validation errors
+    this: new codegen_1.Name("this"),
+    // "globals"
+    self: new codegen_1.Name("self"),
+    scope: new codegen_1.Name("scope"),
+    // JTD serialize/parse name for JSON string and position
+    json: new codegen_1.Name("json"),
+    jsonPos: new codegen_1.Name("jsonPos"),
+    jsonLen: new codegen_1.Name("jsonLen"),
+    jsonPart: new codegen_1.Name("jsonPart")
+  };
+  names.__exports.default = names$1;
+  return names.__exports;
+}
+
+exports.__require = requireNames;

package/dist/cjs/node_modules/ajv/dist/compile/ref_error.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var ref_error = require('../../../../_virtual/ref_error.js');
+var resolve = require('./resolve.js');
+
+var hasRequiredRef_error;
+function requireRef_error() {
+  if (hasRequiredRef_error) return ref_error.__exports;
+  hasRequiredRef_error = 1;
+  Object.defineProperty(ref_error.__exports, "__esModule", {
+    value: true
+  });
+  const resolve_1 = resolve.__require();
+  class MissingRefError extends Error {
+    constructor(resolver, baseId, ref, msg) {
+      super(msg || `can't resolve reference ${ref} from id ${baseId}`);
+      this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
+      this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
+    }
+  }
+  ref_error.__exports.default = MissingRefError;
+  return ref_error.__exports;
+}
+
+exports.__require = requireRef_error;

package/dist/cjs/node_modules/ajv/dist/compile/resolve.js

@@ -0,0 +1,138 @@
+'use strict';
+
+var resolve = require('../../../../_virtual/resolve.js');
+var util = require('./util.js');
+var index$1 = require('../../../fast-deep-equal/index.js');
+var index = require('../../../json-schema-traverse/index.js');
+
+var hasRequiredResolve;
+function requireResolve() {
+  if (hasRequiredResolve) return resolve.__exports;
+  hasRequiredResolve = 1;
+  Object.defineProperty(resolve.__exports, "__esModule", {
+    value: true
+  });
+  resolve.__exports.getSchemaRefs = resolve.__exports.resolveUrl = resolve.__exports.normalizeId = resolve.__exports._getFullPath = resolve.__exports.getFullPath = resolve.__exports.inlineRef = void 0;
+  const util_1 = util.__require();
+  const equal = index$1.__require();
+  const traverse = index.__require();
+  // TODO refactor to use keyword definitions
+  const SIMPLE_INLINED = new Set(["type", "format", "pattern", "maxLength", "minLength", "maxProperties", "minProperties", "maxItems", "minItems", "maximum", "minimum", "uniqueItems", "multipleOf", "required", "enum", "const"]);
+  function inlineRef(schema) {
+    let limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (typeof schema == "boolean") return true;
+    if (limit === true) return !hasRef(schema);
+    if (!limit) return false;
+    return countKeys(schema) <= limit;
+  }
+  resolve.__exports.inlineRef = inlineRef;
+  const REF_KEYWORDS = new Set(["$ref", "$recursiveRef", "$recursiveAnchor", "$dynamicRef", "$dynamicAnchor"]);
+  function hasRef(schema) {
+    for (const key in schema) {
+      if (REF_KEYWORDS.has(key)) return true;
+      const sch = schema[key];
+      if (Array.isArray(sch) && sch.some(hasRef)) return true;
+      if (typeof sch == "object" && hasRef(sch)) return true;
+    }
+    return false;
+  }
+  function countKeys(schema) {
+    let count = 0;
+    for (const key in schema) {
+      if (key === "$ref") return Infinity;
+      count++;
+      if (SIMPLE_INLINED.has(key)) continue;
+      if (typeof schema[key] == "object") {
+        (0, util_1.eachItem)(schema[key], sch => count += countKeys(sch));
+      }
+      if (count === Infinity) return Infinity;
+    }
+    return count;
+  }
+  function getFullPath(resolver) {
+    let id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let normalize = arguments.length > 2 ? arguments[2] : undefined;
+    if (normalize !== false) id = normalizeId(id);
+    const p = resolver.parse(id);
+    return _getFullPath(resolver, p);
+  }
+  resolve.__exports.getFullPath = getFullPath;
+  function _getFullPath(resolver, p) {
+    const serialized = resolver.serialize(p);
+    return serialized.split("#")[0] + "#";
+  }
+  resolve.__exports._getFullPath = _getFullPath;
+  const TRAILING_SLASH_HASH = /#\/?$/;
+  function normalizeId(id) {
+    return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
+  }
+  resolve.__exports.normalizeId = normalizeId;
+  function resolveUrl(resolver, baseId, id) {
+    id = normalizeId(id);
+    return resolver.resolve(baseId, id);
+  }
+  resolve.__exports.resolveUrl = resolveUrl;
+  const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
+  function getSchemaRefs(schema, baseId) {
+    if (typeof schema == "boolean") return {};
+    const {
+      schemaId,
+      uriResolver
+    } = this.opts;
+    const schId = normalizeId(schema[schemaId] || baseId);
+    const baseIds = {
+      "": schId
+    };
+    const pathPrefix = getFullPath(uriResolver, schId, false);
+    const localRefs = {};
+    const schemaRefs = new Set();
+    traverse(schema, {
+      allKeys: true
+    }, (sch, jsonPtr, _, parentJsonPtr) => {
+      if (parentJsonPtr === undefined) return;
+      const fullPath = pathPrefix + jsonPtr;
+      let innerBaseId = baseIds[parentJsonPtr];
+      if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId]);
+      addAnchor.call(this, sch.$anchor);
+      addAnchor.call(this, sch.$dynamicAnchor);
+      baseIds[jsonPtr] = innerBaseId;
+      function addRef(ref) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const _resolve = this.opts.uriResolver.resolve;
+        ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
+        if (schemaRefs.has(ref)) throw ambiguos(ref);
+        schemaRefs.add(ref);
+        let schOrRef = this.refs[ref];
+        if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef];
+        if (typeof schOrRef == "object") {
+          checkAmbiguosRef(sch, schOrRef.schema, ref);
+        } else if (ref !== normalizeId(fullPath)) {
+          if (ref[0] === "#") {
+            checkAmbiguosRef(sch, localRefs[ref], ref);
+            localRefs[ref] = sch;
+          } else {
+            this.refs[ref] = fullPath;
+          }
+        }
+        return ref;
+      }
+      function addAnchor(anchor) {
+        if (typeof anchor == "string") {
+          if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor "${anchor}"`);
+          addRef.call(this, `#${anchor}`);
+        }
+      }
+    });
+    return localRefs;
+    function checkAmbiguosRef(sch1, sch2, ref) {
+      if (sch2 !== undefined && !equal(sch1, sch2)) throw ambiguos(ref);
+    }
+    function ambiguos(ref) {
+      return new Error(`reference "${ref}" resolves to more than one schema`);
+    }
+  }
+  resolve.__exports.getSchemaRefs = getSchemaRefs;
+  return resolve.__exports;
+}
+
+exports.__require = requireResolve;

package/dist/cjs/node_modules/ajv/dist/compile/rules.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var rules = require('../../../../_virtual/rules.js');
+
+var hasRequiredRules;
+function requireRules() {
+  if (hasRequiredRules) return rules.__exports;
+  hasRequiredRules = 1;
+  Object.defineProperty(rules.__exports, "__esModule", {
+    value: true
+  });
+  rules.__exports.getRules = rules.__exports.isJSONType = void 0;
+  const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
+  const jsonTypes = new Set(_jsonTypes);
+  function isJSONType(x) {
+    return typeof x == "string" && jsonTypes.has(x);
+  }
+  rules.__exports.isJSONType = isJSONType;
+  function getRules() {
+    const groups = {
+      number: {
+        type: "number",
+        rules: []
+      },
+      string: {
+        type: "string",
+        rules: []
+      },
+      array: {
+        type: "array",
+        rules: []
+      },
+      object: {
+        type: "object",
+        rules: []
+      }
+    };
+    return {
+      types: {
+        ...groups,
+        integer: true,
+        boolean: true,
+        null: true
+      },
+      rules: [{
+        rules: []
+      }, groups.number, groups.string, groups.array, groups.object],
+      post: {
+        rules: []
+      },
+      all: {},
+      keywords: {}
+    };
+  }
+  rules.__exports.getRules = getRules;
+  return rules.__exports;
+}
+
+exports.__require = requireRules;

package/dist/cjs/node_modules/ajv/dist/compile/util.js

@@ -0,0 +1,176 @@
+'use strict';
+
+var util = require('../../../../_virtual/util.js');
+var index = require('./codegen/index.js');
+var code = require('./codegen/code.js');
+
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util.__exports;
+  hasRequiredUtil = 1;
+  Object.defineProperty(util.__exports, "__esModule", {
+    value: true
+  });
+  util.__exports.checkStrictMode = util.__exports.getErrorPath = util.__exports.Type = util.__exports.useFunc = util.__exports.setEvaluated = util.__exports.evaluatedPropsToName = util.__exports.mergeEvaluated = util.__exports.eachItem = util.__exports.unescapeJsonPointer = util.__exports.escapeJsonPointer = util.__exports.escapeFragment = util.__exports.unescapeFragment = util.__exports.schemaRefOrVal = util.__exports.schemaHasRulesButRef = util.__exports.schemaHasRules = util.__exports.checkUnknownRules = util.__exports.alwaysValidSchema = util.__exports.toHash = void 0;
+  const codegen_1 = index.__require();
+  const code_1 = code.__require();
+  // TODO refactor to use Set
+  function toHash(arr) {
+    const hash = {};
+    for (const item of arr) hash[item] = true;
+    return hash;
+  }
+  util.__exports.toHash = toHash;
+  function alwaysValidSchema(it, schema) {
+    if (typeof schema == "boolean") return schema;
+    if (Object.keys(schema).length === 0) return true;
+    checkUnknownRules(it, schema);
+    return !schemaHasRules(schema, it.self.RULES.all);
+  }
+  util.__exports.alwaysValidSchema = alwaysValidSchema;
+  function checkUnknownRules(it) {
+    let schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : it.schema;
+    const {
+      opts,
+      self
+    } = it;
+    if (!opts.strictSchema) return;
+    if (typeof schema === "boolean") return;
+    const rules = self.RULES.keywords;
+    for (const key in schema) {
+      if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`);
+    }
+  }
+  util.__exports.checkUnknownRules = checkUnknownRules;
+  function schemaHasRules(schema, rules) {
+    if (typeof schema == "boolean") return !schema;
+    for (const key in schema) if (rules[key]) return true;
+    return false;
+  }
+  util.__exports.schemaHasRules = schemaHasRules;
+  function schemaHasRulesButRef(schema, RULES) {
+    if (typeof schema == "boolean") return !schema;
+    for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true;
+    return false;
+  }
+  util.__exports.schemaHasRulesButRef = schemaHasRulesButRef;
+  function schemaRefOrVal(_ref, schema, keyword, $data) {
+    let {
+      topSchemaRef,
+      schemaPath
+    } = _ref;
+    if (!$data) {
+      if (typeof schema == "number" || typeof schema == "boolean") return schema;
+      if (typeof schema == "string") return (0, codegen_1._)`${schema}`;
+    }
+    return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
+  }
+  util.__exports.schemaRefOrVal = schemaRefOrVal;
+  function unescapeFragment(str) {
+    return unescapeJsonPointer(decodeURIComponent(str));
+  }
+  util.__exports.unescapeFragment = unescapeFragment;
+  function escapeFragment(str) {
+    return encodeURIComponent(escapeJsonPointer(str));
+  }
+  util.__exports.escapeFragment = escapeFragment;
+  function escapeJsonPointer(str) {
+    if (typeof str == "number") return `${str}`;
+    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  util.__exports.escapeJsonPointer = escapeJsonPointer;
+  function unescapeJsonPointer(str) {
+    return str.replace(/~1/g, "/").replace(/~0/g, "~");
+  }
+  util.__exports.unescapeJsonPointer = unescapeJsonPointer;
+  function eachItem(xs, f) {
+    if (Array.isArray(xs)) {
+      for (const x of xs) f(x);
+    } else {
+      f(xs);
+    }
+  }
+  util.__exports.eachItem = eachItem;
+  function makeMergeEvaluated(_ref2) {
+    let {
+      mergeNames,
+      mergeToName,
+      mergeValues,
+      resultToName
+    } = _ref2;
+    return (gen, from, to, toName) => {
+      const res = to === undefined ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues(from, to);
+      return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
+    };
+  }
+  util.__exports.mergeEvaluated = {
+    props: makeMergeEvaluated({
+      mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
+        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})`));
+      }),
+      mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
+        if (from === true) {
+          gen.assign(to, true);
+        } else {
+          gen.assign(to, (0, codegen_1._)`${to} || {}`);
+          setEvaluated(gen, to, from);
+        }
+      }),
+      mergeValues: (from, to) => from === true ? true : {
+        ...from,
+        ...to
+      },
+      resultToName: evaluatedPropsToName
+    }),
+    items: makeMergeEvaluated({
+      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}`)),
+      mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
+      mergeValues: (from, to) => from === true ? true : Math.max(from, to),
+      resultToName: (gen, items) => gen.var("items", items)
+    })
+  };
+  function evaluatedPropsToName(gen, ps) {
+    if (ps === true) return gen.var("props", true);
+    const props = gen.var("props", (0, codegen_1._)`{}`);
+    if (ps !== undefined) setEvaluated(gen, props, ps);
+    return props;
+  }
+  util.__exports.evaluatedPropsToName = evaluatedPropsToName;
+  function setEvaluated(gen, props, ps) {
+    Object.keys(ps).forEach(p => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
+  }
+  util.__exports.setEvaluated = setEvaluated;
+  const snippets = {};
+  function useFunc(gen, f) {
+    return gen.scopeValue("func", {
+      ref: f,
+      code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
+    });
+  }
+  util.__exports.useFunc = useFunc;
+  var Type;
+  (function (Type) {
+    Type[Type["Num"] = 0] = "Num";
+    Type[Type["Str"] = 1] = "Str";
+  })(Type || (util.__exports.Type = Type = {}));
+  function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
+    // let path
+    if (dataProp instanceof codegen_1.Name) {
+      const isNumber = dataPropType === Type.Num;
+      return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`; // TODO maybe use global escapePointer
+    }
+    return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
+  }
+  util.__exports.getErrorPath = getErrorPath;
+  function checkStrictMode(it, msg) {
+    let mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : it.opts.strictSchema;
+    if (!mode) return;
+    msg = `strict mode: ${msg}`;
+    if (mode === true) throw new Error(msg);
+    it.self.logger.warn(msg);
+  }
+  util.__exports.checkStrictMode = checkStrictMode;
+  return util.__exports;
+}
+
+exports.__require = requireUtil;

package/dist/cjs/node_modules/ajv/dist/compile/validate/applicability.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var applicability = require('../../../../../_virtual/applicability.js');
+
+var hasRequiredApplicability;
+function requireApplicability() {
+  if (hasRequiredApplicability) return applicability.__exports;
+  hasRequiredApplicability = 1;
+  Object.defineProperty(applicability.__exports, "__esModule", {
+    value: true
+  });
+  applicability.__exports.shouldUseRule = applicability.__exports.shouldUseGroup = applicability.__exports.schemaHasRulesForType = void 0;
+  function schemaHasRulesForType(_ref, type) {
+    let {
+      schema,
+      self
+    } = _ref;
+    const group = self.RULES.types[type];
+    return group && group !== true && shouldUseGroup(schema, group);
+  }
+  applicability.__exports.schemaHasRulesForType = schemaHasRulesForType;
+  function shouldUseGroup(schema, group) {
+    return group.rules.some(rule => shouldUseRule(schema, rule));
+  }
+  applicability.__exports.shouldUseGroup = shouldUseGroup;
+  function shouldUseRule(schema, rule) {
+    var _a;
+    return schema[rule.keyword] !== undefined || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some(kwd => schema[kwd] !== undefined));
+  }
+  applicability.__exports.shouldUseRule = shouldUseRule;
+  return applicability.__exports;
+}
+
+exports.__require = requireApplicability;

package/dist/cjs/node_modules/ajv/dist/compile/validate/boolSchema.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var boolSchema = require('../../../../../_virtual/boolSchema.js');
+var errors = require('../errors.js');
+var index = require('../codegen/index.js');
+var names = require('../names.js');
+
+var hasRequiredBoolSchema;
+function requireBoolSchema() {
+  if (hasRequiredBoolSchema) return boolSchema.__exports;
+  hasRequiredBoolSchema = 1;
+  Object.defineProperty(boolSchema.__exports, "__esModule", {
+    value: true
+  });
+  boolSchema.__exports.boolOrEmptySchema = boolSchema.__exports.topBoolOrEmptySchema = void 0;
+  const errors_1 = errors.__require();
+  const codegen_1 = index.__require();
+  const names_1 = names.__require();
+  const boolError = {
+    message: "boolean schema is false"
+  };
+  function topBoolOrEmptySchema(it) {
+    const {
+      gen,
+      schema,
+      validateName
+    } = it;
+    if (schema === false) {
+      falseSchemaError(it, false);
+    } else if (typeof schema == "object" && schema.$async === true) {
+      gen.return(names_1.default.data);
+    } else {
+      gen.assign((0, codegen_1._)`${validateName}.errors`, null);
+      gen.return(true);
+    }
+  }
+  boolSchema.__exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
+  function boolOrEmptySchema(it, valid) {
+    const {
+      gen,
+      schema
+    } = it;
+    if (schema === false) {
+      gen.var(valid, false); // TODO var
+      falseSchemaError(it);
+    } else {
+      gen.var(valid, true); // TODO var
+    }
+  }
+  boolSchema.__exports.boolOrEmptySchema = boolOrEmptySchema;
+  function falseSchemaError(it, overrideAllErrors) {
+    const {
+      gen,
+      data
+    } = it;
+    // TODO maybe some other interface should be used for non-keyword validation errors...
+    const cxt = {
+      gen,
+      keyword: "false schema",
+      data,
+      schema: false,
+      schemaCode: false,
+      schemaValue: false,
+      params: {},
+      it
+    };
+    (0, errors_1.reportError)(cxt, boolError, undefined, overrideAllErrors);
+  }
+  return boolSchema.__exports;
+}
+
+exports.__require = requireBoolSchema;