@jsonstudio/rcc 0.85.9

package/node_modules/fast-uri/test/util.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const test = require('tape')
+const {
+  stringArrayToHexStripped,
+  removeDotSegments
+} = require('../lib/utils')
+
+test('stringArrayToHexStripped', (t) => {
+  const testCases = [
+    [['0', '0', '0', '0'], ''],
+    [['0', '0', '0', '1'], '1'],
+    [['0', '0', '1', '0'], '10'],
+    [['0', '1', '0', '0'], '100'],
+    [['1', '0', '0', '0'], '1000'],
+    [['1', '0', '0', '1'], '1001'],
+  ]
+
+  t.plan(testCases.length)
+
+  testCases.forEach(([input, expected]) => {
+    t.same(stringArrayToHexStripped(input), expected)
+  })
+})
+
+// Just fixtures, because this function already tested by resolve
+test('removeDotSegments', (t) => {
+  const testCases = []
+  // https://github.com/fastify/fast-uri/issues/139
+  testCases.push(['WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a',
+    'WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a'])
+
+  t.plan(testCases.length)
+
+  testCases.forEach(([input, expected]) => {
+    t.same(removeDotSegments(input), expected)
+  })
+})

package/node_modules/fast-uri/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "checkJs": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "target": "es2015"
+    }
+}

package/node_modules/fast-uri/types/index.d.ts

@@ -0,0 +1,60 @@
+type FastUri = typeof fastUri
+
+declare namespace fastUri {
+  export interface URIComponent {
+    scheme?: string;
+    userinfo?: string;
+    host?: string;
+    port?: number | string;
+    path?: string;
+    query?: string;
+    fragment?: string;
+    reference?: string;
+    nid?: string;
+    nss?: string;
+    resourceName?: string;
+    secure?: boolean;
+    uuid?: string;
+    error?: string;
+  }
+  export interface Options {
+    scheme?: string;
+    reference?: string;
+    unicodeSupport?: boolean;
+    domainHost?: boolean;
+    absolutePath?: boolean;
+    tolerant?: boolean;
+    skipEscape?: boolean;
+    nid?: string;
+  }
+
+  /**
+   * @deprecated Use Options instead
+   */
+  export type options = Options
+  /**
+   * @deprecated Use URIComponent instead
+   */
+  export type URIComponents = URIComponent
+
+  export function normalize (uri: string, opts?: Options): string
+  export function normalize (uri: URIComponent, opts?: Options): URIComponent
+  export function normalize (uri: any, opts?: Options): any
+
+  export function resolve (baseURI: string, relativeURI: string, options?: Options): string
+
+  export function resolveComponent (base: URIComponent, relative: URIComponent, options?: Options, skipNormalization?: boolean): URIComponent
+
+  export function parse (uri: string, opts?: Options): URIComponent
+
+  export function serialize (component: URIComponent, opts?: Options): string
+
+  export function equal (uriA: string, uriB: string): boolean
+
+  export function resolve (base: string, path: string): string
+
+  export const fastUri: FastUri
+  export { fastUri as default }
+}
+
+export = fastUri

package/node_modules/fast-uri/types/index.test-d.ts

@@ -0,0 +1,17 @@
+import uri, { URIComponents, URIComponent, Options, options } from '..'
+import { expectDeprecated, expectType } from 'tsd'
+
+const parsed = uri.parse('foo')
+expectType<URIComponents>(parsed)
+const parsed2 = uri.parse('foo', {
+  domainHost: true,
+  scheme: 'https',
+  unicodeSupport: false
+})
+expectType<URIComponents>(parsed2)
+
+expectType<URIComponent>({} as URIComponents)
+expectDeprecated({} as URIComponents)
+
+expectType<Options>({} as options)
+expectDeprecated({} as options)

package/node_modules/json-schema-traverse/.eslintrc.yml

@@ -0,0 +1,27 @@
+extends: eslint:recommended
+env:
+  node: true
+  browser: true
+rules:
+  block-scoped-var: 2
+  complexity: [2, 15]
+  curly: [2, multi-or-nest, consistent]
+  dot-location: [2, property]
+  dot-notation: 2
+  indent: [2, 2, SwitchCase: 1]
+  linebreak-style: [2, unix]
+  new-cap: 2
+  no-console: [2, allow: [warn, error]]
+  no-else-return: 2
+  no-eq-null: 2
+  no-fallthrough: 2
+  no-invalid-this: 2
+  no-return-assign: 2
+  no-shadow: 1
+  no-trailing-spaces: 2
+  no-use-before-define: [2, nofunc]
+  quotes: [2, single, avoid-escape]
+  semi: [2, always]
+  strict: [2, global]
+  valid-jsdoc: [2, requireReturn: false]
+  no-control-regex: 0

