.config/coc/extensions/node_modules/coc-prettier/node_modules/table/dist/src/generated/validators.js

   1 "use strict";
   2 exports["config.json"] = validate43;
   3 const schema13 = {
   4     "$id": "config.json",
   5     "$schema": "http://json-schema.org/draft-07/schema#",
   6     "type": "object",
   7     "properties": {
   8         "border": {
   9             "$ref": "shared.json#/definitions/borders"
  10         },
  11         "header": {
  12             "type": "object",
  13             "properties": {
  14                 "content": {
  15                     "type": "string"
  16                 },
  17                 "alignment": {
  18                     "$ref": "shared.json#/definitions/alignment"
  19                 },
  20                 "wrapWord": {
  21                     "type": "boolean"
  22                 },
  23                 "truncate": {
  24                     "type": "integer"
  25                 },
  26                 "paddingLeft": {
  27                     "type": "integer"
  28                 },
  29                 "paddingRight": {
  30                     "type": "integer"
  31                 }
  32             },
  33             "required": ["content"],
  34             "additionalProperties": false
  35         },
  36         "columns": {
  37             "$ref": "shared.json#/definitions/columns"
  38         },
  39         "columnDefault": {
  40             "$ref": "shared.json#/definitions/column"
  41         },
  42         "drawVerticalLine": {
  43             "typeof": "function"
  44         },
  45         "drawHorizontalLine": {
  46             "typeof": "function"
  47         },
  48         "singleLine": {
  49             "typeof": "boolean"
  50         }
  51     },
  52     "additionalProperties": false
  53 };
  54 const schema15 = {
  55     "type": "object",
  56     "properties": {
  57         "topBody": {
  58             "$ref": "#/definitions/border"
  59         },
  60         "topJoin": {
  61             "$ref": "#/definitions/border"
  62         },
  63         "topLeft": {
  64             "$ref": "#/definitions/border"
  65         },
  66         "topRight": {
  67             "$ref": "#/definitions/border"
  68         },
  69         "bottomBody": {
  70             "$ref": "#/definitions/border"
  71         },
  72         "bottomJoin": {
  73             "$ref": "#/definitions/border"
  74         },
  75         "bottomLeft": {
  76             "$ref": "#/definitions/border"
  77         },
  78         "bottomRight": {
  79             "$ref": "#/definitions/border"
  80         },
  81         "bodyLeft": {
  82             "$ref": "#/definitions/border"
  83         },
  84         "bodyRight": {
  85             "$ref": "#/definitions/border"
  86         },
  87         "bodyJoin": {
  88             "$ref": "#/definitions/border"
  89         },
  90         "headerJoin": {
  91             "$ref": "#/definitions/border"
  92         },
  93         "joinBody": {
  94             "$ref": "#/definitions/border"
  95         },
  96         "joinLeft": {
  97             "$ref": "#/definitions/border"
  98         },
  99         "joinRight": {
 100             "$ref": "#/definitions/border"
 101         },
 102         "joinJoin": {
 103             "$ref": "#/definitions/border"
 104         }
 105     },
 106     "additionalProperties": false
 107 };
 108 const func8 = Object.prototype.hasOwnProperty;
 109 const schema16 = {
 110     "type": "string"
 111 };
 112 function validate46(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 113     let vErrors = null;
 114     let errors = 0;
 115     if (typeof data !== "string") {
 116         const err0 = {
 117             instancePath,
 118             schemaPath: "#/type",
 119             keyword: "type",
 120             params: {
 121                 type: "string"
 122             },
 123             message: "must be string"
 124         };
 125         if (vErrors === null) {
 126             vErrors = [err0];
 127         }
 128         else {
 129             vErrors.push(err0);
 130         }
 131         errors++;
 132     }
 133     validate46.errors = vErrors;
 134     return errors === 0;
 135 }
 136 function validate45(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 137     let vErrors = null;
 138     let errors = 0;
 139     if (data && typeof data == "object" && !Array.isArray(data)) {
 140         for (const key0 in data) {
 141             if (!(func8.call(schema15.properties, key0))) {
 142                 const err0 = {
 143                     instancePath,
 144                     schemaPath: "#/additionalProperties",
 145                     keyword: "additionalProperties",
 146                     params: {
 147                         additionalProperty: key0
 148                     },
 149                     message: "must NOT have additional properties"
 150                 };
 151                 if (vErrors === null) {
 152                     vErrors = [err0];
 153                 }
 154                 else {
 155                     vErrors.push(err0);
 156                 }
 157                 errors++;
 158             }
 159         }
 160         if (data.topBody !== undefined) {
 161             if (!(validate46(data.topBody, {
 162                 instancePath: instancePath + "/topBody",
 163                 parentData: data,
 164                 parentDataProperty: "topBody",
 165                 rootData
 166             }))) {
 167                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 168                 errors = vErrors.length;
 169             }
 170         }
 171         if (data.topJoin !== undefined) {
 172             if (!(validate46(data.topJoin, {
 173                 instancePath: instancePath + "/topJoin",
 174                 parentData: data,
 175                 parentDataProperty: "topJoin",
 176                 rootData
 177             }))) {
 178                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 179                 errors = vErrors.length;
 180             }
 181         }
 182         if (data.topLeft !== undefined) {
 183             if (!(validate46(data.topLeft, {
 184                 instancePath: instancePath + "/topLeft",
 185                 parentData: data,
 186                 parentDataProperty: "topLeft",
 187                 rootData
 188             }))) {
 189                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 190                 errors = vErrors.length;
 191             }
 192         }
 193         if (data.topRight !== undefined) {
 194             if (!(validate46(data.topRight, {
 195                 instancePath: instancePath + "/topRight",
 196                 parentData: data,
 197                 parentDataProperty: "topRight",
 198                 rootData
 199             }))) {
 200                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 201                 errors = vErrors.length;
 202             }
 203         }
 204         if (data.bottomBody !== undefined) {
 205             if (!(validate46(data.bottomBody, {
 206                 instancePath: instancePath + "/bottomBody",
 207                 parentData: data,
 208                 parentDataProperty: "bottomBody",
 209                 rootData
 210             }))) {
 211                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 212                 errors = vErrors.length;
 213             }
 214         }
 215         if (data.bottomJoin !== undefined) {
 216             if (!(validate46(data.bottomJoin, {
 217                 instancePath: instancePath + "/bottomJoin",
 218                 parentData: data,
 219                 parentDataProperty: "bottomJoin",
 220                 rootData
 221             }))) {
 222                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 223                 errors = vErrors.length;
 224             }
 225         }
 226         if (data.bottomLeft !== undefined) {
 227             if (!(validate46(data.bottomLeft, {
 228                 instancePath: instancePath + "/bottomLeft",
 229                 parentData: data,
 230                 parentDataProperty: "bottomLeft",
 231                 rootData
 232             }))) {
 233                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 234                 errors = vErrors.length;
 235             }
 236         }
 237         if (data.bottomRight !== undefined) {
 238             if (!(validate46(data.bottomRight, {
 239                 instancePath: instancePath + "/bottomRight",
 240                 parentData: data,
 241                 parentDataProperty: "bottomRight",
 242                 rootData
 243             }))) {
 244                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 245                 errors = vErrors.length;
 246             }
 247         }
 248         if (data.bodyLeft !== undefined) {
 249             if (!(validate46(data.bodyLeft, {
 250                 instancePath: instancePath + "/bodyLeft",
 251                 parentData: data,
 252                 parentDataProperty: "bodyLeft",
 253                 rootData
 254             }))) {
 255                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 256                 errors = vErrors.length;
 257             }
 258         }
 259         if (data.bodyRight !== undefined) {
 260             if (!(validate46(data.bodyRight, {
 261                 instancePath: instancePath + "/bodyRight",
 262                 parentData: data,
 263                 parentDataProperty: "bodyRight",
 264                 rootData
 265             }))) {
 266                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 267                 errors = vErrors.length;
 268             }
 269         }
 270         if (data.bodyJoin !== undefined) {
 271             if (!(validate46(data.bodyJoin, {
 272                 instancePath: instancePath + "/bodyJoin",
 273                 parentData: data,
 274                 parentDataProperty: "bodyJoin",
 275                 rootData
 276             }))) {
 277                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 278                 errors = vErrors.length;
 279             }
 280         }
 281         if (data.headerJoin !== undefined) {
 282             if (!(validate46(data.headerJoin, {
 283                 instancePath: instancePath + "/headerJoin",
 284                 parentData: data,
 285                 parentDataProperty: "headerJoin",
 286                 rootData
 287             }))) {
 288                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 289                 errors = vErrors.length;
 290             }
 291         }
 292         if (data.joinBody !== undefined) {
 293             if (!(validate46(data.joinBody, {
 294                 instancePath: instancePath + "/joinBody",
 295                 parentData: data,
 296                 parentDataProperty: "joinBody",
 297                 rootData
 298             }))) {
 299                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 300                 errors = vErrors.length;
 301             }
 302         }
 303         if (data.joinLeft !== undefined) {
 304             if (!(validate46(data.joinLeft, {
 305                 instancePath: instancePath + "/joinLeft",
 306                 parentData: data,
 307                 parentDataProperty: "joinLeft",
 308                 rootData
 309             }))) {
 310                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 311                 errors = vErrors.length;
 312             }
 313         }
 314         if (data.joinRight !== undefined) {
 315             if (!(validate46(data.joinRight, {
 316                 instancePath: instancePath + "/joinRight",
 317                 parentData: data,
 318                 parentDataProperty: "joinRight",
 319                 rootData
 320             }))) {
 321                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 322                 errors = vErrors.length;
 323             }
 324         }
 325         if (data.joinJoin !== undefined) {
 326             if (!(validate46(data.joinJoin, {
 327                 instancePath: instancePath + "/joinJoin",
 328                 parentData: data,
 329                 parentDataProperty: "joinJoin",
 330                 rootData
 331             }))) {
 332                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 333                 errors = vErrors.length;
 334             }
 335         }
 336     }
 337     else {
 338         const err1 = {
 339             instancePath,
 340             schemaPath: "#/type",
 341             keyword: "type",
 342             params: {
 343                 type: "object"
 344             },
 345             message: "must be object"
 346         };
 347         if (vErrors === null) {
 348             vErrors = [err1];
 349         }
 350         else {
 351             vErrors.push(err1);
 352         }
 353         errors++;
 354     }
 355     validate45.errors = vErrors;
 356     return errors === 0;
 357 }
 358 const schema17 = {
 359     "type": "string",
 360     "enum": ["left", "right", "center", "justify"]
 361 };
 362 const func0 = require("ajv/dist/runtime/equal").default;
 363 function validate64(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 364     let vErrors = null;
 365     let errors = 0;
 366     if (typeof data !== "string") {
 367         const err0 = {
 368             instancePath,
 369             schemaPath: "#/type",
 370             keyword: "type",
 371             params: {
 372                 type: "string"
 373             },
 374             message: "must be string"
 375         };
 376         if (vErrors === null) {
 377             vErrors = [err0];
 378         }
 379         else {
 380             vErrors.push(err0);
 381         }
 382         errors++;
 383     }
 384     if (!((((data === "left") || (data === "right")) || (data === "center")) || (data === "justify"))) {
 385         const err1 = {
 386             instancePath,
 387             schemaPath: "#/enum",
 388             keyword: "enum",
 389             params: {
 390                 allowedValues: schema17.enum
 391             },
 392             message: "must be equal to one of the allowed values"
 393         };
 394         if (vErrors === null) {
 395             vErrors = [err1];
 396         }
 397         else {
 398             vErrors.push(err1);
 399         }
 400         errors++;
 401     }
 402     validate64.errors = vErrors;
 403     return errors === 0;
 404 }
 405 const schema18 = {
 406     "oneOf": [{
 407             "type": "object",
 408             "patternProperties": {
 409                 "^[0-9]+$": {
 410                     "$ref": "#/definitions/column"
 411                 }
 412             },
 413             "additionalProperties": false
 414         }, {
 415             "type": "array",
 416             "items": {
 417                 "$ref": "#/definitions/column"
 418             }
 419         }]
 420 };
 421 const pattern0 = new RegExp("^[0-9]+$", "u");
 422 const schema19 = {
 423     "type": "object",
 424     "properties": {
 425         "alignment": {
 426             "$ref": "#/definitions/alignment"
 427         },
 428         "verticalAlignment": {
 429             "type": "string",
 430             "enum": ["top", "middle", "bottom"]
 431         },
 432         "width": {
 433             "type": "integer",
 434             "minimum": 1
 435         },
 436         "wrapWord": {
 437             "type": "boolean"
 438         },
 439         "truncate": {
 440             "type": "integer"
 441         },
 442         "paddingLeft": {
 443             "type": "integer"
 444         },
 445         "paddingRight": {
 446             "type": "integer"
 447         }
 448     },
 449     "additionalProperties": false
 450 };
 451 function validate68(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 452     let vErrors = null;
 453     let errors = 0;
 454     if (typeof data !== "string") {
 455         const err0 = {
 456             instancePath,
 457             schemaPath: "#/type",
 458             keyword: "type",
 459             params: {
 460                 type: "string"
 461             },
 462             message: "must be string"
 463         };
 464         if (vErrors === null) {
 465             vErrors = [err0];
 466         }
 467         else {
 468             vErrors.push(err0);
 469         }
 470         errors++;
 471     }
 472     if (!((((data === "left") || (data === "right")) || (data === "center")) || (data === "justify"))) {
 473         const err1 = {
 474             instancePath,
 475             schemaPath: "#/enum",
 476             keyword: "enum",
 477             params: {
 478                 allowedValues: schema17.enum
 479             },
 480             message: "must be equal to one of the allowed values"
 481         };
 482         if (vErrors === null) {
 483             vErrors = [err1];
 484         }
 485         else {
 486             vErrors.push(err1);
 487         }
 488         errors++;
 489     }
 490     validate68.errors = vErrors;
 491     return errors === 0;
 492 }
 493 function validate67(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 494     let vErrors = null;
 495     let errors = 0;
 496     if (data && typeof data == "object" && !Array.isArray(data)) {
 497         for (const key0 in data) {
 498             if (!(((((((key0 === "alignment") || (key0 === "verticalAlignment")) || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
 499                 const err0 = {
 500                     instancePath,
 501                     schemaPath: "#/additionalProperties",
 502                     keyword: "additionalProperties",
 503                     params: {
 504                         additionalProperty: key0
 505                     },
 506                     message: "must NOT have additional properties"
 507                 };
 508                 if (vErrors === null) {
 509                     vErrors = [err0];
 510                 }
 511                 else {
 512                     vErrors.push(err0);
 513                 }
 514                 errors++;
 515             }
 516         }
 517         if (data.alignment !== undefined) {
 518             if (!(validate68(data.alignment, {
 519                 instancePath: instancePath + "/alignment",
 520                 parentData: data,
 521                 parentDataProperty: "alignment",
 522                 rootData
 523             }))) {
 524                 vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
 525                 errors = vErrors.length;
 526             }
 527         }
 528         if (data.verticalAlignment !== undefined) {
 529             let data1 = data.verticalAlignment;
 530             if (typeof data1 !== "string") {
 531                 const err1 = {
 532                     instancePath: instancePath + "/verticalAlignment",
 533                     schemaPath: "#/properties/verticalAlignment/type",
 534                     keyword: "type",
 535                     params: {
 536                         type: "string"
 537                     },
 538                     message: "must be string"
 539                 };
 540                 if (vErrors === null) {
 541                     vErrors = [err1];
 542                 }
 543                 else {
 544                     vErrors.push(err1);
 545                 }
 546                 errors++;
 547             }
 548             if (!(((data1 === "top") || (data1 === "middle")) || (data1 === "bottom"))) {
 549                 const err2 = {
 550                     instancePath: instancePath + "/verticalAlignment",
 551                     schemaPath: "#/properties/verticalAlignment/enum",
 552                     keyword: "enum",
 553                     params: {
 554                         allowedValues: schema19.properties.verticalAlignment.enum
 555                     },
 556                     message: "must be equal to one of the allowed values"
 557                 };
 558                 if (vErrors === null) {
 559                     vErrors = [err2];
 560                 }
 561                 else {
 562                     vErrors.push(err2);
 563                 }
 564                 errors++;
 565             }
 566         }
 567         if (data.width !== undefined) {
 568             let data2 = data.width;
 569             if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
 570                 const err3 = {
 571                     instancePath: instancePath + "/width",
 572                     schemaPath: "#/properties/width/type",
 573                     keyword: "type",
 574                     params: {
 575                         type: "integer"
 576                     },
 577                     message: "must be integer"
 578                 };
 579                 if (vErrors === null) {
 580                     vErrors = [err3];
 581                 }
 582                 else {
 583                     vErrors.push(err3);
 584                 }
 585                 errors++;
 586             }
 587             if ((typeof data2 == "number") && (isFinite(data2))) {
 588                 if (data2 < 1 || isNaN(data2)) {
 589                     const err4 = {
 590                         instancePath: instancePath + "/width",
 591                         schemaPath: "#/properties/width/minimum",
 592                         keyword: "minimum",
 593                         params: {
 594                             comparison: ">=",
 595                             limit: 1
 596                         },
 597                         message: "must be >= 1"
 598                     };
 599                     if (vErrors === null) {
 600                         vErrors = [err4];
 601                     }
 602                     else {
 603                         vErrors.push(err4);
 604                     }
 605                     errors++;
 606                 }
 607             }
 608         }
 609         if (data.wrapWord !== undefined) {
 610             if (typeof data.wrapWord !== "boolean") {
 611                 const err5 = {
 612                     instancePath: instancePath + "/wrapWord",
 613                     schemaPath: "#/properties/wrapWord/type",
 614                     keyword: "type",
 615                     params: {
 616                         type: "boolean"
 617                     },
 618                     message: "must be boolean"
 619                 };
 620                 if (vErrors === null) {
 621                     vErrors = [err5];
 622                 }
 623                 else {
 624                     vErrors.push(err5);
 625                 }
 626                 errors++;
 627             }
 628         }
 629         if (data.truncate !== undefined) {
 630             let data4 = data.truncate;
 631             if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
 632                 const err6 = {
 633                     instancePath: instancePath + "/truncate",
 634                     schemaPath: "#/properties/truncate/type",
 635                     keyword: "type",
 636                     params: {
 637                         type: "integer"
 638                     },
 639                     message: "must be integer"
 640                 };
 641                 if (vErrors === null) {
 642                     vErrors = [err6];
 643                 }
 644                 else {
 645                     vErrors.push(err6);
 646                 }
 647                 errors++;
 648             }
 649         }
 650         if (data.paddingLeft !== undefined) {
 651             let data5 = data.paddingLeft;
 652             if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
 653                 const err7 = {
 654                     instancePath: instancePath + "/paddingLeft",
 655                     schemaPath: "#/properties/paddingLeft/type",
 656                     keyword: "type",
 657                     params: {
 658                         type: "integer"
 659                     },
 660                     message: "must be integer"
 661                 };
 662                 if (vErrors === null) {
 663                     vErrors = [err7];
 664                 }
 665                 else {
 666                     vErrors.push(err7);
 667                 }
 668                 errors++;
 669             }
 670         }
 671         if (data.paddingRight !== undefined) {
 672             let data6 = data.paddingRight;
 673             if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
 674                 const err8 = {
 675                     instancePath: instancePath + "/paddingRight",
 676                     schemaPath: "#/properties/paddingRight/type",
 677                     keyword: "type",
 678                     params: {
 679                         type: "integer"
 680                     },
 681                     message: "must be integer"
 682                 };
 683                 if (vErrors === null) {
 684                     vErrors = [err8];
 685                 }
 686                 else {
 687                     vErrors.push(err8);
 688                 }
 689                 errors++;
 690             }
 691         }
 692     }
 693     else {
 694         const err9 = {
 695             instancePath,
 696             schemaPath: "#/type",
 697             keyword: "type",
 698             params: {
 699                 type: "object"
 700             },
 701             message: "must be object"
 702         };
 703         if (vErrors === null) {
 704             vErrors = [err9];
 705         }
 706         else {
 707             vErrors.push(err9);
 708         }
 709         errors++;
 710     }
 711     validate67.errors = vErrors;
 712     return errors === 0;
 713 }
 714 function validate66(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 715     let vErrors = null;
 716     let errors = 0;
 717     const _errs0 = errors;
 718     let valid0 = false;
 719     let passing0 = null;
 720     const _errs1 = errors;
 721     if (data && typeof data == "object" && !Array.isArray(data)) {
 722         for (const key0 in data) {
 723             if (!(pattern0.test(key0))) {
 724                 const err0 = {
 725                     instancePath,
 726                     schemaPath: "#/oneOf/0/additionalProperties",
 727                     keyword: "additionalProperties",
 728                     params: {
 729                         additionalProperty: key0
 730                     },
 731                     message: "must NOT have additional properties"
 732                 };
 733                 if (vErrors === null) {
 734                     vErrors = [err0];
 735                 }
 736                 else {
 737                     vErrors.push(err0);
 738                 }
 739                 errors++;
 740             }
 741         }
 742         for (const key1 in data) {
 743             if (pattern0.test(key1)) {
 744                 if (!(validate67(data[key1], {
 745                     instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
 746                     parentData: data,
 747                     parentDataProperty: key1,
 748                     rootData
 749                 }))) {
 750                     vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
 751                     errors = vErrors.length;
 752                 }
 753             }
 754         }
 755     }
 756     else {
 757         const err1 = {
 758             instancePath,
 759             schemaPath: "#/oneOf/0/type",
 760             keyword: "type",
 761             params: {
 762                 type: "object"
 763             },
 764             message: "must be object"
 765         };
 766         if (vErrors === null) {
 767             vErrors = [err1];
 768         }
 769         else {
 770             vErrors.push(err1);
 771         }
 772         errors++;
 773     }
 774     var _valid0 = _errs1 === errors;
 775     if (_valid0) {
 776         valid0 = true;
 777         passing0 = 0;
 778     }
 779     const _errs5 = errors;
 780     if (Array.isArray(data)) {
 781         const len0 = data.length;
 782         for (let i0 = 0; i0 < len0; i0++) {
 783             if (!(validate67(data[i0], {
 784                 instancePath: instancePath + "/" + i0,
 785                 parentData: data,
 786                 parentDataProperty: i0,
 787                 rootData
 788             }))) {
 789                 vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
 790                 errors = vErrors.length;
 791             }
 792         }
 793     }
 794     else {
 795         const err2 = {
 796             instancePath,
 797             schemaPath: "#/oneOf/1/type",
 798             keyword: "type",
 799             params: {
 800                 type: "array"
 801             },
 802             message: "must be array"
 803         };
 804         if (vErrors === null) {
 805             vErrors = [err2];
 806         }
 807         else {
 808             vErrors.push(err2);
 809         }
 810         errors++;
 811     }
 812     var _valid0 = _errs5 === errors;
 813     if (_valid0 && valid0) {
 814         valid0 = false;
 815         passing0 = [passing0, 1];
 816     }
 817     else {
 818         if (_valid0) {
 819             valid0 = true;
 820             passing0 = 1;
 821         }
 822     }
 823     if (!valid0) {
 824         const err3 = {
 825             instancePath,
 826             schemaPath: "#/oneOf",
 827             keyword: "oneOf",
 828             params: {
 829                 passingSchemas: passing0
 830             },
 831             message: "must match exactly one schema in oneOf"
 832         };
 833         if (vErrors === null) {
 834             vErrors = [err3];
 835         }
 836         else {
 837             vErrors.push(err3);
 838         }
 839         errors++;
 840     }
 841     else {
 842         errors = _errs0;
 843         if (vErrors !== null) {
 844             if (_errs0) {
 845                 vErrors.length = _errs0;
 846             }
 847             else {
 848                 vErrors = null;
 849             }
 850         }
 851     }
 852     validate66.errors = vErrors;
 853     return errors === 0;
 854 }
 855 function validate73(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
 856     let vErrors = null;
 857     let errors = 0;
 858     if (data && typeof data == "object" && !Array.isArray(data)) {
 859         for (const key0 in data) {
 860             if (!(((((((key0 === "alignment") || (key0 === "verticalAlignment")) || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
 861                 const err0 = {
 862                     instancePath,
 863                     schemaPath: "#/additionalProperties",
 864                     keyword: "additionalProperties",
 865                     params: {
 866                         additionalProperty: key0
 867                     },
 868                     message: "must NOT have additional properties"
 869                 };
 870                 if (vErrors === null) {
 871                     vErrors = [err0];
 872                 }
 873                 else {
 874                     vErrors.push(err0);
 875                 }
 876                 errors++;
 877             }
 878         }
 879         if (data.alignment !== undefined) {
 880             if (!(validate68(data.alignment, {
 881                 instancePath: instancePath + "/alignment",
 882                 parentData: data,
 883                 parentDataProperty: "alignment",
 884                 rootData
 885             }))) {
 886                 vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
 887                 errors = vErrors.length;
 888             }
 889         }
 890         if (data.verticalAlignment !== undefined) {
 891             let data1 = data.verticalAlignment;
 892             if (typeof data1 !== "string") {
 893                 const err1 = {
 894                     instancePath: instancePath + "/verticalAlignment",
 895                     schemaPath: "#/properties/verticalAlignment/type",
 896                     keyword: "type",
 897                     params: {
 898                         type: "string"
 899                     },
 900                     message: "must be string"
 901                 };
 902                 if (vErrors === null) {
 903                     vErrors = [err1];
 904                 }
 905                 else {
 906                     vErrors.push(err1);
 907                 }
 908                 errors++;
 909             }
 910             if (!(((data1 === "top") || (data1 === "middle")) || (data1 === "bottom"))) {
 911                 const err2 = {
 912                     instancePath: instancePath + "/verticalAlignment",
 913                     schemaPath: "#/properties/verticalAlignment/enum",
 914                     keyword: "enum",
 915                     params: {
 916                         allowedValues: schema19.properties.verticalAlignment.enum
 917                     },
 918                     message: "must be equal to one of the allowed values"
 919                 };
 920                 if (vErrors === null) {
 921                     vErrors = [err2];
 922                 }
 923                 else {
 924                     vErrors.push(err2);
 925                 }
 926                 errors++;
 927             }
 928         }
 929         if (data.width !== undefined) {
 930             let data2 = data.width;
 931             if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
 932                 const err3 = {
 933                     instancePath: instancePath + "/width",
 934                     schemaPath: "#/properties/width/type",
 935                     keyword: "type",
 936                     params: {
 937                         type: "integer"
 938                     },
 939                     message: "must be integer"
 940                 };
 941                 if (vErrors === null) {
 942                     vErrors = [err3];
 943                 }
 944                 else {
 945                     vErrors.push(err3);
 946                 }
 947                 errors++;
 948             }
 949             if ((typeof data2 == "number") && (isFinite(data2))) {
 950                 if (data2 < 1 || isNaN(data2)) {
 951                     const err4 = {
 952                         instancePath: instancePath + "/width",
 953                         schemaPath: "#/properties/width/minimum",
 954                         keyword: "minimum",
 955                         params: {
 956                             comparison: ">=",
 957                             limit: 1
 958                         },
 959                         message: "must be >= 1"
 960                     };
 961                     if (vErrors === null) {
 962                         vErrors = [err4];
 963                     }
 964                     else {
 965                         vErrors.push(err4);
 966                     }
 967                     errors++;
 968                 }
 969             }
 970         }
 971         if (data.wrapWord !== undefined) {
 972             if (typeof data.wrapWord !== "boolean") {
 973                 const err5 = {
 974                     instancePath: instancePath + "/wrapWord",
 975                     schemaPath: "#/properties/wrapWord/type",
 976                     keyword: "type",
 977                     params: {
 978                         type: "boolean"
 979                     },
 980                     message: "must be boolean"
 981                 };
 982                 if (vErrors === null) {
 983                     vErrors = [err5];
 984                 }
 985                 else {
 986                     vErrors.push(err5);
 987                 }
 988                 errors++;
 989             }
 990         }
 991         if (data.truncate !== undefined) {
 992             let data4 = data.truncate;
 993             if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
 994                 const err6 = {
 995                     instancePath: instancePath + "/truncate",
 996                     schemaPath: "#/properties/truncate/type",
 997                     keyword: "type",
 998                     params: {
 999                         type: "integer"
1000                     },
1001                     message: "must be integer"
1002                 };
1003                 if (vErrors === null) {
1004                     vErrors = [err6];
1005                 }
1006                 else {
1007                     vErrors.push(err6);
1008                 }
1009                 errors++;
1010             }
1011         }
1012         if (data.paddingLeft !== undefined) {
1013             let data5 = data.paddingLeft;
1014             if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
1015                 const err7 = {
1016                     instancePath: instancePath + "/paddingLeft",
1017                     schemaPath: "#/properties/paddingLeft/type",
1018                     keyword: "type",
1019                     params: {
1020                         type: "integer"
1021                     },
1022                     message: "must be integer"
1023                 };
1024                 if (vErrors === null) {
1025                     vErrors = [err7];
1026                 }
1027                 else {
1028                     vErrors.push(err7);
1029                 }
1030                 errors++;
1031             }
1032         }
1033         if (data.paddingRight !== undefined) {
1034             let data6 = data.paddingRight;
1035             if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
1036                 const err8 = {
1037                     instancePath: instancePath + "/paddingRight",
1038                     schemaPath: "#/properties/paddingRight/type",
1039                     keyword: "type",
1040                     params: {
1041                         type: "integer"
1042                     },
1043                     message: "must be integer"
1044                 };
1045                 if (vErrors === null) {
1046                     vErrors = [err8];
1047                 }
1048                 else {
1049                     vErrors.push(err8);
1050                 }
1051                 errors++;
1052             }
1053         }
1054     }
1055     else {
1056         const err9 = {
1057             instancePath,
1058             schemaPath: "#/type",
1059             keyword: "type",
1060             params: {
1061                 type: "object"
1062             },
1063             message: "must be object"
1064         };
1065         if (vErrors === null) {
1066             vErrors = [err9];
1067         }
1068         else {
1069             vErrors.push(err9);
1070         }
1071         errors++;
1072     }
1073     validate73.errors = vErrors;
1074     return errors === 0;
1075 }
1076 function validate43(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
1077     /*# sourceURL="config.json" */ ;
1078     let vErrors = null;
1079     let errors = 0;
1080     if (data && typeof data == "object" && !Array.isArray(data)) {
1081         for (const key0 in data) {
1082             if (!(((((((key0 === "border") || (key0 === "header")) || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawVerticalLine")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
1083                 const err0 = {
1084                     instancePath,
1085                     schemaPath: "#/additionalProperties",
1086                     keyword: "additionalProperties",
1087                     params: {
1088                         additionalProperty: key0
1089                     },
1090                     message: "must NOT have additional properties"
1091                 };
1092                 if (vErrors === null) {
1093                     vErrors = [err0];
1094                 }
1095                 else {
1096                     vErrors.push(err0);
1097                 }
1098                 errors++;
1099             }
1100         }
1101         if (data.border !== undefined) {
1102             if (!(validate45(data.border, {
1103                 instancePath: instancePath + "/border",
1104                 parentData: data,
1105                 parentDataProperty: "border",
1106                 rootData
1107             }))) {
1108                 vErrors = vErrors === null ? validate45.errors : vErrors.concat(validate45.errors);
1109                 errors = vErrors.length;
1110             }
1111         }
1112         if (data.header !== undefined) {
1113             let data1 = data.header;
1114             if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
1115                 if (data1.content === undefined) {
1116                     const err1 = {
1117                         instancePath: instancePath + "/header",
1118                         schemaPath: "#/properties/header/required",
1119                         keyword: "required",
1120                         params: {
1121                             missingProperty: "content"
1122                         },
1123                         message: "must have required property '" + "content" + "'"
1124                     };
1125                     if (vErrors === null) {
1126                         vErrors = [err1];
1127                     }
1128                     else {
1129                         vErrors.push(err1);
1130                     }
1131                     errors++;
1132                 }
1133                 for (const key1 in data1) {
1134                     if (!((((((key1 === "content") || (key1 === "alignment")) || (key1 === "wrapWord")) || (key1 === "truncate")) || (key1 === "paddingLeft")) || (key1 === "paddingRight"))) {
1135                         const err2 = {
1136                             instancePath: instancePath + "/header",
1137                             schemaPath: "#/properties/header/additionalProperties",
1138                             keyword: "additionalProperties",
1139                             params: {
1140                                 additionalProperty: key1
1141                             },
1142                             message: "must NOT have additional properties"
1143                         };
1144                         if (vErrors === null) {
1145                             vErrors = [err2];
1146                         }
1147                         else {
1148                             vErrors.push(err2);
1149                         }
1150                         errors++;
1151                     }
1152                 }
1153                 if (data1.content !== undefined) {
1154                     if (typeof data1.content !== "string") {
1155                         const err3 = {
1156                             instancePath: instancePath + "/header/content",
1157                             schemaPath: "#/properties/header/properties/content/type",
1158                             keyword: "type",
1159                             params: {
1160                                 type: "string"
1161                             },
1162                             message: "must be string"
1163                         };
1164                         if (vErrors === null) {
1165                             vErrors = [err3];
1166                         }
1167                         else {
1168                             vErrors.push(err3);
1169                         }
1170                         errors++;
1171                     }
1172                 }
1173                 if (data1.alignment !== undefined) {
1174                     if (!(validate64(data1.alignment, {
1175                         instancePath: instancePath + "/header/alignment",
1176                         parentData: data1,
1177                         parentDataProperty: "alignment",
1178                         rootData
1179                     }))) {
1180                         vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
1181                         errors = vErrors.length;
1182                     }
1183                 }
1184                 if (data1.wrapWord !== undefined) {
1185                     if (typeof data1.wrapWord !== "boolean") {
1186                         const err4 = {
1187                             instancePath: instancePath + "/header/wrapWord",
1188                             schemaPath: "#/properties/header/properties/wrapWord/type",
1189                             keyword: "type",
1190                             params: {
1191                                 type: "boolean"
1192                             },
1193                             message: "must be boolean"
1194                         };
1195                         if (vErrors === null) {
1196                             vErrors = [err4];
1197                         }
1198                         else {
1199                             vErrors.push(err4);
1200                         }
1201                         errors++;
1202                     }
1203                 }
1204                 if (data1.truncate !== undefined) {
1205                     let data5 = data1.truncate;
1206                     if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
1207                         const err5 = {
1208                             instancePath: instancePath + "/header/truncate",
1209                             schemaPath: "#/properties/header/properties/truncate/type",
1210                             keyword: "type",
1211                             params: {
1212                                 type: "integer"
1213                             },
1214                             message: "must be integer"
1215                         };
1216                         if (vErrors === null) {
1217                             vErrors = [err5];
1218                         }
1219                         else {
1220                             vErrors.push(err5);
1221                         }
1222                         errors++;
1223                     }
1224                 }
1225                 if (data1.paddingLeft !== undefined) {
1226                     let data6 = data1.paddingLeft;
1227                     if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
1228                         const err6 = {
1229                             instancePath: instancePath + "/header/paddingLeft",
1230                             schemaPath: "#/properties/header/properties/paddingLeft/type",
1231                             keyword: "type",
1232                             params: {
1233                                 type: "integer"
1234                             },
1235                             message: "must be integer"
1236                         };
1237                         if (vErrors === null) {
1238                             vErrors = [err6];
1239                         }
1240                         else {
1241                             vErrors.push(err6);
1242                         }
1243                         errors++;
1244                     }
1245                 }
1246                 if (data1.paddingRight !== undefined) {
1247                     let data7 = data1.paddingRight;
1248                     if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
1249                         const err7 = {
1250                             instancePath: instancePath + "/header/paddingRight",
1251                             schemaPath: "#/properties/header/properties/paddingRight/type",
1252                             keyword: "type",
1253                             params: {
1254                                 type: "integer"
1255                             },
1256                             message: "must be integer"
1257                         };
1258                         if (vErrors === null) {
1259                             vErrors = [err7];
1260                         }
1261                         else {
1262                             vErrors.push(err7);
1263                         }
1264                         errors++;
1265                     }
1266                 }
1267             }
1268             else {
1269                 const err8 = {
1270                     instancePath: instancePath + "/header",
1271                     schemaPath: "#/properties/header/type",
1272                     keyword: "type",
1273                     params: {
1274                         type: "object"
1275                     },
1276                     message: "must be object"
1277                 };
1278                 if (vErrors === null) {
1279                     vErrors = [err8];
1280                 }
1281                 else {
1282                     vErrors.push(err8);
1283                 }
1284                 errors++;
1285             }
1286         }
1287         if (data.columns !== undefined) {
1288             if (!(validate66(data.columns, {
1289                 instancePath: instancePath + "/columns",
1290                 parentData: data,
1291                 parentDataProperty: "columns",
1292                 rootData
1293             }))) {
1294                 vErrors = vErrors === null ? validate66.errors : vErrors.concat(validate66.errors);
1295                 errors = vErrors.length;
1296             }
1297         }
1298         if (data.columnDefault !== undefined) {
1299             if (!(validate73(data.columnDefault, {
1300                 instancePath: instancePath + "/columnDefault",
1301                 parentData: data,
1302                 parentDataProperty: "columnDefault",
1303                 rootData
1304             }))) {
1305                 vErrors = vErrors === null ? validate73.errors : vErrors.concat(validate73.errors);
1306                 errors = vErrors.length;
1307             }
1308         }
1309         if (data.drawVerticalLine !== undefined) {
1310             if (typeof data.drawVerticalLine != "function") {
1311                 const err9 = {
1312                     instancePath: instancePath + "/drawVerticalLine",
1313                     schemaPath: "#/properties/drawVerticalLine/typeof",
1314                     keyword: "typeof",
1315                     params: {},
1316                     message: "must pass \"typeof\" keyword validation"
1317                 };
1318                 if (vErrors === null) {
1319                     vErrors = [err9];
1320                 }
1321                 else {
1322                     vErrors.push(err9);
1323                 }
1324                 errors++;
1325             }
1326         }
1327         if (data.drawHorizontalLine !== undefined) {
1328             if (typeof data.drawHorizontalLine != "function") {
1329                 const err10 = {
1330                     instancePath: instancePath + "/drawHorizontalLine",
1331                     schemaPath: "#/properties/drawHorizontalLine/typeof",
1332                     keyword: "typeof",
1333                     params: {},
1334                     message: "must pass \"typeof\" keyword validation"
1335                 };
1336                 if (vErrors === null) {
1337                     vErrors = [err10];
1338                 }
1339                 else {
1340                     vErrors.push(err10);
1341                 }
1342                 errors++;
1343             }
1344         }
1345         if (data.singleLine !== undefined) {
1346             if (typeof data.singleLine != "boolean") {
1347                 const err11 = {
1348                     instancePath: instancePath + "/singleLine",
1349                     schemaPath: "#/properties/singleLine/typeof",
1350                     keyword: "typeof",
1351                     params: {},
1352                     message: "must pass \"typeof\" keyword validation"
1353                 };
1354                 if (vErrors === null) {
1355                     vErrors = [err11];
1356                 }
1357                 else {
1358                     vErrors.push(err11);
1359                 }
1360                 errors++;
1361             }
1362         }
1363     }
1364     else {
1365         const err12 = {
1366             instancePath,
1367             schemaPath: "#/type",
1368             keyword: "type",
1369             params: {
1370                 type: "object"
1371             },
1372             message: "must be object"
1373         };
1374         if (vErrors === null) {
1375             vErrors = [err12];
1376         }
1377         else {
1378             vErrors.push(err12);
1379         }
1380         errors++;
1381     }
1382     validate43.errors = vErrors;
1383     return errors === 0;
1384 }
1385 exports["streamConfig.json"] = validate76;
1386 const schema22 = {
1387     "$id": "streamConfig.json",
1388     "$schema": "http://json-schema.org/draft-07/schema#",
1389     "type": "object",
1390     "properties": {
1391         "border": {
1392             "$ref": "shared.json#/definitions/borders"
1393         },
1394         "columns": {
1395             "$ref": "shared.json#/definitions/columns"
1396         },
1397         "columnDefault": {
1398             "$ref": "shared.json#/definitions/column"
1399         },
1400         "columnCount": {
1401             "type": "integer",
1402             "minimum": 1
1403         },
1404         "drawVerticalLine": {
1405             "typeof": "function"
1406         }
1407     },
1408     "required": ["columnDefault", "columnCount"],
1409     "additionalProperties": false
1410 };
1411 function validate77(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
1412     let vErrors = null;
1413     let errors = 0;
1414     if (data && typeof data == "object" && !Array.isArray(data)) {
1415         for (const key0 in data) {
1416             if (!(func8.call(schema15.properties, key0))) {
1417                 const err0 = {
1418                     instancePath,
1419                     schemaPath: "#/additionalProperties",
1420                     keyword: "additionalProperties",
1421                     params: {
1422                         additionalProperty: key0
1423                     },
1424                     message: "must NOT have additional properties"
1425                 };
1426                 if (vErrors === null) {
1427                     vErrors = [err0];
1428                 }
1429                 else {
1430                     vErrors.push(err0);
1431                 }
1432                 errors++;
1433             }
1434         }
1435         if (data.topBody !== undefined) {
1436             if (!(validate46(data.topBody, {
1437                 instancePath: instancePath + "/topBody",
1438                 parentData: data,
1439                 parentDataProperty: "topBody",
1440                 rootData
1441             }))) {
1442                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1443                 errors = vErrors.length;
1444             }
1445         }
1446         if (data.topJoin !== undefined) {
1447             if (!(validate46(data.topJoin, {
1448                 instancePath: instancePath + "/topJoin",
1449                 parentData: data,
1450                 parentDataProperty: "topJoin",
1451                 rootData
1452             }))) {
1453                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1454                 errors = vErrors.length;
1455             }
1456         }
1457         if (data.topLeft !== undefined) {
1458             if (!(validate46(data.topLeft, {
1459                 instancePath: instancePath + "/topLeft",
1460                 parentData: data,
1461                 parentDataProperty: "topLeft",
1462                 rootData
1463             }))) {
1464                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1465                 errors = vErrors.length;
1466             }
1467         }
1468         if (data.topRight !== undefined) {
1469             if (!(validate46(data.topRight, {
1470                 instancePath: instancePath + "/topRight",
1471                 parentData: data,
1472                 parentDataProperty: "topRight",
1473                 rootData
1474             }))) {
1475                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1476                 errors = vErrors.length;
1477             }
1478         }
1479         if (data.bottomBody !== undefined) {
1480             if (!(validate46(data.bottomBody, {
1481                 instancePath: instancePath + "/bottomBody",
1482                 parentData: data,
1483                 parentDataProperty: "bottomBody",
1484                 rootData
1485             }))) {
1486                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1487                 errors = vErrors.length;
1488             }
1489         }
1490         if (data.bottomJoin !== undefined) {
1491             if (!(validate46(data.bottomJoin, {
1492                 instancePath: instancePath + "/bottomJoin",
1493                 parentData: data,
1494                 parentDataProperty: "bottomJoin",
1495                 rootData
1496             }))) {
1497                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1498                 errors = vErrors.length;
1499             }
1500         }
1501         if (data.bottomLeft !== undefined) {
1502             if (!(validate46(data.bottomLeft, {
1503                 instancePath: instancePath + "/bottomLeft",
1504                 parentData: data,
1505                 parentDataProperty: "bottomLeft",
1506                 rootData
1507             }))) {
1508                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1509                 errors = vErrors.length;
1510             }
1511         }
1512         if (data.bottomRight !== undefined) {
1513             if (!(validate46(data.bottomRight, {
1514                 instancePath: instancePath + "/bottomRight",
1515                 parentData: data,
1516                 parentDataProperty: "bottomRight",
1517                 rootData
1518             }))) {
1519                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1520                 errors = vErrors.length;
1521             }
1522         }
1523         if (data.bodyLeft !== undefined) {
1524             if (!(validate46(data.bodyLeft, {
1525                 instancePath: instancePath + "/bodyLeft",
1526                 parentData: data,
1527                 parentDataProperty: "bodyLeft",
1528                 rootData
1529             }))) {
1530                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1531                 errors = vErrors.length;
1532             }
1533         }
1534         if (data.bodyRight !== undefined) {
1535             if (!(validate46(data.bodyRight, {
1536                 instancePath: instancePath + "/bodyRight",
1537                 parentData: data,
1538                 parentDataProperty: "bodyRight",
1539                 rootData
1540             }))) {
1541                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1542                 errors = vErrors.length;
1543             }
1544         }
1545         if (data.bodyJoin !== undefined) {
1546             if (!(validate46(data.bodyJoin, {
1547                 instancePath: instancePath + "/bodyJoin",
1548                 parentData: data,
1549                 parentDataProperty: "bodyJoin",
1550                 rootData
1551             }))) {
1552                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1553                 errors = vErrors.length;
1554             }
1555         }
1556         if (data.headerJoin !== undefined) {
1557             if (!(validate46(data.headerJoin, {
1558                 instancePath: instancePath + "/headerJoin",
1559                 parentData: data,
1560                 parentDataProperty: "headerJoin",
1561                 rootData
1562             }))) {
1563                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1564                 errors = vErrors.length;
1565             }
1566         }
1567         if (data.joinBody !== undefined) {
1568             if (!(validate46(data.joinBody, {
1569                 instancePath: instancePath + "/joinBody",
1570                 parentData: data,
1571                 parentDataProperty: "joinBody",
1572                 rootData
1573             }))) {
1574                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1575                 errors = vErrors.length;
1576             }
1577         }
1578         if (data.joinLeft !== undefined) {
1579             if (!(validate46(data.joinLeft, {
1580                 instancePath: instancePath + "/joinLeft",
1581                 parentData: data,
1582                 parentDataProperty: "joinLeft",
1583                 rootData
1584             }))) {
1585                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1586                 errors = vErrors.length;
1587             }
1588         }
1589         if (data.joinRight !== undefined) {
1590             if (!(validate46(data.joinRight, {
1591                 instancePath: instancePath + "/joinRight",
1592                 parentData: data,
1593                 parentDataProperty: "joinRight",
1594                 rootData
1595             }))) {
1596                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1597                 errors = vErrors.length;
1598             }
1599         }
1600         if (data.joinJoin !== undefined) {
1601             if (!(validate46(data.joinJoin, {
1602                 instancePath: instancePath + "/joinJoin",
1603                 parentData: data,
1604                 parentDataProperty: "joinJoin",
1605                 rootData
1606             }))) {
1607                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1608                 errors = vErrors.length;
1609             }
1610         }
1611     }
1612     else {
1613         const err1 = {
1614             instancePath,
1615             schemaPath: "#/type",
1616             keyword: "type",
1617             params: {
1618                 type: "object"
1619             },
1620             message: "must be object"
1621         };
1622         if (vErrors === null) {
1623             vErrors = [err1];
1624         }
1625         else {
1626             vErrors.push(err1);
1627         }
1628         errors++;
1629     }
1630     validate77.errors = vErrors;
1631     return errors === 0;
1632 }
1633 function validate95(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
1634     let vErrors = null;
1635     let errors = 0;
1636     const _errs0 = errors;
1637     let valid0 = false;
1638     let passing0 = null;
1639     const _errs1 = errors;
1640     if (data && typeof data == "object" && !Array.isArray(data)) {
1641         for (const key0 in data) {
1642             if (!(pattern0.test(key0))) {
1643                 const err0 = {
1644                     instancePath,
1645                     schemaPath: "#/oneOf/0/additionalProperties",
1646                     keyword: "additionalProperties",
1647                     params: {
1648                         additionalProperty: key0
1649                     },
1650                     message: "must NOT have additional properties"
1651                 };
1652                 if (vErrors === null) {
1653                     vErrors = [err0];
1654                 }
1655                 else {
1656                     vErrors.push(err0);
1657                 }
1658                 errors++;
1659             }
1660         }
1661         for (const key1 in data) {
1662             if (pattern0.test(key1)) {
1663                 if (!(validate67(data[key1], {
1664                     instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
1665                     parentData: data,
1666                     parentDataProperty: key1,
1667                     rootData
1668                 }))) {
1669                     vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
1670                     errors = vErrors.length;
1671                 }
1672             }
1673         }
1674     }
1675     else {
1676         const err1 = {
1677             instancePath,
1678             schemaPath: "#/oneOf/0/type",
1679             keyword: "type",
1680             params: {
1681                 type: "object"
1682             },
1683             message: "must be object"
1684         };
1685         if (vErrors === null) {
1686             vErrors = [err1];
1687         }
1688         else {
1689             vErrors.push(err1);
1690         }
1691         errors++;
1692     }
1693     var _valid0 = _errs1 === errors;
1694     if (_valid0) {
1695         valid0 = true;
1696         passing0 = 0;
1697     }
1698     const _errs5 = errors;
1699     if (Array.isArray(data)) {
1700         const len0 = data.length;
1701         for (let i0 = 0; i0 < len0; i0++) {
1702             if (!(validate67(data[i0], {
1703                 instancePath: instancePath + "/" + i0,
1704                 parentData: data,
1705                 parentDataProperty: i0,
1706                 rootData
1707             }))) {
1708                 vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
1709                 errors = vErrors.length;
1710             }
1711         }
1712     }
1713     else {
1714         const err2 = {
1715             instancePath,
1716             schemaPath: "#/oneOf/1/type",
1717             keyword: "type",
1718             params: {
1719                 type: "array"
1720             },
1721             message: "must be array"
1722         };
1723         if (vErrors === null) {
1724             vErrors = [err2];
1725         }
1726         else {
1727             vErrors.push(err2);
1728         }
1729         errors++;
1730     }
1731     var _valid0 = _errs5 === errors;
1732     if (_valid0 && valid0) {
1733         valid0 = false;
1734         passing0 = [passing0, 1];
1735     }
1736     else {
1737         if (_valid0) {
1738             valid0 = true;
1739             passing0 = 1;
1740         }
1741     }
1742     if (!valid0) {
1743         const err3 = {
1744             instancePath,
1745             schemaPath: "#/oneOf",
1746             keyword: "oneOf",
1747             params: {
1748                 passingSchemas: passing0
1749             },
1750             message: "must match exactly one schema in oneOf"
1751         };
1752         if (vErrors === null) {
1753             vErrors = [err3];
1754         }
1755         else {
1756             vErrors.push(err3);
1757         }
1758         errors++;
1759     }
1760     else {
1761         errors = _errs0;
1762         if (vErrors !== null) {
1763             if (_errs0) {
1764                 vErrors.length = _errs0;
1765             }
1766             else {
1767                 vErrors = null;
1768             }
1769         }
1770     }
1771     validate95.errors = vErrors;
1772     return errors === 0;
1773 }
1774 function validate99(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
1775     let vErrors = null;
1776     let errors = 0;
1777     if (data && typeof data == "object" && !Array.isArray(data)) {
1778         for (const key0 in data) {
1779             if (!(((((((key0 === "alignment") || (key0 === "verticalAlignment")) || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
1780                 const err0 = {
1781                     instancePath,
1782                     schemaPath: "#/additionalProperties",
1783                     keyword: "additionalProperties",
1784                     params: {
1785                         additionalProperty: key0
1786                     },
1787                     message: "must NOT have additional properties"
1788                 };
1789                 if (vErrors === null) {
1790                     vErrors = [err0];
1791                 }
1792                 else {
1793                     vErrors.push(err0);
1794                 }
1795                 errors++;
1796             }
1797         }
1798         if (data.alignment !== undefined) {
1799             if (!(validate68(data.alignment, {
1800                 instancePath: instancePath + "/alignment",
1801                 parentData: data,
1802                 parentDataProperty: "alignment",
1803                 rootData
1804             }))) {
1805                 vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
1806                 errors = vErrors.length;
1807             }
1808         }
1809         if (data.verticalAlignment !== undefined) {
1810             let data1 = data.verticalAlignment;
1811             if (typeof data1 !== "string") {
1812                 const err1 = {
1813                     instancePath: instancePath + "/verticalAlignment",
1814                     schemaPath: "#/properties/verticalAlignment/type",
1815                     keyword: "type",
1816                     params: {
1817                         type: "string"
1818                     },
1819                     message: "must be string"
1820                 };
1821                 if (vErrors === null) {
1822                     vErrors = [err1];
1823                 }
1824                 else {
1825                     vErrors.push(err1);
1826                 }
1827                 errors++;
1828             }
1829             if (!(((data1 === "top") || (data1 === "middle")) || (data1 === "bottom"))) {
1830                 const err2 = {
1831                     instancePath: instancePath + "/verticalAlignment",
1832                     schemaPath: "#/properties/verticalAlignment/enum",
1833                     keyword: "enum",
1834                     params: {
1835                         allowedValues: schema19.properties.verticalAlignment.enum
1836                     },
1837                     message: "must be equal to one of the allowed values"
1838                 };
1839                 if (vErrors === null) {
1840                     vErrors = [err2];
1841                 }
1842                 else {
1843                     vErrors.push(err2);
1844                 }
1845                 errors++;
1846             }
1847         }
1848         if (data.width !== undefined) {
1849             let data2 = data.width;
1850             if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
1851                 const err3 = {
1852                     instancePath: instancePath + "/width",
1853                     schemaPath: "#/properties/width/type",
1854                     keyword: "type",
1855                     params: {
1856                         type: "integer"
1857                     },
1858                     message: "must be integer"
1859                 };
1860                 if (vErrors === null) {
1861                     vErrors = [err3];
1862                 }
1863                 else {
1864                     vErrors.push(err3);
1865                 }
1866                 errors++;
1867             }
1868             if ((typeof data2 == "number") && (isFinite(data2))) {
1869                 if (data2 < 1 || isNaN(data2)) {
1870                     const err4 = {
1871                         instancePath: instancePath + "/width",
1872                         schemaPath: "#/properties/width/minimum",
1873                         keyword: "minimum",
1874                         params: {
1875                             comparison: ">=",
1876                             limit: 1
1877                         },
1878                         message: "must be >= 1"
1879                     };
1880                     if (vErrors === null) {
1881                         vErrors = [err4];
1882                     }
1883                     else {
1884                         vErrors.push(err4);
1885                     }
1886                     errors++;
1887                 }
1888             }
1889         }
1890         if (data.wrapWord !== undefined) {
1891             if (typeof data.wrapWord !== "boolean") {
1892                 const err5 = {
1893                     instancePath: instancePath + "/wrapWord",
1894                     schemaPath: "#/properties/wrapWord/type",
1895                     keyword: "type",
1896                     params: {
1897                         type: "boolean"
1898                     },
1899                     message: "must be boolean"
1900                 };
1901                 if (vErrors === null) {
1902                     vErrors = [err5];
1903                 }
1904                 else {
1905                     vErrors.push(err5);
1906                 }
1907                 errors++;
1908             }
1909         }
1910         if (data.truncate !== undefined) {
1911             let data4 = data.truncate;
1912             if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
1913                 const err6 = {
1914                     instancePath: instancePath + "/truncate",
1915                     schemaPath: "#/properties/truncate/type",
1916                     keyword: "type",
1917                     params: {
1918                         type: "integer"
1919                     },
1920                     message: "must be integer"
1921                 };
1922                 if (vErrors === null) {
1923                     vErrors = [err6];
1924                 }
1925                 else {
1926                     vErrors.push(err6);
1927                 }
1928                 errors++;
1929             }
1930         }
1931         if (data.paddingLeft !== undefined) {
1932             let data5 = data.paddingLeft;
1933             if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
1934                 const err7 = {
1935                     instancePath: instancePath + "/paddingLeft",
1936                     schemaPath: "#/properties/paddingLeft/type",
1937                     keyword: "type",
1938                     params: {
1939                         type: "integer"
1940                     },
1941                     message: "must be integer"
1942                 };
1943                 if (vErrors === null) {
1944                     vErrors = [err7];
1945                 }
1946                 else {
1947                     vErrors.push(err7);
1948                 }
1949                 errors++;
1950             }
1951         }
1952         if (data.paddingRight !== undefined) {
1953             let data6 = data.paddingRight;
1954             if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
1955                 const err8 = {
1956                     instancePath: instancePath + "/paddingRight",
1957                     schemaPath: "#/properties/paddingRight/type",
1958                     keyword: "type",
1959                     params: {
1960                         type: "integer"
1961                     },
1962                     message: "must be integer"
1963                 };
1964                 if (vErrors === null) {
1965                     vErrors = [err8];
1966                 }
1967                 else {
1968                     vErrors.push(err8);
1969                 }
1970                 errors++;
1971             }
1972         }
1973     }
1974     else {
1975         const err9 = {
1976             instancePath,
1977             schemaPath: "#/type",
1978             keyword: "type",
1979             params: {
1980                 type: "object"
1981             },
1982             message: "must be object"
1983         };
1984         if (vErrors === null) {
1985             vErrors = [err9];
1986         }
1987         else {
1988             vErrors.push(err9);
1989         }
1990         errors++;
1991     }
1992     validate99.errors = vErrors;
1993     return errors === 0;
1994 }
1995 function validate76(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
1996     /*# sourceURL="streamConfig.json" */ ;
1997     let vErrors = null;
1998     let errors = 0;
1999     if (data && typeof data == "object" && !Array.isArray(data)) {
2000         if (data.columnDefault === undefined) {
2001             const err0 = {
2002                 instancePath,
2003                 schemaPath: "#/required",
2004                 keyword: "required",
2005                 params: {
2006                     missingProperty: "columnDefault"
2007                 },
2008                 message: "must have required property '" + "columnDefault" + "'"
2009             };
2010             if (vErrors === null) {
2011                 vErrors = [err0];
2012             }
2013             else {
2014                 vErrors.push(err0);
2015             }
2016             errors++;
2017         }
2018         if (data.columnCount === undefined) {
2019             const err1 = {
2020                 instancePath,
2021                 schemaPath: "#/required",
2022                 keyword: "required",
2023                 params: {
2024                     missingProperty: "columnCount"
2025                 },
2026                 message: "must have required property '" + "columnCount" + "'"
2027             };
2028             if (vErrors === null) {
2029                 vErrors = [err1];
2030             }
2031             else {
2032                 vErrors.push(err1);
2033             }
2034             errors++;
2035         }
2036         for (const key0 in data) {
2037             if (!(((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "columnCount")) || (key0 === "drawVerticalLine"))) {
2038                 const err2 = {
2039                     instancePath,
2040                     schemaPath: "#/additionalProperties",
2041                     keyword: "additionalProperties",
2042                     params: {
2043                         additionalProperty: key0
2044                     },
2045                     message: "must NOT have additional properties"
2046                 };
2047                 if (vErrors === null) {
2048                     vErrors = [err2];
2049                 }
2050                 else {
2051                     vErrors.push(err2);
2052                 }
2053                 errors++;
2054             }
2055         }
2056         if (data.border !== undefined) {
2057             if (!(validate77(data.border, {
2058                 instancePath: instancePath + "/border",
2059                 parentData: data,
2060                 parentDataProperty: "border",
2061                 rootData
2062             }))) {
2063                 vErrors = vErrors === null ? validate77.errors : vErrors.concat(validate77.errors);
2064                 errors = vErrors.length;
2065             }
2066         }
2067         if (data.columns !== undefined) {
2068             if (!(validate95(data.columns, {
2069                 instancePath: instancePath + "/columns",
2070                 parentData: data,
2071                 parentDataProperty: "columns",
2072                 rootData
2073             }))) {
2074                 vErrors = vErrors === null ? validate95.errors : vErrors.concat(validate95.errors);
2075                 errors = vErrors.length;
2076             }
2077         }
2078         if (data.columnDefault !== undefined) {
2079             if (!(validate99(data.columnDefault, {
2080                 instancePath: instancePath + "/columnDefault",
2081                 parentData: data,
2082                 parentDataProperty: "columnDefault",
2083                 rootData
2084             }))) {
2085                 vErrors = vErrors === null ? validate99.errors : vErrors.concat(validate99.errors);
2086                 errors = vErrors.length;
2087             }
2088         }
2089         if (data.columnCount !== undefined) {
2090             let data3 = data.columnCount;
2091             if (!(((typeof data3 == "number") && (!(data3 % 1) && !isNaN(data3))) && (isFinite(data3)))) {
2092                 const err3 = {
2093                     instancePath: instancePath + "/columnCount",
2094                     schemaPath: "#/properties/columnCount/type",
2095                     keyword: "type",
2096                     params: {
2097                         type: "integer"
2098                     },
2099                     message: "must be integer"
2100                 };
2101                 if (vErrors === null) {
2102                     vErrors = [err3];
2103                 }
2104                 else {
2105                     vErrors.push(err3);
2106                 }
2107                 errors++;
2108             }
2109             if ((typeof data3 == "number") && (isFinite(data3))) {
2110                 if (data3 < 1 || isNaN(data3)) {
2111                     const err4 = {
2112                         instancePath: instancePath + "/columnCount",
2113                         schemaPath: "#/properties/columnCount/minimum",
2114                         keyword: "minimum",
2115                         params: {
2116                             comparison: ">=",
2117                             limit: 1
2118                         },
2119                         message: "must be >= 1"
2120                     };
2121                     if (vErrors === null) {
2122                         vErrors = [err4];
2123                     }
2124                     else {
2125                         vErrors.push(err4);
2126                     }
2127                     errors++;
2128                 }
2129             }
2130         }
2131         if (data.drawVerticalLine !== undefined) {
2132             if (typeof data.drawVerticalLine != "function") {
2133                 const err5 = {
2134                     instancePath: instancePath + "/drawVerticalLine",
2135                     schemaPath: "#/properties/drawVerticalLine/typeof",
2136                     keyword: "typeof",
2137                     params: {},
2138                     message: "must pass \"typeof\" keyword validation"
2139                 };
2140                 if (vErrors === null) {
2141                     vErrors = [err5];
2142                 }
2143                 else {
2144                     vErrors.push(err5);
2145                 }
2146                 errors++;
2147             }
2148         }
2149     }
2150     else {
2151         const err6 = {
2152             instancePath,
2153             schemaPath: "#/type",
2154             keyword: "type",
2155             params: {
2156                 type: "object"
2157             },
2158             message: "must be object"
2159         };
2160         if (vErrors === null) {
2161             vErrors = [err6];
2162         }
2163         else {
2164             vErrors.push(err6);
2165         }
2166         errors++;
2167     }
2168     validate76.errors = vErrors;
2169     return errors === 0;
2170 }
2171 //# sourceMappingURL=validators.js.map