.config/coc/extensions/node_modules/coc-prettier/node_modules/table/dist/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         "columns": {
  12             "$ref": "shared.json#/definitions/columns"
  13         },
  14         "columnDefault": {
  15             "$ref": "shared.json#/definitions/column"
  16         },
  17         "drawHorizontalLine": {
  18             "typeof": "function"
  19         },
  20         "singleLine": {
  21             "typeof": "boolean"
  22         }
  23     },
  24     "additionalProperties": false
  25 };
  26 const schema15 = {
  27     "type": "object",
  28     "properties": {
  29         "topBody": {
  30             "$ref": "#/definitions/border"
  31         },
  32         "topJoin": {
  33             "$ref": "#/definitions/border"
  34         },
  35         "topLeft": {
  36             "$ref": "#/definitions/border"
  37         },
  38         "topRight": {
  39             "$ref": "#/definitions/border"
  40         },
  41         "bottomBody": {
  42             "$ref": "#/definitions/border"
  43         },
  44         "bottomJoin": {
  45             "$ref": "#/definitions/border"
  46         },
  47         "bottomLeft": {
  48             "$ref": "#/definitions/border"
  49         },
  50         "bottomRight": {
  51             "$ref": "#/definitions/border"
  52         },
  53         "bodyLeft": {
  54             "$ref": "#/definitions/border"
  55         },
  56         "bodyRight": {
  57             "$ref": "#/definitions/border"
  58         },
  59         "bodyJoin": {
  60             "$ref": "#/definitions/border"
  61         },
  62         "joinBody": {
  63             "$ref": "#/definitions/border"
  64         },
  65         "joinLeft": {
  66             "$ref": "#/definitions/border"
  67         },
  68         "joinRight": {
  69             "$ref": "#/definitions/border"
  70         },
  71         "joinJoin": {
  72             "$ref": "#/definitions/border"
  73         }
  74     },
  75     "additionalProperties": false
  76 };
  77 const func8 = Object.prototype.hasOwnProperty;
  78 const schema16 = {
  79     "type": "string"
  80 };
  81
  82 function validate46(data, {
  83     instancePath = "",
  84     parentData,
  85     parentDataProperty,
  86     rootData = data
  87 } = {}) {
  88     let vErrors = null;
  89     let errors = 0;
  90     if (typeof data !== "string") {
  91         const err0 = {
  92             instancePath,
  93             schemaPath: "#/type",
  94             keyword: "type",
  95             params: {
  96                 type: "string"
  97             },
  98             message: "must be string"
  99         };
 100         if (vErrors === null) {
 101             vErrors = [err0];
 102         } else {
 103             vErrors.push(err0);
 104         }
 105         errors++;
 106     }
 107     validate46.errors = vErrors;
 108     return errors === 0;
 109 }
 110
 111 function validate45(data, {
 112     instancePath = "",
 113     parentData,
 114     parentDataProperty,
 115     rootData = data
 116 } = {}) {
 117     let vErrors = null;
 118     let errors = 0;
 119     if (data && typeof data == "object" && !Array.isArray(data)) {
 120         for (const key0 in data) {
 121             if (!(func8.call(schema15.properties, key0))) {
 122                 const err0 = {
 123                     instancePath,
 124                     schemaPath: "#/additionalProperties",
 125                     keyword: "additionalProperties",
 126                     params: {
 127                         additionalProperty: key0
 128                     },
 129                     message: "must NOT have additional properties"
 130                 };
 131                 if (vErrors === null) {
 132                     vErrors = [err0];
 133                 } else {
 134                     vErrors.push(err0);
 135                 }
 136                 errors++;
 137             }
 138         }
 139         if (data.topBody !== undefined) {
 140             if (!(validate46(data.topBody, {
 141                     instancePath: instancePath + "/topBody",
 142                     parentData: data,
 143                     parentDataProperty: "topBody",
 144                     rootData
 145                 }))) {
 146                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 147                 errors = vErrors.length;
 148             }
 149         }
 150         if (data.topJoin !== undefined) {
 151             if (!(validate46(data.topJoin, {
 152                     instancePath: instancePath + "/topJoin",
 153                     parentData: data,
 154                     parentDataProperty: "topJoin",
 155                     rootData
 156                 }))) {
 157                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 158                 errors = vErrors.length;
 159             }
 160         }
 161         if (data.topLeft !== undefined) {
 162             if (!(validate46(data.topLeft, {
 163                     instancePath: instancePath + "/topLeft",
 164                     parentData: data,
 165                     parentDataProperty: "topLeft",
 166                     rootData
 167                 }))) {
 168                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 169                 errors = vErrors.length;
 170             }
 171         }
 172         if (data.topRight !== undefined) {
 173             if (!(validate46(data.topRight, {
 174                     instancePath: instancePath + "/topRight",
 175                     parentData: data,
 176                     parentDataProperty: "topRight",
 177                     rootData
 178                 }))) {
 179                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 180                 errors = vErrors.length;
 181             }
 182         }
 183         if (data.bottomBody !== undefined) {
 184             if (!(validate46(data.bottomBody, {
 185                     instancePath: instancePath + "/bottomBody",
 186                     parentData: data,
 187                     parentDataProperty: "bottomBody",
 188                     rootData
 189                 }))) {
 190                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 191                 errors = vErrors.length;
 192             }
 193         }
 194         if (data.bottomJoin !== undefined) {
 195             if (!(validate46(data.bottomJoin, {
 196                     instancePath: instancePath + "/bottomJoin",
 197                     parentData: data,
 198                     parentDataProperty: "bottomJoin",
 199                     rootData
 200                 }))) {
 201                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 202                 errors = vErrors.length;
 203             }
 204         }
 205         if (data.bottomLeft !== undefined) {
 206             if (!(validate46(data.bottomLeft, {
 207                     instancePath: instancePath + "/bottomLeft",
 208                     parentData: data,
 209                     parentDataProperty: "bottomLeft",
 210                     rootData
 211                 }))) {
 212                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 213                 errors = vErrors.length;
 214             }
 215         }
 216         if (data.bottomRight !== undefined) {
 217             if (!(validate46(data.bottomRight, {
 218                     instancePath: instancePath + "/bottomRight",
 219                     parentData: data,
 220                     parentDataProperty: "bottomRight",
 221                     rootData
 222                 }))) {
 223                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 224                 errors = vErrors.length;
 225             }
 226         }
 227         if (data.bodyLeft !== undefined) {
 228             if (!(validate46(data.bodyLeft, {
 229                     instancePath: instancePath + "/bodyLeft",
 230                     parentData: data,
 231                     parentDataProperty: "bodyLeft",
 232                     rootData
 233                 }))) {
 234                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 235                 errors = vErrors.length;
 236             }
 237         }
 238         if (data.bodyRight !== undefined) {
 239             if (!(validate46(data.bodyRight, {
 240                     instancePath: instancePath + "/bodyRight",
 241                     parentData: data,
 242                     parentDataProperty: "bodyRight",
 243                     rootData
 244                 }))) {
 245                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 246                 errors = vErrors.length;
 247             }
 248         }
 249         if (data.bodyJoin !== undefined) {
 250             if (!(validate46(data.bodyJoin, {
 251                     instancePath: instancePath + "/bodyJoin",
 252                     parentData: data,
 253                     parentDataProperty: "bodyJoin",
 254                     rootData
 255                 }))) {
 256                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 257                 errors = vErrors.length;
 258             }
 259         }
 260         if (data.joinBody !== undefined) {
 261             if (!(validate46(data.joinBody, {
 262                     instancePath: instancePath + "/joinBody",
 263                     parentData: data,
 264                     parentDataProperty: "joinBody",
 265                     rootData
 266                 }))) {
 267                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 268                 errors = vErrors.length;
 269             }
 270         }
 271         if (data.joinLeft !== undefined) {
 272             if (!(validate46(data.joinLeft, {
 273                     instancePath: instancePath + "/joinLeft",
 274                     parentData: data,
 275                     parentDataProperty: "joinLeft",
 276                     rootData
 277                 }))) {
 278                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 279                 errors = vErrors.length;
 280             }
 281         }
 282         if (data.joinRight !== undefined) {
 283             if (!(validate46(data.joinRight, {
 284                     instancePath: instancePath + "/joinRight",
 285                     parentData: data,
 286                     parentDataProperty: "joinRight",
 287                     rootData
 288                 }))) {
 289                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 290                 errors = vErrors.length;
 291             }
 292         }
 293         if (data.joinJoin !== undefined) {
 294             if (!(validate46(data.joinJoin, {
 295                     instancePath: instancePath + "/joinJoin",
 296                     parentData: data,
 297                     parentDataProperty: "joinJoin",
 298                     rootData
 299                 }))) {
 300                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 301                 errors = vErrors.length;
 302             }
 303         }
 304     } else {
 305         const err1 = {
 306             instancePath,
 307             schemaPath: "#/type",
 308             keyword: "type",
 309             params: {
 310                 type: "object"
 311             },
 312             message: "must be object"
 313         };
 314         if (vErrors === null) {
 315             vErrors = [err1];
 316         } else {
 317             vErrors.push(err1);
 318         }
 319         errors++;
 320     }
 321     validate45.errors = vErrors;
 322     return errors === 0;
 323 }
 324 const schema17 = {
 325     "type": "object",
 326     "patternProperties": {
 327         "^[0-9]+$": {
 328             "$ref": "#/definitions/column"
 329         }
 330     },
 331     "additionalProperties": false
 332 };
 333 const pattern0 = new RegExp("^[0-9]+$", "u");
 334 const schema18 = {
 335     "type": "object",
 336     "properties": {
 337         "alignment": {
 338             "type": "string",
 339             "enum": ["left", "right", "center"]
 340         },
 341         "width": {
 342             "type": "number"
 343         },
 344         "wrapWord": {
 345             "type": "boolean"
 346         },
 347         "truncate": {
 348             "type": "number"
 349         },
 350         "paddingLeft": {
 351             "type": "number"
 352         },
 353         "paddingRight": {
 354             "type": "number"
 355         }
 356     },
 357     "additionalProperties": false
 358 };
 359 const func0 = require("ajv/dist/runtime/equal").default;
 360
 361 function validate64(data, {
 362     instancePath = "",
 363     parentData,
 364     parentDataProperty,
 365     rootData = data
 366 } = {}) {
 367     let vErrors = null;
 368     let errors = 0;
 369     if (data && typeof data == "object" && !Array.isArray(data)) {
 370         for (const key0 in data) {
 371             if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
 372                 const err0 = {
 373                     instancePath,
 374                     schemaPath: "#/additionalProperties",
 375                     keyword: "additionalProperties",
 376                     params: {
 377                         additionalProperty: key0
 378                     },
 379                     message: "must NOT have additional properties"
 380                 };
 381                 if (vErrors === null) {
 382                     vErrors = [err0];
 383                 } else {
 384                     vErrors.push(err0);
 385                 }
 386                 errors++;
 387             }
 388         }
 389         if (data.alignment !== undefined) {
 390             let data0 = data.alignment;
 391             if (typeof data0 !== "string") {
 392                 const err1 = {
 393                     instancePath: instancePath + "/alignment",
 394                     schemaPath: "#/properties/alignment/type",
 395                     keyword: "type",
 396                     params: {
 397                         type: "string"
 398                     },
 399                     message: "must be string"
 400                 };
 401                 if (vErrors === null) {
 402                     vErrors = [err1];
 403                 } else {
 404                     vErrors.push(err1);
 405                 }
 406                 errors++;
 407             }
 408             if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
 409                 const err2 = {
 410                     instancePath: instancePath + "/alignment",
 411                     schemaPath: "#/properties/alignment/enum",
 412                     keyword: "enum",
 413                     params: {
 414                         allowedValues: schema18.properties.alignment.enum
 415                     },
 416                     message: "must be equal to one of the allowed values"
 417                 };
 418                 if (vErrors === null) {
 419                     vErrors = [err2];
 420                 } else {
 421                     vErrors.push(err2);
 422                 }
 423                 errors++;
 424             }
 425         }
 426         if (data.width !== undefined) {
 427             let data1 = data.width;
 428             if (!((typeof data1 == "number") && (isFinite(data1)))) {
 429                 const err3 = {
 430                     instancePath: instancePath + "/width",
 431                     schemaPath: "#/properties/width/type",
 432                     keyword: "type",
 433                     params: {
 434                         type: "number"
 435                     },
 436                     message: "must be number"
 437                 };
 438                 if (vErrors === null) {
 439                     vErrors = [err3];
 440                 } else {
 441                     vErrors.push(err3);
 442                 }
 443                 errors++;
 444             }
 445         }
 446         if (data.wrapWord !== undefined) {
 447             if (typeof data.wrapWord !== "boolean") {
 448                 const err4 = {
 449                     instancePath: instancePath + "/wrapWord",
 450                     schemaPath: "#/properties/wrapWord/type",
 451                     keyword: "type",
 452                     params: {
 453                         type: "boolean"
 454                     },
 455                     message: "must be boolean"
 456                 };
 457                 if (vErrors === null) {
 458                     vErrors = [err4];
 459                 } else {
 460                     vErrors.push(err4);
 461                 }
 462                 errors++;
 463             }
 464         }
 465         if (data.truncate !== undefined) {
 466             let data3 = data.truncate;
 467             if (!((typeof data3 == "number") && (isFinite(data3)))) {
 468                 const err5 = {
 469                     instancePath: instancePath + "/truncate",
 470                     schemaPath: "#/properties/truncate/type",
 471                     keyword: "type",
 472                     params: {
 473                         type: "number"
 474                     },
 475                     message: "must be number"
 476                 };
 477                 if (vErrors === null) {
 478                     vErrors = [err5];
 479                 } else {
 480                     vErrors.push(err5);
 481                 }
 482                 errors++;
 483             }
 484         }
 485         if (data.paddingLeft !== undefined) {
 486             let data4 = data.paddingLeft;
 487             if (!((typeof data4 == "number") && (isFinite(data4)))) {
 488                 const err6 = {
 489                     instancePath: instancePath + "/paddingLeft",
 490                     schemaPath: "#/properties/paddingLeft/type",
 491                     keyword: "type",
 492                     params: {
 493                         type: "number"
 494                     },
 495                     message: "must be number"
 496                 };
 497                 if (vErrors === null) {
 498                     vErrors = [err6];
 499                 } else {
 500                     vErrors.push(err6);
 501                 }
 502                 errors++;
 503             }
 504         }
 505         if (data.paddingRight !== undefined) {
 506             let data5 = data.paddingRight;
 507             if (!((typeof data5 == "number") && (isFinite(data5)))) {
 508                 const err7 = {
 509                     instancePath: instancePath + "/paddingRight",
 510                     schemaPath: "#/properties/paddingRight/type",
 511                     keyword: "type",
 512                     params: {
 513                         type: "number"
 514                     },
 515                     message: "must be number"
 516                 };
 517                 if (vErrors === null) {
 518                     vErrors = [err7];
 519                 } else {
 520                     vErrors.push(err7);
 521                 }
 522                 errors++;
 523             }
 524         }
 525     } else {
 526         const err8 = {
 527             instancePath,
 528             schemaPath: "#/type",
 529             keyword: "type",
 530             params: {
 531                 type: "object"
 532             },
 533             message: "must be object"
 534         };
 535         if (vErrors === null) {
 536             vErrors = [err8];
 537         } else {
 538             vErrors.push(err8);
 539         }
 540         errors++;
 541     }
 542     validate64.errors = vErrors;
 543     return errors === 0;
 544 }
 545
 546 function validate63(data, {
 547     instancePath = "",
 548     parentData,
 549     parentDataProperty,
 550     rootData = data
 551 } = {}) {
 552     let vErrors = null;
 553     let errors = 0;
 554     if (data && typeof data == "object" && !Array.isArray(data)) {
 555         for (const key0 in data) {
 556             if (!(pattern0.test(key0))) {
 557                 const err0 = {
 558                     instancePath,
 559                     schemaPath: "#/additionalProperties",
 560                     keyword: "additionalProperties",
 561                     params: {
 562                         additionalProperty: key0
 563                     },
 564                     message: "must NOT have additional properties"
 565                 };
 566                 if (vErrors === null) {
 567                     vErrors = [err0];
 568                 } else {
 569                     vErrors.push(err0);
 570                 }
 571                 errors++;
 572             }
 573         }
 574         for (const key1 in data) {
 575             if (pattern0.test(key1)) {
 576                 if (!(validate64(data[key1], {
 577                         instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
 578                         parentData: data,
 579                         parentDataProperty: key1,
 580                         rootData
 581                     }))) {
 582                     vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
 583                     errors = vErrors.length;
 584                 }
 585             }
 586         }
 587     } else {
 588         const err1 = {
 589             instancePath,
 590             schemaPath: "#/type",
 591             keyword: "type",
 592             params: {
 593                 type: "object"
 594             },
 595             message: "must be object"
 596         };
 597         if (vErrors === null) {
 598             vErrors = [err1];
 599         } else {
 600             vErrors.push(err1);
 601         }
 602         errors++;
 603     }
 604     validate63.errors = vErrors;
 605     return errors === 0;
 606 }
 607
 608 function validate67(data, {
 609     instancePath = "",
 610     parentData,
 611     parentDataProperty,
 612     rootData = data
 613 } = {}) {
 614     let vErrors = null;
 615     let errors = 0;
 616     if (data && typeof data == "object" && !Array.isArray(data)) {
 617         for (const key0 in data) {
 618             if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
 619                 const err0 = {
 620                     instancePath,
 621                     schemaPath: "#/additionalProperties",
 622                     keyword: "additionalProperties",
 623                     params: {
 624                         additionalProperty: key0
 625                     },
 626                     message: "must NOT have additional properties"
 627                 };
 628                 if (vErrors === null) {
 629                     vErrors = [err0];
 630                 } else {
 631                     vErrors.push(err0);
 632                 }
 633                 errors++;
 634             }
 635         }
 636         if (data.alignment !== undefined) {
 637             let data0 = data.alignment;
 638             if (typeof data0 !== "string") {
 639                 const err1 = {
 640                     instancePath: instancePath + "/alignment",
 641                     schemaPath: "#/properties/alignment/type",
 642                     keyword: "type",
 643                     params: {
 644                         type: "string"
 645                     },
 646                     message: "must be string"
 647                 };
 648                 if (vErrors === null) {
 649                     vErrors = [err1];
 650                 } else {
 651                     vErrors.push(err1);
 652                 }
 653                 errors++;
 654             }
 655             if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
 656                 const err2 = {
 657                     instancePath: instancePath + "/alignment",
 658                     schemaPath: "#/properties/alignment/enum",
 659                     keyword: "enum",
 660                     params: {
 661                         allowedValues: schema18.properties.alignment.enum
 662                     },
 663                     message: "must be equal to one of the allowed values"
 664                 };
 665                 if (vErrors === null) {
 666                     vErrors = [err2];
 667                 } else {
 668                     vErrors.push(err2);
 669                 }
 670                 errors++;
 671             }
 672         }
 673         if (data.width !== undefined) {
 674             let data1 = data.width;
 675             if (!((typeof data1 == "number") && (isFinite(data1)))) {
 676                 const err3 = {
 677                     instancePath: instancePath + "/width",
 678                     schemaPath: "#/properties/width/type",
 679                     keyword: "type",
 680                     params: {
 681                         type: "number"
 682                     },
 683                     message: "must be number"
 684                 };
 685                 if (vErrors === null) {
 686                     vErrors = [err3];
 687                 } else {
 688                     vErrors.push(err3);
 689                 }
 690                 errors++;
 691             }
 692         }
 693         if (data.wrapWord !== undefined) {
 694             if (typeof data.wrapWord !== "boolean") {
 695                 const err4 = {
 696                     instancePath: instancePath + "/wrapWord",
 697                     schemaPath: "#/properties/wrapWord/type",
 698                     keyword: "type",
 699                     params: {
 700                         type: "boolean"
 701                     },
 702                     message: "must be boolean"
 703                 };
 704                 if (vErrors === null) {
 705                     vErrors = [err4];
 706                 } else {
 707                     vErrors.push(err4);
 708                 }
 709                 errors++;
 710             }
 711         }
 712         if (data.truncate !== undefined) {
 713             let data3 = data.truncate;
 714             if (!((typeof data3 == "number") && (isFinite(data3)))) {
 715                 const err5 = {
 716                     instancePath: instancePath + "/truncate",
 717                     schemaPath: "#/properties/truncate/type",
 718                     keyword: "type",
 719                     params: {
 720                         type: "number"
 721                     },
 722                     message: "must be number"
 723                 };
 724                 if (vErrors === null) {
 725                     vErrors = [err5];
 726                 } else {
 727                     vErrors.push(err5);
 728                 }
 729                 errors++;
 730             }
 731         }
 732         if (data.paddingLeft !== undefined) {
 733             let data4 = data.paddingLeft;
 734             if (!((typeof data4 == "number") && (isFinite(data4)))) {
 735                 const err6 = {
 736                     instancePath: instancePath + "/paddingLeft",
 737                     schemaPath: "#/properties/paddingLeft/type",
 738                     keyword: "type",
 739                     params: {
 740                         type: "number"
 741                     },
 742                     message: "must be number"
 743                 };
 744                 if (vErrors === null) {
 745                     vErrors = [err6];
 746                 } else {
 747                     vErrors.push(err6);
 748                 }
 749                 errors++;
 750             }
 751         }
 752         if (data.paddingRight !== undefined) {
 753             let data5 = data.paddingRight;
 754             if (!((typeof data5 == "number") && (isFinite(data5)))) {
 755                 const err7 = {
 756                     instancePath: instancePath + "/paddingRight",
 757                     schemaPath: "#/properties/paddingRight/type",
 758                     keyword: "type",
 759                     params: {
 760                         type: "number"
 761                     },
 762                     message: "must be number"
 763                 };
 764                 if (vErrors === null) {
 765                     vErrors = [err7];
 766                 } else {
 767                     vErrors.push(err7);
 768                 }
 769                 errors++;
 770             }
 771         }
 772     } else {
 773         const err8 = {
 774             instancePath,
 775             schemaPath: "#/type",
 776             keyword: "type",
 777             params: {
 778                 type: "object"
 779             },
 780             message: "must be object"
 781         };
 782         if (vErrors === null) {
 783             vErrors = [err8];
 784         } else {
 785             vErrors.push(err8);
 786         }
 787         errors++;
 788     }
 789     validate67.errors = vErrors;
 790     return errors === 0;
 791 }
 792
 793 function validate43(data, {
 794     instancePath = "",
 795     parentData,
 796     parentDataProperty,
 797     rootData = data
 798 } = {}) {
 799     /*# sourceURL="config.json" */ ;
 800     let vErrors = null;
 801     let errors = 0;
 802     if (data && typeof data == "object" && !Array.isArray(data)) {
 803         for (const key0 in data) {
 804             if (!(((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
 805                 const err0 = {
 806                     instancePath,
 807                     schemaPath: "#/additionalProperties",
 808                     keyword: "additionalProperties",
 809                     params: {
 810                         additionalProperty: key0
 811                     },
 812                     message: "must NOT have additional properties"
 813                 };
 814                 if (vErrors === null) {
 815                     vErrors = [err0];
 816                 } else {
 817                     vErrors.push(err0);
 818                 }
 819                 errors++;
 820             }
 821         }
 822         if (data.border !== undefined) {
 823             if (!(validate45(data.border, {
 824                     instancePath: instancePath + "/border",
 825                     parentData: data,
 826                     parentDataProperty: "border",
 827                     rootData
 828                 }))) {
 829                 vErrors = vErrors === null ? validate45.errors : vErrors.concat(validate45.errors);
 830                 errors = vErrors.length;
 831             }
 832         }
 833         if (data.columns !== undefined) {
 834             if (!(validate63(data.columns, {
 835                     instancePath: instancePath + "/columns",
 836                     parentData: data,
 837                     parentDataProperty: "columns",
 838                     rootData
 839                 }))) {
 840                 vErrors = vErrors === null ? validate63.errors : vErrors.concat(validate63.errors);
 841                 errors = vErrors.length;
 842             }
 843         }
 844         if (data.columnDefault !== undefined) {
 845             if (!(validate67(data.columnDefault, {
 846                     instancePath: instancePath + "/columnDefault",
 847                     parentData: data,
 848                     parentDataProperty: "columnDefault",
 849                     rootData
 850                 }))) {
 851                 vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
 852                 errors = vErrors.length;
 853             }
 854         }
 855         if (data.drawHorizontalLine !== undefined) {
 856             if (typeof data.drawHorizontalLine != "function") {
 857                 const err1 = {
 858                     instancePath: instancePath + "/drawHorizontalLine",
 859                     schemaPath: "#/properties/drawHorizontalLine/typeof",
 860                     keyword: "typeof",
 861                     params: {},
 862                     message: "should pass \"typeof\" keyword validation"
 863                 };
 864                 if (vErrors === null) {
 865                     vErrors = [err1];
 866                 } else {
 867                     vErrors.push(err1);
 868                 }
 869                 errors++;
 870             }
 871         }
 872         if (data.singleLine !== undefined) {
 873             if (typeof data.singleLine != "boolean") {
 874                 const err2 = {
 875                     instancePath: instancePath + "/singleLine",
 876                     schemaPath: "#/properties/singleLine/typeof",
 877                     keyword: "typeof",
 878                     params: {},
 879                     message: "should pass \"typeof\" keyword validation"
 880                 };
 881                 if (vErrors === null) {
 882                     vErrors = [err2];
 883                 } else {
 884                     vErrors.push(err2);
 885                 }
 886                 errors++;
 887             }
 888         }
 889     } else {
 890         const err3 = {
 891             instancePath,
 892             schemaPath: "#/type",
 893             keyword: "type",
 894             params: {
 895                 type: "object"
 896             },
 897             message: "must be object"
 898         };
 899         if (vErrors === null) {
 900             vErrors = [err3];
 901         } else {
 902             vErrors.push(err3);
 903         }
 904         errors++;
 905     }
 906     validate43.errors = vErrors;
 907     return errors === 0;
 908 }
 909 exports["streamConfig.json"] = validate69;
 910 const schema20 = {
 911     "$id": "streamConfig.json",
 912     "$schema": "http://json-schema.org/draft-07/schema#",
 913     "type": "object",
 914     "properties": {
 915         "border": {
 916             "$ref": "shared.json#/definitions/borders"
 917         },
 918         "columns": {
 919             "$ref": "shared.json#/definitions/columns"
 920         },
 921         "columnDefault": {
 922             "$ref": "shared.json#/definitions/column"
 923         },
 924         "columnCount": {
 925             "type": "number"
 926         }
 927     },
 928     "additionalProperties": false
 929 };
 930
 931 function validate70(data, {
 932     instancePath = "",
 933     parentData,
 934     parentDataProperty,
 935     rootData = data
 936 } = {}) {
 937     let vErrors = null;
 938     let errors = 0;
 939     if (data && typeof data == "object" && !Array.isArray(data)) {
 940         for (const key0 in data) {
 941             if (!(func8.call(schema15.properties, key0))) {
 942                 const err0 = {
 943                     instancePath,
 944                     schemaPath: "#/additionalProperties",
 945                     keyword: "additionalProperties",
 946                     params: {
 947                         additionalProperty: key0
 948                     },
 949                     message: "must NOT have additional properties"
 950                 };
 951                 if (vErrors === null) {
 952                     vErrors = [err0];
 953                 } else {
 954                     vErrors.push(err0);
 955                 }
 956                 errors++;
 957             }
 958         }
 959         if (data.topBody !== undefined) {
 960             if (!(validate46(data.topBody, {
 961                     instancePath: instancePath + "/topBody",
 962                     parentData: data,
 963                     parentDataProperty: "topBody",
 964                     rootData
 965                 }))) {
 966                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 967                 errors = vErrors.length;
 968             }
 969         }
 970         if (data.topJoin !== undefined) {
 971             if (!(validate46(data.topJoin, {
 972                     instancePath: instancePath + "/topJoin",
 973                     parentData: data,
 974                     parentDataProperty: "topJoin",
 975                     rootData
 976                 }))) {
 977                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 978                 errors = vErrors.length;
 979             }
 980         }
 981         if (data.topLeft !== undefined) {
 982             if (!(validate46(data.topLeft, {
 983                     instancePath: instancePath + "/topLeft",
 984                     parentData: data,
 985                     parentDataProperty: "topLeft",
 986                     rootData
 987                 }))) {
 988                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
 989                 errors = vErrors.length;
 990             }
 991         }
 992         if (data.topRight !== undefined) {
 993             if (!(validate46(data.topRight, {
 994                     instancePath: instancePath + "/topRight",
 995                     parentData: data,
 996                     parentDataProperty: "topRight",
 997                     rootData
 998                 }))) {
 999                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1000                 errors = vErrors.length;
1001             }
1002         }
1003         if (data.bottomBody !== undefined) {
1004             if (!(validate46(data.bottomBody, {
1005                     instancePath: instancePath + "/bottomBody",
1006                     parentData: data,
1007                     parentDataProperty: "bottomBody",
1008                     rootData
1009                 }))) {
1010                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1011                 errors = vErrors.length;
1012             }
1013         }
1014         if (data.bottomJoin !== undefined) {
1015             if (!(validate46(data.bottomJoin, {
1016                     instancePath: instancePath + "/bottomJoin",
1017                     parentData: data,
1018                     parentDataProperty: "bottomJoin",
1019                     rootData
1020                 }))) {
1021                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1022                 errors = vErrors.length;
1023             }
1024         }
1025         if (data.bottomLeft !== undefined) {
1026             if (!(validate46(data.bottomLeft, {
1027                     instancePath: instancePath + "/bottomLeft",
1028                     parentData: data,
1029                     parentDataProperty: "bottomLeft",
1030                     rootData
1031                 }))) {
1032                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1033                 errors = vErrors.length;
1034             }
1035         }
1036         if (data.bottomRight !== undefined) {
1037             if (!(validate46(data.bottomRight, {
1038                     instancePath: instancePath + "/bottomRight",
1039                     parentData: data,
1040                     parentDataProperty: "bottomRight",
1041                     rootData
1042                 }))) {
1043                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1044                 errors = vErrors.length;
1045             }
1046         }
1047         if (data.bodyLeft !== undefined) {
1048             if (!(validate46(data.bodyLeft, {
1049                     instancePath: instancePath + "/bodyLeft",
1050                     parentData: data,
1051                     parentDataProperty: "bodyLeft",
1052                     rootData
1053                 }))) {
1054                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1055                 errors = vErrors.length;
1056             }
1057         }
1058         if (data.bodyRight !== undefined) {
1059             if (!(validate46(data.bodyRight, {
1060                     instancePath: instancePath + "/bodyRight",
1061                     parentData: data,
1062                     parentDataProperty: "bodyRight",
1063                     rootData
1064                 }))) {
1065                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1066                 errors = vErrors.length;
1067             }
1068         }
1069         if (data.bodyJoin !== undefined) {
1070             if (!(validate46(data.bodyJoin, {
1071                     instancePath: instancePath + "/bodyJoin",
1072                     parentData: data,
1073                     parentDataProperty: "bodyJoin",
1074                     rootData
1075                 }))) {
1076                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1077                 errors = vErrors.length;
1078             }
1079         }
1080         if (data.joinBody !== undefined) {
1081             if (!(validate46(data.joinBody, {
1082                     instancePath: instancePath + "/joinBody",
1083                     parentData: data,
1084                     parentDataProperty: "joinBody",
1085                     rootData
1086                 }))) {
1087                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1088                 errors = vErrors.length;
1089             }
1090         }
1091         if (data.joinLeft !== undefined) {
1092             if (!(validate46(data.joinLeft, {
1093                     instancePath: instancePath + "/joinLeft",
1094                     parentData: data,
1095                     parentDataProperty: "joinLeft",
1096                     rootData
1097                 }))) {
1098                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1099                 errors = vErrors.length;
1100             }
1101         }
1102         if (data.joinRight !== undefined) {
1103             if (!(validate46(data.joinRight, {
1104                     instancePath: instancePath + "/joinRight",
1105                     parentData: data,
1106                     parentDataProperty: "joinRight",
1107                     rootData
1108                 }))) {
1109                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1110                 errors = vErrors.length;
1111             }
1112         }
1113         if (data.joinJoin !== undefined) {
1114             if (!(validate46(data.joinJoin, {
1115                     instancePath: instancePath + "/joinJoin",
1116                     parentData: data,
1117                     parentDataProperty: "joinJoin",
1118                     rootData
1119                 }))) {
1120                 vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
1121                 errors = vErrors.length;
1122             }
1123         }
1124     } else {
1125         const err1 = {
1126             instancePath,
1127             schemaPath: "#/type",
1128             keyword: "type",
1129             params: {
1130                 type: "object"
1131             },
1132             message: "must be object"
1133         };
1134         if (vErrors === null) {
1135             vErrors = [err1];
1136         } else {
1137             vErrors.push(err1);
1138         }
1139         errors++;
1140     }
1141     validate70.errors = vErrors;
1142     return errors === 0;
1143 }
1144
1145 function validate87(data, {
1146     instancePath = "",
1147     parentData,
1148     parentDataProperty,
1149     rootData = data
1150 } = {}) {
1151     let vErrors = null;
1152     let errors = 0;
1153     if (data && typeof data == "object" && !Array.isArray(data)) {
1154         for (const key0 in data) {
1155             if (!(pattern0.test(key0))) {
1156                 const err0 = {
1157                     instancePath,
1158                     schemaPath: "#/additionalProperties",
1159                     keyword: "additionalProperties",
1160                     params: {
1161                         additionalProperty: key0
1162                     },
1163                     message: "must NOT have additional properties"
1164                 };
1165                 if (vErrors === null) {
1166                     vErrors = [err0];
1167                 } else {
1168                     vErrors.push(err0);
1169                 }
1170                 errors++;
1171             }
1172         }
1173         for (const key1 in data) {
1174             if (pattern0.test(key1)) {
1175                 if (!(validate64(data[key1], {
1176                         instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
1177                         parentData: data,
1178                         parentDataProperty: key1,
1179                         rootData
1180                     }))) {
1181                     vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
1182                     errors = vErrors.length;
1183                 }
1184             }
1185         }
1186     } else {
1187         const err1 = {
1188             instancePath,
1189             schemaPath: "#/type",
1190             keyword: "type",
1191             params: {
1192                 type: "object"
1193             },
1194             message: "must be object"
1195         };
1196         if (vErrors === null) {
1197             vErrors = [err1];
1198         } else {
1199             vErrors.push(err1);
1200         }
1201         errors++;
1202     }
1203     validate87.errors = vErrors;
1204     return errors === 0;
1205 }
1206
1207 function validate90(data, {
1208     instancePath = "",
1209     parentData,
1210     parentDataProperty,
1211     rootData = data
1212 } = {}) {
1213     let vErrors = null;
1214     let errors = 0;
1215     if (data && typeof data == "object" && !Array.isArray(data)) {
1216         for (const key0 in data) {
1217             if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
1218                 const err0 = {
1219                     instancePath,
1220                     schemaPath: "#/additionalProperties",
1221                     keyword: "additionalProperties",
1222                     params: {
1223                         additionalProperty: key0
1224                     },
1225                     message: "must NOT have additional properties"
1226                 };
1227                 if (vErrors === null) {
1228                     vErrors = [err0];
1229                 } else {
1230                     vErrors.push(err0);
1231                 }
1232                 errors++;
1233             }
1234         }
1235         if (data.alignment !== undefined) {
1236             let data0 = data.alignment;
1237             if (typeof data0 !== "string") {
1238                 const err1 = {
1239                     instancePath: instancePath + "/alignment",
1240                     schemaPath: "#/properties/alignment/type",
1241                     keyword: "type",
1242                     params: {
1243                         type: "string"
1244                     },
1245                     message: "must be string"
1246                 };
1247                 if (vErrors === null) {
1248                     vErrors = [err1];
1249                 } else {
1250                     vErrors.push(err1);
1251                 }
1252                 errors++;
1253             }
1254             if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
1255                 const err2 = {
1256                     instancePath: instancePath + "/alignment",
1257                     schemaPath: "#/properties/alignment/enum",
1258                     keyword: "enum",
1259                     params: {
1260                         allowedValues: schema18.properties.alignment.enum
1261                     },
1262                     message: "must be equal to one of the allowed values"
1263                 };
1264                 if (vErrors === null) {
1265                     vErrors = [err2];
1266                 } else {
1267                     vErrors.push(err2);
1268                 }
1269                 errors++;
1270             }
1271         }
1272         if (data.width !== undefined) {
1273             let data1 = data.width;
1274             if (!((typeof data1 == "number") && (isFinite(data1)))) {
1275                 const err3 = {
1276                     instancePath: instancePath + "/width",
1277                     schemaPath: "#/properties/width/type",
1278                     keyword: "type",
1279                     params: {
1280                         type: "number"
1281                     },
1282                     message: "must be number"
1283                 };
1284                 if (vErrors === null) {
1285                     vErrors = [err3];
1286                 } else {
1287                     vErrors.push(err3);
1288                 }
1289                 errors++;
1290             }
1291         }
1292         if (data.wrapWord !== undefined) {
1293             if (typeof data.wrapWord !== "boolean") {
1294                 const err4 = {
1295                     instancePath: instancePath + "/wrapWord",
1296                     schemaPath: "#/properties/wrapWord/type",
1297                     keyword: "type",
1298                     params: {
1299                         type: "boolean"
1300                     },
1301                     message: "must be boolean"
1302                 };
1303                 if (vErrors === null) {
1304                     vErrors = [err4];
1305                 } else {
1306                     vErrors.push(err4);
1307                 }
1308                 errors++;
1309             }
1310         }
1311         if (data.truncate !== undefined) {
1312             let data3 = data.truncate;
1313             if (!((typeof data3 == "number") && (isFinite(data3)))) {
1314                 const err5 = {
1315                     instancePath: instancePath + "/truncate",
1316                     schemaPath: "#/properties/truncate/type",
1317                     keyword: "type",
1318                     params: {
1319                         type: "number"
1320                     },
1321                     message: "must be number"
1322                 };
1323                 if (vErrors === null) {
1324                     vErrors = [err5];
1325                 } else {
1326                     vErrors.push(err5);
1327                 }
1328                 errors++;
1329             }
1330         }
1331         if (data.paddingLeft !== undefined) {
1332             let data4 = data.paddingLeft;
1333             if (!((typeof data4 == "number") && (isFinite(data4)))) {
1334                 const err6 = {
1335                     instancePath: instancePath + "/paddingLeft",
1336                     schemaPath: "#/properties/paddingLeft/type",
1337                     keyword: "type",
1338                     params: {
1339                         type: "number"
1340                     },
1341                     message: "must be number"
1342                 };
1343                 if (vErrors === null) {
1344                     vErrors = [err6];
1345                 } else {
1346                     vErrors.push(err6);
1347                 }
1348                 errors++;
1349             }
1350         }
1351         if (data.paddingRight !== undefined) {
1352             let data5 = data.paddingRight;
1353             if (!((typeof data5 == "number") && (isFinite(data5)))) {
1354                 const err7 = {
1355                     instancePath: instancePath + "/paddingRight",
1356                     schemaPath: "#/properties/paddingRight/type",
1357                     keyword: "type",
1358                     params: {
1359                         type: "number"
1360                     },
1361                     message: "must be number"
1362                 };
1363                 if (vErrors === null) {
1364                     vErrors = [err7];
1365                 } else {
1366                     vErrors.push(err7);
1367                 }
1368                 errors++;
1369             }
1370         }
1371     } else {
1372         const err8 = {
1373             instancePath,
1374             schemaPath: "#/type",
1375             keyword: "type",
1376             params: {
1377                 type: "object"
1378             },
1379             message: "must be object"
1380         };
1381         if (vErrors === null) {
1382             vErrors = [err8];
1383         } else {
1384             vErrors.push(err8);
1385         }
1386         errors++;
1387     }
1388     validate90.errors = vErrors;
1389     return errors === 0;
1390 }
1391
1392 function validate69(data, {
1393     instancePath = "",
1394     parentData,
1395     parentDataProperty,
1396     rootData = data
1397 } = {}) {
1398     /*# sourceURL="streamConfig.json" */ ;
1399     let vErrors = null;
1400     let errors = 0;
1401     if (data && typeof data == "object" && !Array.isArray(data)) {
1402         for (const key0 in data) {
1403             if (!((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "columnCount"))) {
1404                 const err0 = {
1405                     instancePath,
1406                     schemaPath: "#/additionalProperties",
1407                     keyword: "additionalProperties",
1408                     params: {
1409                         additionalProperty: key0
1410                     },
1411                     message: "must NOT have additional properties"
1412                 };
1413                 if (vErrors === null) {
1414                     vErrors = [err0];
1415                 } else {
1416                     vErrors.push(err0);
1417                 }
1418                 errors++;
1419             }
1420         }
1421         if (data.border !== undefined) {
1422             if (!(validate70(data.border, {
1423                     instancePath: instancePath + "/border",
1424                     parentData: data,
1425                     parentDataProperty: "border",
1426                     rootData
1427                 }))) {
1428                 vErrors = vErrors === null ? validate70.errors : vErrors.concat(validate70.errors);
1429                 errors = vErrors.length;
1430             }
1431         }
1432         if (data.columns !== undefined) {
1433             if (!(validate87(data.columns, {
1434                     instancePath: instancePath + "/columns",
1435                     parentData: data,
1436                     parentDataProperty: "columns",
1437                     rootData
1438                 }))) {
1439                 vErrors = vErrors === null ? validate87.errors : vErrors.concat(validate87.errors);
1440                 errors = vErrors.length;
1441             }
1442         }
1443         if (data.columnDefault !== undefined) {
1444             if (!(validate90(data.columnDefault, {
1445                     instancePath: instancePath + "/columnDefault",
1446                     parentData: data,
1447                     parentDataProperty: "columnDefault",
1448                     rootData
1449                 }))) {
1450                 vErrors = vErrors === null ? validate90.errors : vErrors.concat(validate90.errors);
1451                 errors = vErrors.length;
1452             }
1453         }
1454         if (data.columnCount !== undefined) {
1455             let data3 = data.columnCount;
1456             if (!((typeof data3 == "number") && (isFinite(data3)))) {
1457                 const err1 = {
1458                     instancePath: instancePath + "/columnCount",
1459                     schemaPath: "#/properties/columnCount/type",
1460                     keyword: "type",
1461                     params: {
1462                         type: "number"
1463                     },
1464                     message: "must be number"
1465                 };
1466                 if (vErrors === null) {
1467                     vErrors = [err1];
1468                 } else {
1469                     vErrors.push(err1);
1470                 }
1471                 errors++;
1472             }
1473         }
1474     } else {
1475         const err2 = {
1476             instancePath,
1477             schemaPath: "#/type",
1478             keyword: "type",
1479             params: {
1480                 type: "object"
1481             },
1482             message: "must be object"
1483         };
1484         if (vErrors === null) {
1485             vErrors = [err2];
1486         } else {
1487             vErrors.push(err2);
1488         }
1489         errors++;
1490     }
1491     validate69.errors = vErrors;
1492     return errors === 0;
1493 }