package/node_modules/json-schema-traverse/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: epoberezkin
+tidelift: "npm/json-schema-traverse"

package/node_modules/json-schema-traverse/.github/workflows/build.yml

@@ -0,0 +1,28 @@
+name: build
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: ["*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm install
+      - run: npm test
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}

package/node_modules/json-schema-traverse/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish-npm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14
+          registry-url: https://registry.npmjs.org/
+      - run: npm install
+      - run: npm test
+      - name: Publish beta version to npm
+        if: "github.event.release.prerelease"
+        run: npm publish --tag beta
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Publish to npm
+        if: "!github.event.release.prerelease"
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/node_modules/json-schema-traverse/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Evgeny Poberezkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/json-schema-traverse/README.md

@@ -0,0 +1,95 @@
+# json-schema-traverse
+Traverse JSON Schema passing each schema object to callback
+
+[![build](https://github.com/epoberezkin/json-schema-traverse/workflows/build/badge.svg)](https://github.com/epoberezkin/json-schema-traverse/actions?query=workflow%3Abuild)
+[![npm](https://img.shields.io/npm/v/json-schema-traverse)](https://www.npmjs.com/package/json-schema-traverse)
+[![coverage](https://coveralls.io/repos/github/epoberezkin/json-schema-traverse/badge.svg?branch=master)](https://coveralls.io/github/epoberezkin/json-schema-traverse?branch=master)
+
+
+## Install
+
+```
+npm install json-schema-traverse
+```
+
+
+## Usage
+
+```javascript
+const traverse = require('json-schema-traverse');
+const schema = {
+  properties: {
+    foo: {type: 'string'},
+    bar: {type: 'integer'}
+  }
+};
+
+traverse(schema, {cb});
+// cb is called 3 times with:
+// 1. root schema
+// 2. {type: 'string'}
+// 3. {type: 'integer'}
+
+// Or:
+
+traverse(schema, {cb: {pre, post}});
+// pre is called 3 times with:
+// 1. root schema
+// 2. {type: 'string'}
+// 3. {type: 'integer'}
+//
+// post is called 3 times with:
+// 1. {type: 'string'}
+// 2. {type: 'integer'}
+// 3. root schema
+
+```
+
+Callback function `cb` is called for each schema object (not including draft-06 boolean schemas), including the root schema, in pre-order traversal. Schema references ($ref) are not resolved, they are passed as is.  Alternatively, you can pass a `{pre, post}` object as `cb`, and then `pre` will be called before traversing child elements, and `post` will be called after all child elements have been traversed.
+
+Callback is passed these parameters:
+
+- _schema_: the current schema object
+- _JSON pointer_: from the root schema to the current schema object
+- _root schema_: the schema passed to `traverse` object
+- _parent JSON pointer_: from the root schema to the parent schema object (see below)
+- _parent keyword_: the keyword inside which this schema appears (e.g. `properties`, `anyOf`, etc.)
+- _parent schema_: not necessarily parent object/array; in the example above the parent schema for `{type: 'string'}` is the root schema
+- _index/property_: index or property name in the array/object containing multiple schemas; in the example above for `{type: 'string'}` the property name is `'foo'`
+
+
+## Traverse objects in all unknown keywords
+
+```javascript
+const traverse = require('json-schema-traverse');
+const schema = {
+  mySchema: {
+    minimum: 1,
+    maximum: 2
+  }
+};
+
+traverse(schema, {allKeys: true, cb});
+// cb is called 2 times with:
+// 1. root schema
+// 2. mySchema
+```
+
+Without option `allKeys: true` callback will be called only with root schema.
+
+
+## Enterprise support
+
+json-schema-traverse package is a part of [Tidelift enterprise subscription](https://tidelift.com/subscription/pkg/npm-json-schema-traverse?utm_source=npm-json-schema-traverse&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) - it provides a centralised commercial support to open-source software users, in addition to the support provided by software maintainers.
+
+
+## Security contact
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerability via GitHub issues.
+
+
+## License
+
+[MIT](https://github.com/epoberezkin/json-schema-traverse/blob/master/LICENSE)

package/node_modules/json-schema-traverse/index.d.ts

@@ -0,0 +1,40 @@
+declare function traverse(
+  schema: traverse.SchemaObject,
+  opts: traverse.Options,
+  cb?: traverse.Callback
+): void;
+
+declare function traverse(
+  schema: traverse.SchemaObject,
+  cb: traverse.Callback
+): void;
+
+declare namespace traverse {
+  interface SchemaObject {
+    $id?: string;
+    $schema?: string;
+    [x: string]: any;
+  }
+
+  type Callback = (
+    schema: SchemaObject,
+    jsonPtr: string,
+    rootSchema: SchemaObject,
+    parentJsonPtr?: string,
+    parentKeyword?: string,
+    parentSchema?: SchemaObject,
+    keyIndex?: string | number
+  ) => void;
+
+  interface Options {
+    allKeys?: boolean;
+    cb?:
+      | Callback
+      | {
+          pre?: Callback;
+          post?: Callback;
+        };
+  }
+}
+
+export = traverse;

package/node_modules/json-schema-traverse/index.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var traverse = module.exports = function (schema, opts, cb) {
+  // Legacy support for v0.3.1 and earlier.
+  if (typeof opts == 'function') {
+    cb = opts;
+    opts = {};
+  }
+
+  cb = opts.cb || cb;
+  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};
+  var post = cb.post || function() {};
+
+  _traverse(opts, pre, post, schema, '', schema);
+};
+
+
+traverse.keywords = {
+  additionalItems: true,
+  items: true,
+  contains: true,
+  additionalProperties: true,
+  propertyNames: true,
+  not: true,
+  if: true,
+  then: true,
+  else: true
+};
+
+traverse.arrayKeywords = {
+  items: true,
+  allOf: true,
+  anyOf: true,
+  oneOf: true
+};
+
+traverse.propsKeywords = {
+  $defs: true,
+  definitions: true,
+  properties: true,
+  patternProperties: true,
+  dependencies: true
+};
+
+traverse.skipKeywords = {
+  default: true,
+  enum: true,
+  const: true,
+  required: true,
+  maximum: true,
+  minimum: true,
+  exclusiveMaximum: true,
+  exclusiveMinimum: true,
+  multipleOf: true,
+  maxLength: true,
+  minLength: true,
+  pattern: true,
+  format: true,
+  maxItems: true,
+  minItems: true,
+  uniqueItems: true,
+  maxProperties: true,
+  minProperties: true
+};
+
+
+function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {
+    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+    for (var key in schema) {
+      var sch = schema[key];
+      if (Array.isArray(sch)) {
+        if (key in traverse.arrayKeywords) {
+          for (var i=0; i<sch.length; i++)
+            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);
+        }
+      } else if (key in traverse.propsKeywords) {
+        if (sch && typeof sch == 'object') {
+          for (var prop in sch)
+            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+        }
+      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {
+        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);
+      }
+    }
+    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+  }
+}
+
+
+function escapeJsonPtr(str) {
+  return str.replace(/~/g, '~0').replace(/\//g, '~1');
+}

package/node_modules/json-schema-traverse/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "json-schema-traverse",
+  "version": "1.0.0",
+  "description": "Traverse JSON Schema passing each schema object to callback",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "eslint": "eslint index.js spec",
+    "test-spec": "mocha spec -R spec",
+    "test": "npm run eslint && nyc npm run test-spec"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/epoberezkin/json-schema-traverse.git"
+  },
+  "keywords": [
+    "JSON-Schema",
+    "traverse",
+    "iterate"
+  ],
+  "author": "Evgeny Poberezkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/epoberezkin/json-schema-traverse/issues"
+  },
+  "homepage": "https://github.com/epoberezkin/json-schema-traverse#readme",
+  "devDependencies": {
+    "eslint": "^7.3.1",
+    "mocha": "^8.0.1",
+    "nyc": "^15.0.0",
+    "pre-commit": "^1.2.2"
+  },
+  "nyc": {
+    "exclude": [
+      "**/spec/**",
+      "node_modules"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  }
+}

package/node_modules/json-schema-traverse/spec/.eslintrc.yml

@@ -0,0 +1,6 @@
+parserOptions:
+  ecmaVersion: 6
+globals:
+  beforeEach: false
+  describe: false
+  it: false

package/node_modules/json-schema-traverse/spec/fixtures/schema.js

@@ -0,0 +1,125 @@
+'use strict';
+
+var schema = {
+  additionalItems: subschema('additionalItems'),
+  items: subschema('items'),
+  contains: subschema('contains'),
+  additionalProperties: subschema('additionalProperties'),
+  propertyNames: subschema('propertyNames'),
+  not: subschema('not'),
+  allOf: [
+    subschema('allOf_0'),
+    subschema('allOf_1'),
+    {
+      items: [
+        subschema('items_0'),
+        subschema('items_1'),
+      ]
+    }
+  ],
+  anyOf: [
+    subschema('anyOf_0'),
+    subschema('anyOf_1'),
+  ],
+  oneOf: [
+    subschema('oneOf_0'),
+    subschema('oneOf_1'),
+  ],
+  definitions: {
+    foo: subschema('definitions_foo'),
+    bar: subschema('definitions_bar'),
+  },
+  properties: {
+    foo: subschema('properties_foo'),
+    bar: subschema('properties_bar'),
+  },
+  patternProperties: {
+    foo: subschema('patternProperties_foo'),
+    bar: subschema('patternProperties_bar'),
+  },
+  dependencies: {
+    foo: subschema('dependencies_foo'),
+    bar: subschema('dependencies_bar'),
+  },
+  required: ['foo', 'bar']
+};
+
+
+function subschema(keyword) {
+  var sch = {
+    properties: {},
+    additionalProperties: false,
+    additionalItems: false,
+    anyOf: [
+      {format: 'email'},
+      {format: 'hostname'}
+    ]
+  };
+  sch.properties['foo_' + keyword] = {title: 'foo'};
+  sch.properties['bar_' + keyword] = {title: 'bar'};
+  return sch;
+}
+
+
+module.exports = {
+  schema: schema,
+
+  // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
+  expectedCalls: [[schema, '', schema, undefined, undefined, undefined, undefined]]
+    .concat(expectedCalls('additionalItems'))
+    .concat(expectedCalls('items'))
+    .concat(expectedCalls('contains'))
+    .concat(expectedCalls('additionalProperties'))
+    .concat(expectedCalls('propertyNames'))
+    .concat(expectedCalls('not'))
+    .concat(expectedCallsChild('allOf', 0))
+    .concat(expectedCallsChild('allOf', 1))
+    .concat([
+      [schema.allOf[2], '/allOf/2', schema, '', 'allOf', schema, 2],
+      [schema.allOf[2].items[0], '/allOf/2/items/0', schema, '/allOf/2', 'items', schema.allOf[2], 0],
+      [schema.allOf[2].items[0].properties.foo_items_0, '/allOf/2/items/0/properties/foo_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'foo_items_0'],
+      [schema.allOf[2].items[0].properties.bar_items_0, '/allOf/2/items/0/properties/bar_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'bar_items_0'],
+      [schema.allOf[2].items[0].anyOf[0], '/allOf/2/items/0/anyOf/0', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 0],
+      [schema.allOf[2].items[0].anyOf[1], '/allOf/2/items/0/anyOf/1', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 1],
+
+      [schema.allOf[2].items[1], '/allOf/2/items/1', schema, '/allOf/2', 'items', schema.allOf[2], 1],
+      [schema.allOf[2].items[1].properties.foo_items_1, '/allOf/2/items/1/properties/foo_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'foo_items_1'],
+      [schema.allOf[2].items[1].properties.bar_items_1, '/allOf/2/items/1/properties/bar_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'bar_items_1'],
+      [schema.allOf[2].items[1].anyOf[0], '/allOf/2/items/1/anyOf/0', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 0],
+      [schema.allOf[2].items[1].anyOf[1], '/allOf/2/items/1/anyOf/1', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 1]
+    ])
+    .concat(expectedCallsChild('anyOf', 0))
+    .concat(expectedCallsChild('anyOf', 1))
+    .concat(expectedCallsChild('oneOf', 0))
+    .concat(expectedCallsChild('oneOf', 1))
+    .concat(expectedCallsChild('definitions', 'foo'))
+    .concat(expectedCallsChild('definitions', 'bar'))
+    .concat(expectedCallsChild('properties', 'foo'))
+    .concat(expectedCallsChild('properties', 'bar'))
+    .concat(expectedCallsChild('patternProperties', 'foo'))
+    .concat(expectedCallsChild('patternProperties', 'bar'))
+    .concat(expectedCallsChild('dependencies', 'foo'))
+    .concat(expectedCallsChild('dependencies', 'bar'))
+};
+
+
+function expectedCalls(keyword) {
+  return [
+    [schema[keyword], `/${keyword}`, schema, '', keyword, schema, undefined],
+    [schema[keyword].properties[`foo_${keyword}`], `/${keyword}/properties/foo_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `foo_${keyword}`],
+    [schema[keyword].properties[`bar_${keyword}`], `/${keyword}/properties/bar_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `bar_${keyword}`],
+    [schema[keyword].anyOf[0], `/${keyword}/anyOf/0`, schema, `/${keyword}`, 'anyOf', schema[keyword], 0],
+    [schema[keyword].anyOf[1], `/${keyword}/anyOf/1`, schema, `/${keyword}`, 'anyOf', schema[keyword], 1]
+  ];
+}
+
+
+function expectedCallsChild(keyword, i) {
+  return [
+    [schema[keyword][i], `/${keyword}/${i}`, schema, '', keyword, schema, i],
+    [schema[keyword][i].properties[`foo_${keyword}_${i}`], `/${keyword}/${i}/properties/foo_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `foo_${keyword}_${i}`],
+    [schema[keyword][i].properties[`bar_${keyword}_${i}`], `/${keyword}/${i}/properties/bar_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `bar_${keyword}_${i}`],
+    [schema[keyword][i].anyOf[0], `/${keyword}/${i}/anyOf/0`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 0],
+    [schema[keyword][i].anyOf[1], `/${keyword}/${i}/anyOf/1`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 1]
+  ];
+}