diff --git a/.netlify/functions-serve/graphql/graphql.js b/.netlify/functions-serve/graphql/graphql.js new file mode 100644 index 0000000..e713088 --- /dev/null +++ b/.netlify/functions-serve/graphql/graphql.js @@ -0,0 +1 @@ +module.exports = require('./src/netlify/functions/graphql/graphql.js') \ No newline at end of file diff --git a/.netlify/functions-serve/graphql/package.json b/.netlify/functions-serve/graphql/package.json new file mode 100644 index 0000000..0292b99 --- /dev/null +++ b/.netlify/functions-serve/graphql/package.json @@ -0,0 +1 @@ +{"type":"commonjs"} \ No newline at end of file diff --git a/.netlify/functions-serve/graphql/src/netlify/functions/graphql/graphql.js b/.netlify/functions-serve/graphql/src/netlify/functions/graphql/graphql.js new file mode 100644 index 0000000..6038cf5 --- /dev/null +++ b/.netlify/functions-serve/graphql/src/netlify/functions/graphql/graphql.js @@ -0,0 +1,63883 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); +var __objRest = (source, exclude) => { + var target = {}; + for (var prop in source) + if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0) + target[prop] = source[prop]; + if (source != null && __getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(source)) { + if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop)) + target[prop] = source[prop]; + } + return target; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key of __getOwnPropNames(module2)) + if (!__hasOwnProp.call(target, key) && key !== "default") + __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable }); + } + return target; +}; +var __toModule = (module2) => { + return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2); +}; + +// node_modules/webidl-conversions/lib/index.js +var require_lib = __commonJS({ + "node_modules/webidl-conversions/lib/index.js"(exports2, module2) { + "use strict"; + var conversions = {}; + module2.exports = conversions; + function sign(x) { + return x < 0 ? -1 : 1; + } + function evenRound(x) { + if (x % 1 === 0.5 && (x & 1) === 0) { + return Math.floor(x); + } else { + return Math.round(x); + } + } + function createNumberConversion(bitLength, typeOpts) { + if (!typeOpts.unsigned) { + --bitLength; + } + const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength); + const upperBound = Math.pow(2, bitLength) - 1; + const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength); + const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1); + return function(V, opts) { + if (!opts) + opts = {}; + let x = +V; + if (opts.enforceRange) { + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite number"); + } + x = sign(x) * Math.floor(Math.abs(x)); + if (x < lowerBound || x > upperBound) { + throw new TypeError("Argument is not in byte range"); + } + return x; + } + if (!isNaN(x) && opts.clamp) { + x = evenRound(x); + if (x < lowerBound) + x = lowerBound; + if (x > upperBound) + x = upperBound; + return x; + } + if (!Number.isFinite(x) || x === 0) { + return 0; + } + x = sign(x) * Math.floor(Math.abs(x)); + x = x % moduloVal; + if (!typeOpts.unsigned && x >= moduloBound) { + return x - moduloVal; + } else if (typeOpts.unsigned) { + if (x < 0) { + x += moduloVal; + } else if (x === -0) { + return 0; + } + } + return x; + }; + } + conversions["void"] = function() { + return void 0; + }; + conversions["boolean"] = function(val) { + return !!val; + }; + conversions["byte"] = createNumberConversion(8, { unsigned: false }); + conversions["octet"] = createNumberConversion(8, { unsigned: true }); + conversions["short"] = createNumberConversion(16, { unsigned: false }); + conversions["unsigned short"] = createNumberConversion(16, { unsigned: true }); + conversions["long"] = createNumberConversion(32, { unsigned: false }); + conversions["unsigned long"] = createNumberConversion(32, { unsigned: true }); + conversions["long long"] = createNumberConversion(32, { unsigned: false, moduloBitLength: 64 }); + conversions["unsigned long long"] = createNumberConversion(32, { unsigned: true, moduloBitLength: 64 }); + conversions["double"] = function(V) { + const x = +V; + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite floating-point value"); + } + return x; + }; + conversions["unrestricted double"] = function(V) { + const x = +V; + if (isNaN(x)) { + throw new TypeError("Argument is NaN"); + } + return x; + }; + conversions["float"] = conversions["double"]; + conversions["unrestricted float"] = conversions["unrestricted double"]; + conversions["DOMString"] = function(V, opts) { + if (!opts) + opts = {}; + if (opts.treatNullAsEmptyString && V === null) { + return ""; + } + return String(V); + }; + conversions["ByteString"] = function(V, opts) { + const x = String(V); + let c = void 0; + for (let i = 0; (c = x.codePointAt(i)) !== void 0; ++i) { + if (c > 255) { + throw new TypeError("Argument is not a valid bytestring"); + } + } + return x; + }; + conversions["USVString"] = function(V) { + const S = String(V); + const n = S.length; + const U = []; + for (let i = 0; i < n; ++i) { + const c = S.charCodeAt(i); + if (c < 55296 || c > 57343) { + U.push(String.fromCodePoint(c)); + } else if (56320 <= c && c <= 57343) { + U.push(String.fromCodePoint(65533)); + } else { + if (i === n - 1) { + U.push(String.fromCodePoint(65533)); + } else { + const d = S.charCodeAt(i + 1); + if (56320 <= d && d <= 57343) { + const a = c & 1023; + const b = d & 1023; + U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b)); + ++i; + } else { + U.push(String.fromCodePoint(65533)); + } + } + } + } + return U.join(""); + }; + conversions["Date"] = function(V, opts) { + if (!(V instanceof Date)) { + throw new TypeError("Argument is not a Date object"); + } + if (isNaN(V)) { + return void 0; + } + return V; + }; + conversions["RegExp"] = function(V, opts) { + if (!(V instanceof RegExp)) { + V = new RegExp(V); + } + return V; + }; + } +}); + +// node_modules/whatwg-url/lib/utils.js +var require_utils = __commonJS({ + "node_modules/whatwg-url/lib/utils.js"(exports2, module2) { + "use strict"; + module2.exports.mixin = function mixin(target, source) { + const keys = Object.getOwnPropertyNames(source); + for (let i = 0; i < keys.length; ++i) { + Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i])); + } + }; + module2.exports.wrapperSymbol = Symbol("wrapper"); + module2.exports.implSymbol = Symbol("impl"); + module2.exports.wrapperForImpl = function(impl) { + return impl[module2.exports.wrapperSymbol]; + }; + module2.exports.implForWrapper = function(wrapper) { + return wrapper[module2.exports.implSymbol]; + }; + } +}); + +// node_modules/tr46/lib/mappingTable.json +var require_mappingTable = __commonJS({ + "node_modules/tr46/lib/mappingTable.json"(exports2, module2) { + module2.exports = [[[0, 44], "disallowed_STD3_valid"], [[45, 46], "valid"], [[47, 47], "disallowed_STD3_valid"], [[48, 57], "valid"], [[58, 64], "disallowed_STD3_valid"], [[65, 65], "mapped", [97]], [[66, 66], "mapped", [98]], [[67, 67], "mapped", [99]], [[68, 68], "mapped", [100]], [[69, 69], "mapped", [101]], [[70, 70], "mapped", [102]], [[71, 71], "mapped", [103]], [[72, 72], "mapped", [104]], [[73, 73], "mapped", [105]], [[74, 74], "mapped", [106]], [[75, 75], "mapped", [107]], [[76, 76], "mapped", [108]], [[77, 77], "mapped", [109]], [[78, 78], "mapped", [110]], [[79, 79], "mapped", [111]], [[80, 80], "mapped", [112]], [[81, 81], "mapped", [113]], [[82, 82], "mapped", [114]], [[83, 83], "mapped", [115]], [[84, 84], "mapped", [116]], [[85, 85], "mapped", [117]], [[86, 86], "mapped", [118]], [[87, 87], "mapped", [119]], [[88, 88], "mapped", [120]], [[89, 89], "mapped", [121]], [[90, 90], "mapped", [122]], [[91, 96], "disallowed_STD3_valid"], [[97, 122], "valid"], [[123, 127], "disallowed_STD3_valid"], [[128, 159], "disallowed"], [[160, 160], "disallowed_STD3_mapped", [32]], [[161, 167], "valid", [], "NV8"], [[168, 168], "disallowed_STD3_mapped", [32, 776]], [[169, 169], "valid", [], "NV8"], [[170, 170], "mapped", [97]], [[171, 172], "valid", [], "NV8"], [[173, 173], "ignored"], [[174, 174], "valid", [], "NV8"], [[175, 175], "disallowed_STD3_mapped", [32, 772]], [[176, 177], "valid", [], "NV8"], [[178, 178], "mapped", [50]], [[179, 179], "mapped", [51]], [[180, 180], "disallowed_STD3_mapped", [32, 769]], [[181, 181], "mapped", [956]], [[182, 182], "valid", [], "NV8"], [[183, 183], "valid"], [[184, 184], "disallowed_STD3_mapped", [32, 807]], [[185, 185], "mapped", [49]], [[186, 186], "mapped", [111]], [[187, 187], "valid", [], "NV8"], [[188, 188], "mapped", [49, 8260, 52]], [[189, 189], "mapped", [49, 8260, 50]], [[190, 190], "mapped", [51, 8260, 52]], [[191, 191], "valid", [], "NV8"], [[192, 192], "mapped", [224]], [[193, 193], "mapped", [225]], [[194, 194], "mapped", [226]], [[195, 195], "mapped", [227]], [[196, 196], "mapped", [228]], [[197, 197], "mapped", [229]], [[198, 198], "mapped", [230]], [[199, 199], "mapped", [231]], [[200, 200], "mapped", [232]], [[201, 201], "mapped", [233]], [[202, 202], "mapped", [234]], [[203, 203], "mapped", [235]], [[204, 204], "mapped", [236]], [[205, 205], "mapped", [237]], [[206, 206], "mapped", [238]], [[207, 207], "mapped", [239]], [[208, 208], "mapped", [240]], [[209, 209], "mapped", [241]], [[210, 210], "mapped", [242]], [[211, 211], "mapped", [243]], [[212, 212], "mapped", [244]], [[213, 213], "mapped", [245]], [[214, 214], "mapped", [246]], [[215, 215], "valid", [], "NV8"], [[216, 216], "mapped", [248]], [[217, 217], "mapped", [249]], [[218, 218], "mapped", [250]], [[219, 219], "mapped", [251]], [[220, 220], "mapped", [252]], [[221, 221], "mapped", [253]], [[222, 222], "mapped", [254]], [[223, 223], "deviation", [115, 115]], [[224, 246], "valid"], [[247, 247], "valid", [], "NV8"], [[248, 255], "valid"], [[256, 256], "mapped", [257]], [[257, 257], "valid"], [[258, 258], "mapped", [259]], [[259, 259], "valid"], [[260, 260], "mapped", [261]], [[261, 261], "valid"], [[262, 262], "mapped", [263]], [[263, 263], "valid"], [[264, 264], "mapped", [265]], [[265, 265], "valid"], [[266, 266], "mapped", [267]], [[267, 267], "valid"], [[268, 268], "mapped", [269]], [[269, 269], "valid"], [[270, 270], "mapped", [271]], [[271, 271], "valid"], [[272, 272], "mapped", [273]], [[273, 273], "valid"], [[274, 274], "mapped", [275]], [[275, 275], "valid"], [[276, 276], "mapped", [277]], [[277, 277], "valid"], [[278, 278], "mapped", [279]], [[279, 279], "valid"], [[280, 280], "mapped", [281]], [[281, 281], "valid"], [[282, 282], "mapped", [283]], [[283, 283], "valid"], [[284, 284], "mapped", [285]], [[285, 285], "valid"], [[286, 286], "mapped", [287]], [[287, 287], "valid"], [[288, 288], "mapped", [289]], [[289, 289], "valid"], [[290, 290], "mapped", [291]], [[291, 291], "valid"], [[292, 292], "mapped", [293]], [[293, 293], "valid"], [[294, 294], "mapped", [295]], [[295, 295], "valid"], [[296, 296], "mapped", [297]], [[297, 297], "valid"], [[298, 298], "mapped", [299]], [[299, 299], "valid"], [[300, 300], "mapped", [301]], [[301, 301], "valid"], [[302, 302], "mapped", [303]], [[303, 303], "valid"], [[304, 304], "mapped", [105, 775]], [[305, 305], "valid"], [[306, 307], "mapped", [105, 106]], [[308, 308], "mapped", [309]], [[309, 309], "valid"], [[310, 310], "mapped", [311]], [[311, 312], "valid"], [[313, 313], "mapped", [314]], [[314, 314], "valid"], [[315, 315], "mapped", [316]], [[316, 316], "valid"], [[317, 317], "mapped", [318]], [[318, 318], "valid"], [[319, 320], "mapped", [108, 183]], [[321, 321], "mapped", [322]], [[322, 322], "valid"], [[323, 323], "mapped", [324]], [[324, 324], "valid"], [[325, 325], "mapped", [326]], [[326, 326], "valid"], [[327, 327], "mapped", [328]], [[328, 328], "valid"], [[329, 329], "mapped", [700, 110]], [[330, 330], "mapped", [331]], [[331, 331], "valid"], [[332, 332], "mapped", [333]], [[333, 333], "valid"], [[334, 334], "mapped", [335]], [[335, 335], "valid"], [[336, 336], "mapped", [337]], [[337, 337], "valid"], [[338, 338], "mapped", [339]], [[339, 339], "valid"], [[340, 340], "mapped", [341]], [[341, 341], "valid"], [[342, 342], "mapped", [343]], [[343, 343], "valid"], [[344, 344], "mapped", [345]], [[345, 345], "valid"], [[346, 346], "mapped", [347]], [[347, 347], "valid"], [[348, 348], "mapped", [349]], [[349, 349], "valid"], [[350, 350], "mapped", [351]], [[351, 351], "valid"], [[352, 352], "mapped", [353]], [[353, 353], "valid"], [[354, 354], "mapped", [355]], [[355, 355], "valid"], [[356, 356], "mapped", [357]], [[357, 357], "valid"], [[358, 358], "mapped", [359]], [[359, 359], "valid"], [[360, 360], "mapped", [361]], [[361, 361], "valid"], [[362, 362], "mapped", [363]], [[363, 363], "valid"], [[364, 364], "mapped", [365]], [[365, 365], "valid"], [[366, 366], "mapped", [367]], [[367, 367], "valid"], [[368, 368], "mapped", [369]], [[369, 369], "valid"], [[370, 370], "mapped", [371]], [[371, 371], "valid"], [[372, 372], "mapped", [373]], [[373, 373], "valid"], [[374, 374], "mapped", [375]], [[375, 375], "valid"], [[376, 376], "mapped", [255]], [[377, 377], "mapped", [378]], [[378, 378], "valid"], [[379, 379], "mapped", [380]], [[380, 380], "valid"], [[381, 381], "mapped", [382]], [[382, 382], "valid"], [[383, 383], "mapped", [115]], [[384, 384], "valid"], [[385, 385], "mapped", [595]], [[386, 386], "mapped", [387]], [[387, 387], "valid"], [[388, 388], "mapped", [389]], [[389, 389], "valid"], [[390, 390], "mapped", [596]], [[391, 391], "mapped", [392]], [[392, 392], "valid"], [[393, 393], "mapped", [598]], [[394, 394], "mapped", [599]], [[395, 395], "mapped", [396]], [[396, 397], "valid"], [[398, 398], "mapped", [477]], [[399, 399], "mapped", [601]], [[400, 400], "mapped", [603]], [[401, 401], "mapped", [402]], [[402, 402], "valid"], [[403, 403], "mapped", [608]], [[404, 404], "mapped", [611]], [[405, 405], "valid"], [[406, 406], "mapped", [617]], [[407, 407], "mapped", [616]], [[408, 408], "mapped", [409]], [[409, 411], "valid"], [[412, 412], "mapped", [623]], [[413, 413], "mapped", [626]], [[414, 414], "valid"], [[415, 415], "mapped", [629]], [[416, 416], "mapped", [417]], [[417, 417], "valid"], [[418, 418], "mapped", [419]], [[419, 419], "valid"], [[420, 420], "mapped", [421]], [[421, 421], "valid"], [[422, 422], "mapped", [640]], [[423, 423], "mapped", [424]], [[424, 424], "valid"], [[425, 425], "mapped", [643]], [[426, 427], "valid"], [[428, 428], "mapped", [429]], [[429, 429], "valid"], [[430, 430], "mapped", [648]], [[431, 431], "mapped", [432]], [[432, 432], "valid"], [[433, 433], "mapped", [650]], [[434, 434], "mapped", [651]], [[435, 435], "mapped", [436]], [[436, 436], "valid"], [[437, 437], "mapped", [438]], [[438, 438], "valid"], [[439, 439], "mapped", [658]], [[440, 440], "mapped", [441]], [[441, 443], "valid"], [[444, 444], "mapped", [445]], [[445, 451], "valid"], [[452, 454], "mapped", [100, 382]], [[455, 457], "mapped", [108, 106]], [[458, 460], "mapped", [110, 106]], [[461, 461], "mapped", [462]], [[462, 462], "valid"], [[463, 463], "mapped", [464]], [[464, 464], "valid"], [[465, 465], "mapped", [466]], [[466, 466], "valid"], [[467, 467], "mapped", [468]], [[468, 468], "valid"], [[469, 469], "mapped", [470]], [[470, 470], "valid"], [[471, 471], "mapped", [472]], [[472, 472], "valid"], [[473, 473], "mapped", [474]], [[474, 474], "valid"], [[475, 475], "mapped", [476]], [[476, 477], "valid"], [[478, 478], "mapped", [479]], [[479, 479], "valid"], [[480, 480], "mapped", [481]], [[481, 481], "valid"], [[482, 482], "mapped", [483]], [[483, 483], "valid"], [[484, 484], "mapped", [485]], [[485, 485], "valid"], [[486, 486], "mapped", [487]], [[487, 487], "valid"], [[488, 488], "mapped", [489]], [[489, 489], "valid"], [[490, 490], "mapped", [491]], [[491, 491], "valid"], [[492, 492], "mapped", [493]], [[493, 493], "valid"], [[494, 494], "mapped", [495]], [[495, 496], "valid"], [[497, 499], "mapped", [100, 122]], [[500, 500], "mapped", [501]], [[501, 501], "valid"], [[502, 502], "mapped", [405]], [[503, 503], "mapped", [447]], [[504, 504], "mapped", [505]], [[505, 505], "valid"], [[506, 506], "mapped", [507]], [[507, 507], "valid"], [[508, 508], "mapped", [509]], [[509, 509], "valid"], [[510, 510], "mapped", [511]], [[511, 511], "valid"], [[512, 512], "mapped", [513]], [[513, 513], "valid"], [[514, 514], "mapped", [515]], [[515, 515], "valid"], [[516, 516], "mapped", [517]], [[517, 517], "valid"], [[518, 518], "mapped", [519]], [[519, 519], "valid"], [[520, 520], "mapped", [521]], [[521, 521], "valid"], [[522, 522], "mapped", [523]], [[523, 523], "valid"], [[524, 524], "mapped", [525]], [[525, 525], "valid"], [[526, 526], "mapped", [527]], [[527, 527], "valid"], [[528, 528], "mapped", [529]], [[529, 529], "valid"], [[530, 530], "mapped", [531]], [[531, 531], "valid"], [[532, 532], "mapped", [533]], [[533, 533], "valid"], [[534, 534], "mapped", [535]], [[535, 535], "valid"], [[536, 536], "mapped", [537]], [[537, 537], "valid"], [[538, 538], "mapped", [539]], [[539, 539], "valid"], [[540, 540], "mapped", [541]], [[541, 541], "valid"], [[542, 542], "mapped", [543]], [[543, 543], "valid"], [[544, 544], "mapped", [414]], [[545, 545], "valid"], [[546, 546], "mapped", [547]], [[547, 547], "valid"], [[548, 548], "mapped", [549]], [[549, 549], "valid"], [[550, 550], "mapped", [551]], [[551, 551], "valid"], [[552, 552], "mapped", [553]], [[553, 553], "valid"], [[554, 554], "mapped", [555]], [[555, 555], "valid"], [[556, 556], "mapped", [557]], [[557, 557], "valid"], [[558, 558], "mapped", [559]], [[559, 559], "valid"], [[560, 560], "mapped", [561]], [[561, 561], "valid"], [[562, 562], "mapped", [563]], [[563, 563], "valid"], [[564, 566], "valid"], [[567, 569], "valid"], [[570, 570], "mapped", [11365]], [[571, 571], "mapped", [572]], [[572, 572], "valid"], [[573, 573], "mapped", [410]], [[574, 574], "mapped", [11366]], [[575, 576], "valid"], [[577, 577], "mapped", [578]], [[578, 578], "valid"], [[579, 579], "mapped", [384]], [[580, 580], "mapped", [649]], [[581, 581], "mapped", [652]], [[582, 582], "mapped", [583]], [[583, 583], "valid"], [[584, 584], "mapped", [585]], [[585, 585], "valid"], [[586, 586], "mapped", [587]], [[587, 587], "valid"], [[588, 588], "mapped", [589]], [[589, 589], "valid"], [[590, 590], "mapped", [591]], [[591, 591], "valid"], [[592, 680], "valid"], [[681, 685], "valid"], [[686, 687], "valid"], [[688, 688], "mapped", [104]], [[689, 689], "mapped", [614]], [[690, 690], "mapped", [106]], [[691, 691], "mapped", [114]], [[692, 692], "mapped", [633]], [[693, 693], "mapped", [635]], [[694, 694], "mapped", [641]], [[695, 695], "mapped", [119]], [[696, 696], "mapped", [121]], [[697, 705], "valid"], [[706, 709], "valid", [], "NV8"], [[710, 721], "valid"], [[722, 727], "valid", [], "NV8"], [[728, 728], "disallowed_STD3_mapped", [32, 774]], [[729, 729], "disallowed_STD3_mapped", [32, 775]], [[730, 730], "disallowed_STD3_mapped", [32, 778]], [[731, 731], "disallowed_STD3_mapped", [32, 808]], [[732, 732], "disallowed_STD3_mapped", [32, 771]], [[733, 733], "disallowed_STD3_mapped", [32, 779]], [[734, 734], "valid", [], "NV8"], [[735, 735], "valid", [], "NV8"], [[736, 736], "mapped", [611]], [[737, 737], "mapped", [108]], [[738, 738], "mapped", [115]], [[739, 739], "mapped", [120]], [[740, 740], "mapped", [661]], [[741, 745], "valid", [], "NV8"], [[746, 747], "valid", [], "NV8"], [[748, 748], "valid"], [[749, 749], "valid", [], "NV8"], [[750, 750], "valid"], [[751, 767], "valid", [], "NV8"], [[768, 831], "valid"], [[832, 832], "mapped", [768]], [[833, 833], "mapped", [769]], [[834, 834], "valid"], [[835, 835], "mapped", [787]], [[836, 836], "mapped", [776, 769]], [[837, 837], "mapped", [953]], [[838, 846], "valid"], [[847, 847], "ignored"], [[848, 855], "valid"], [[856, 860], "valid"], [[861, 863], "valid"], [[864, 865], "valid"], [[866, 866], "valid"], [[867, 879], "valid"], [[880, 880], "mapped", [881]], [[881, 881], "valid"], [[882, 882], "mapped", [883]], [[883, 883], "valid"], [[884, 884], "mapped", [697]], [[885, 885], "valid"], [[886, 886], "mapped", [887]], [[887, 887], "valid"], [[888, 889], "disallowed"], [[890, 890], "disallowed_STD3_mapped", [32, 953]], [[891, 893], "valid"], [[894, 894], "disallowed_STD3_mapped", [59]], [[895, 895], "mapped", [1011]], [[896, 899], "disallowed"], [[900, 900], "disallowed_STD3_mapped", [32, 769]], [[901, 901], "disallowed_STD3_mapped", [32, 776, 769]], [[902, 902], "mapped", [940]], [[903, 903], "mapped", [183]], [[904, 904], "mapped", [941]], [[905, 905], "mapped", [942]], [[906, 906], "mapped", [943]], [[907, 907], "disallowed"], [[908, 908], "mapped", [972]], [[909, 909], "disallowed"], [[910, 910], "mapped", [973]], [[911, 911], "mapped", [974]], [[912, 912], "valid"], [[913, 913], "mapped", [945]], [[914, 914], "mapped", [946]], [[915, 915], "mapped", [947]], [[916, 916], "mapped", [948]], [[917, 917], "mapped", [949]], [[918, 918], "mapped", [950]], [[919, 919], "mapped", [951]], [[920, 920], "mapped", [952]], [[921, 921], "mapped", [953]], [[922, 922], "mapped", [954]], [[923, 923], "mapped", [955]], [[924, 924], "mapped", [956]], [[925, 925], "mapped", [957]], [[926, 926], "mapped", [958]], [[927, 927], "mapped", [959]], [[928, 928], "mapped", [960]], [[929, 929], "mapped", [961]], [[930, 930], "disallowed"], [[931, 931], "mapped", [963]], [[932, 932], "mapped", [964]], [[933, 933], "mapped", [965]], [[934, 934], "mapped", [966]], [[935, 935], "mapped", [967]], [[936, 936], "mapped", [968]], [[937, 937], "mapped", [969]], [[938, 938], "mapped", [970]], [[939, 939], "mapped", [971]], [[940, 961], "valid"], [[962, 962], "deviation", [963]], [[963, 974], "valid"], [[975, 975], "mapped", [983]], [[976, 976], "mapped", [946]], [[977, 977], "mapped", [952]], [[978, 978], "mapped", [965]], [[979, 979], "mapped", [973]], [[980, 980], "mapped", [971]], [[981, 981], "mapped", [966]], [[982, 982], "mapped", [960]], [[983, 983], "valid"], [[984, 984], "mapped", [985]], [[985, 985], "valid"], [[986, 986], "mapped", [987]], [[987, 987], "valid"], [[988, 988], "mapped", [989]], [[989, 989], "valid"], [[990, 990], "mapped", [991]], [[991, 991], "valid"], [[992, 992], "mapped", [993]], [[993, 993], "valid"], [[994, 994], "mapped", [995]], [[995, 995], "valid"], [[996, 996], "mapped", [997]], [[997, 997], "valid"], [[998, 998], "mapped", [999]], [[999, 999], "valid"], [[1e3, 1e3], "mapped", [1001]], [[1001, 1001], "valid"], [[1002, 1002], "mapped", [1003]], [[1003, 1003], "valid"], [[1004, 1004], "mapped", [1005]], [[1005, 1005], "valid"], [[1006, 1006], "mapped", [1007]], [[1007, 1007], "valid"], [[1008, 1008], "mapped", [954]], [[1009, 1009], "mapped", [961]], [[1010, 1010], "mapped", [963]], [[1011, 1011], "valid"], [[1012, 1012], "mapped", [952]], [[1013, 1013], "mapped", [949]], [[1014, 1014], "valid", [], "NV8"], [[1015, 1015], "mapped", [1016]], [[1016, 1016], "valid"], [[1017, 1017], "mapped", [963]], [[1018, 1018], "mapped", [1019]], [[1019, 1019], "valid"], [[1020, 1020], "valid"], [[1021, 1021], "mapped", [891]], [[1022, 1022], "mapped", [892]], [[1023, 1023], "mapped", [893]], [[1024, 1024], "mapped", [1104]], [[1025, 1025], "mapped", [1105]], [[1026, 1026], "mapped", [1106]], [[1027, 1027], "mapped", [1107]], [[1028, 1028], "mapped", [1108]], [[1029, 1029], "mapped", [1109]], [[1030, 1030], "mapped", [1110]], [[1031, 1031], "mapped", [1111]], [[1032, 1032], "mapped", [1112]], [[1033, 1033], "mapped", [1113]], [[1034, 1034], "mapped", [1114]], [[1035, 1035], "mapped", [1115]], [[1036, 1036], "mapped", [1116]], [[1037, 1037], "mapped", [1117]], [[1038, 1038], "mapped", [1118]], [[1039, 1039], "mapped", [1119]], [[1040, 1040], "mapped", [1072]], [[1041, 1041], "mapped", [1073]], [[1042, 1042], "mapped", [1074]], [[1043, 1043], "mapped", [1075]], [[1044, 1044], "mapped", [1076]], [[1045, 1045], "mapped", [1077]], [[1046, 1046], "mapped", [1078]], [[1047, 1047], "mapped", [1079]], [[1048, 1048], "mapped", [1080]], [[1049, 1049], "mapped", [1081]], [[1050, 1050], "mapped", [1082]], [[1051, 1051], "mapped", [1083]], [[1052, 1052], "mapped", [1084]], [[1053, 1053], "mapped", [1085]], [[1054, 1054], "mapped", [1086]], [[1055, 1055], "mapped", [1087]], [[1056, 1056], "mapped", [1088]], [[1057, 1057], "mapped", [1089]], [[1058, 1058], "mapped", [1090]], [[1059, 1059], "mapped", [1091]], [[1060, 1060], "mapped", [1092]], [[1061, 1061], "mapped", [1093]], [[1062, 1062], "mapped", [1094]], [[1063, 1063], "mapped", [1095]], [[1064, 1064], "mapped", [1096]], [[1065, 1065], "mapped", [1097]], [[1066, 1066], "mapped", [1098]], [[1067, 1067], "mapped", [1099]], [[1068, 1068], "mapped", [1100]], [[1069, 1069], "mapped", [1101]], [[1070, 1070], "mapped", [1102]], [[1071, 1071], "mapped", [1103]], [[1072, 1103], "valid"], [[1104, 1104], "valid"], [[1105, 1116], "valid"], [[1117, 1117], "valid"], [[1118, 1119], "valid"], [[1120, 1120], "mapped", [1121]], [[1121, 1121], "valid"], [[1122, 1122], "mapped", [1123]], [[1123, 1123], "valid"], [[1124, 1124], "mapped", [1125]], [[1125, 1125], "valid"], [[1126, 1126], "mapped", [1127]], [[1127, 1127], "valid"], [[1128, 1128], "mapped", [1129]], [[1129, 1129], "valid"], [[1130, 1130], "mapped", [1131]], [[1131, 1131], "valid"], [[1132, 1132], "mapped", [1133]], [[1133, 1133], "valid"], [[1134, 1134], "mapped", [1135]], [[1135, 1135], "valid"], [[1136, 1136], "mapped", [1137]], [[1137, 1137], "valid"], [[1138, 1138], "mapped", [1139]], [[1139, 1139], "valid"], [[1140, 1140], "mapped", [1141]], [[1141, 1141], "valid"], [[1142, 1142], "mapped", [1143]], [[1143, 1143], "valid"], [[1144, 1144], "mapped", [1145]], [[1145, 1145], "valid"], [[1146, 1146], "mapped", [1147]], [[1147, 1147], "valid"], [[1148, 1148], "mapped", [1149]], [[1149, 1149], "valid"], [[1150, 1150], "mapped", [1151]], [[1151, 1151], "valid"], [[1152, 1152], "mapped", [1153]], [[1153, 1153], "valid"], [[1154, 1154], "valid", [], "NV8"], [[1155, 1158], "valid"], [[1159, 1159], "valid"], [[1160, 1161], "valid", [], "NV8"], [[1162, 1162], "mapped", [1163]], [[1163, 1163], "valid"], [[1164, 1164], "mapped", [1165]], [[1165, 1165], "valid"], [[1166, 1166], "mapped", [1167]], [[1167, 1167], "valid"], [[1168, 1168], "mapped", [1169]], [[1169, 1169], "valid"], [[1170, 1170], "mapped", [1171]], [[1171, 1171], "valid"], [[1172, 1172], "mapped", [1173]], [[1173, 1173], "valid"], [[1174, 1174], "mapped", [1175]], [[1175, 1175], "valid"], [[1176, 1176], "mapped", [1177]], [[1177, 1177], "valid"], [[1178, 1178], "mapped", [1179]], [[1179, 1179], "valid"], [[1180, 1180], "mapped", [1181]], [[1181, 1181], "valid"], [[1182, 1182], "mapped", [1183]], [[1183, 1183], "valid"], [[1184, 1184], "mapped", [1185]], [[1185, 1185], "valid"], [[1186, 1186], "mapped", [1187]], [[1187, 1187], "valid"], [[1188, 1188], "mapped", [1189]], [[1189, 1189], "valid"], [[1190, 1190], "mapped", [1191]], [[1191, 1191], "valid"], [[1192, 1192], "mapped", [1193]], [[1193, 1193], "valid"], [[1194, 1194], "mapped", [1195]], [[1195, 1195], "valid"], [[1196, 1196], "mapped", [1197]], [[1197, 1197], "valid"], [[1198, 1198], "mapped", [1199]], [[1199, 1199], "valid"], [[1200, 1200], "mapped", [1201]], [[1201, 1201], "valid"], [[1202, 1202], "mapped", [1203]], [[1203, 1203], "valid"], [[1204, 1204], "mapped", [1205]], [[1205, 1205], "valid"], [[1206, 1206], "mapped", [1207]], [[1207, 1207], "valid"], [[1208, 1208], "mapped", [1209]], [[1209, 1209], "valid"], [[1210, 1210], "mapped", [1211]], [[1211, 1211], "valid"], [[1212, 1212], "mapped", [1213]], [[1213, 1213], "valid"], [[1214, 1214], "mapped", [1215]], [[1215, 1215], "valid"], [[1216, 1216], "disallowed"], [[1217, 1217], "mapped", [1218]], [[1218, 1218], "valid"], [[1219, 1219], "mapped", [1220]], [[1220, 1220], "valid"], [[1221, 1221], "mapped", [1222]], [[1222, 1222], "valid"], [[1223, 1223], "mapped", [1224]], [[1224, 1224], "valid"], [[1225, 1225], "mapped", [1226]], [[1226, 1226], "valid"], [[1227, 1227], "mapped", [1228]], [[1228, 1228], "valid"], [[1229, 1229], "mapped", [1230]], [[1230, 1230], "valid"], [[1231, 1231], "valid"], [[1232, 1232], "mapped", [1233]], [[1233, 1233], "valid"], [[1234, 1234], "mapped", [1235]], [[1235, 1235], "valid"], [[1236, 1236], "mapped", [1237]], [[1237, 1237], "valid"], [[1238, 1238], "mapped", [1239]], [[1239, 1239], "valid"], [[1240, 1240], "mapped", [1241]], [[1241, 1241], "valid"], [[1242, 1242], "mapped", [1243]], [[1243, 1243], "valid"], [[1244, 1244], "mapped", [1245]], [[1245, 1245], "valid"], [[1246, 1246], "mapped", [1247]], [[1247, 1247], "valid"], [[1248, 1248], "mapped", [1249]], [[1249, 1249], "valid"], [[1250, 1250], "mapped", [1251]], [[1251, 1251], "valid"], [[1252, 1252], "mapped", [1253]], [[1253, 1253], "valid"], [[1254, 1254], "mapped", [1255]], [[1255, 1255], "valid"], [[1256, 1256], "mapped", [1257]], [[1257, 1257], "valid"], [[1258, 1258], "mapped", [1259]], [[1259, 1259], "valid"], [[1260, 1260], "mapped", [1261]], [[1261, 1261], "valid"], [[1262, 1262], "mapped", [1263]], [[1263, 1263], "valid"], [[1264, 1264], "mapped", [1265]], [[1265, 1265], "valid"], [[1266, 1266], "mapped", [1267]], [[1267, 1267], "valid"], [[1268, 1268], "mapped", [1269]], [[1269, 1269], "valid"], [[1270, 1270], "mapped", [1271]], [[1271, 1271], "valid"], [[1272, 1272], "mapped", [1273]], [[1273, 1273], "valid"], [[1274, 1274], "mapped", [1275]], [[1275, 1275], "valid"], [[1276, 1276], "mapped", [1277]], [[1277, 1277], "valid"], [[1278, 1278], "mapped", [1279]], [[1279, 1279], "valid"], [[1280, 1280], "mapped", [1281]], [[1281, 1281], "valid"], [[1282, 1282], "mapped", [1283]], [[1283, 1283], "valid"], [[1284, 1284], "mapped", [1285]], [[1285, 1285], "valid"], [[1286, 1286], "mapped", [1287]], [[1287, 1287], "valid"], [[1288, 1288], "mapped", [1289]], [[1289, 1289], "valid"], [[1290, 1290], "mapped", [1291]], [[1291, 1291], "valid"], [[1292, 1292], "mapped", [1293]], [[1293, 1293], "valid"], [[1294, 1294], "mapped", [1295]], [[1295, 1295], "valid"], [[1296, 1296], "mapped", [1297]], [[1297, 1297], "valid"], [[1298, 1298], "mapped", [1299]], [[1299, 1299], "valid"], [[1300, 1300], "mapped", [1301]], [[1301, 1301], "valid"], [[1302, 1302], "mapped", [1303]], [[1303, 1303], "valid"], [[1304, 1304], "mapped", [1305]], [[1305, 1305], "valid"], [[1306, 1306], "mapped", [1307]], [[1307, 1307], "valid"], [[1308, 1308], "mapped", [1309]], [[1309, 1309], "valid"], [[1310, 1310], "mapped", [1311]], [[1311, 1311], "valid"], [[1312, 1312], "mapped", [1313]], [[1313, 1313], "valid"], [[1314, 1314], "mapped", [1315]], [[1315, 1315], "valid"], [[1316, 1316], "mapped", [1317]], [[1317, 1317], "valid"], [[1318, 1318], "mapped", [1319]], [[1319, 1319], "valid"], [[1320, 1320], "mapped", [1321]], [[1321, 1321], "valid"], [[1322, 1322], "mapped", [1323]], [[1323, 1323], "valid"], [[1324, 1324], "mapped", [1325]], [[1325, 1325], "valid"], [[1326, 1326], "mapped", [1327]], [[1327, 1327], "valid"], [[1328, 1328], "disallowed"], [[1329, 1329], "mapped", [1377]], [[1330, 1330], "mapped", [1378]], [[1331, 1331], "mapped", [1379]], [[1332, 1332], "mapped", [1380]], [[1333, 1333], "mapped", [1381]], [[1334, 1334], "mapped", [1382]], [[1335, 1335], "mapped", [1383]], [[1336, 1336], "mapped", [1384]], [[1337, 1337], "mapped", [1385]], [[1338, 1338], "mapped", [1386]], [[1339, 1339], "mapped", [1387]], [[1340, 1340], "mapped", [1388]], [[1341, 1341], "mapped", [1389]], [[1342, 1342], "mapped", [1390]], [[1343, 1343], "mapped", [1391]], [[1344, 1344], "mapped", [1392]], [[1345, 1345], "mapped", [1393]], [[1346, 1346], "mapped", [1394]], [[1347, 1347], "mapped", [1395]], [[1348, 1348], "mapped", [1396]], [[1349, 1349], "mapped", [1397]], [[1350, 1350], "mapped", [1398]], [[1351, 1351], "mapped", [1399]], [[1352, 1352], "mapped", [1400]], [[1353, 1353], "mapped", [1401]], [[1354, 1354], "mapped", [1402]], [[1355, 1355], "mapped", [1403]], [[1356, 1356], "mapped", [1404]], [[1357, 1357], "mapped", [1405]], [[1358, 1358], "mapped", [1406]], [[1359, 1359], "mapped", [1407]], [[1360, 1360], "mapped", [1408]], [[1361, 1361], "mapped", [1409]], [[1362, 1362], "mapped", [1410]], [[1363, 1363], "mapped", [1411]], [[1364, 1364], "mapped", [1412]], [[1365, 1365], "mapped", [1413]], [[1366, 1366], "mapped", [1414]], [[1367, 1368], "disallowed"], [[1369, 1369], "valid"], [[1370, 1375], "valid", [], "NV8"], [[1376, 1376], "disallowed"], [[1377, 1414], "valid"], [[1415, 1415], "mapped", [1381, 1410]], [[1416, 1416], "disallowed"], [[1417, 1417], "valid", [], "NV8"], [[1418, 1418], "valid", [], "NV8"], [[1419, 1420], "disallowed"], [[1421, 1422], "valid", [], "NV8"], [[1423, 1423], "valid", [], "NV8"], [[1424, 1424], "disallowed"], [[1425, 1441], "valid"], [[1442, 1442], "valid"], [[1443, 1455], "valid"], [[1456, 1465], "valid"], [[1466, 1466], "valid"], [[1467, 1469], "valid"], [[1470, 1470], "valid", [], "NV8"], [[1471, 1471], "valid"], [[1472, 1472], "valid", [], "NV8"], [[1473, 1474], "valid"], [[1475, 1475], "valid", [], "NV8"], [[1476, 1476], "valid"], [[1477, 1477], "valid"], [[1478, 1478], "valid", [], "NV8"], [[1479, 1479], "valid"], [[1480, 1487], "disallowed"], [[1488, 1514], "valid"], [[1515, 1519], "disallowed"], [[1520, 1524], "valid"], [[1525, 1535], "disallowed"], [[1536, 1539], "disallowed"], [[1540, 1540], "disallowed"], [[1541, 1541], "disallowed"], [[1542, 1546], "valid", [], "NV8"], [[1547, 1547], "valid", [], "NV8"], [[1548, 1548], "valid", [], "NV8"], [[1549, 1551], "valid", [], "NV8"], [[1552, 1557], "valid"], [[1558, 1562], "valid"], [[1563, 1563], "valid", [], "NV8"], [[1564, 1564], "disallowed"], [[1565, 1565], "disallowed"], [[1566, 1566], "valid", [], "NV8"], [[1567, 1567], "valid", [], "NV8"], [[1568, 1568], "valid"], [[1569, 1594], "valid"], [[1595, 1599], "valid"], [[1600, 1600], "valid", [], "NV8"], [[1601, 1618], "valid"], [[1619, 1621], "valid"], [[1622, 1624], "valid"], [[1625, 1630], "valid"], [[1631, 1631], "valid"], [[1632, 1641], "valid"], [[1642, 1645], "valid", [], "NV8"], [[1646, 1647], "valid"], [[1648, 1652], "valid"], [[1653, 1653], "mapped", [1575, 1652]], [[1654, 1654], "mapped", [1608, 1652]], [[1655, 1655], "mapped", [1735, 1652]], [[1656, 1656], "mapped", [1610, 1652]], [[1657, 1719], "valid"], [[1720, 1721], "valid"], [[1722, 1726], "valid"], [[1727, 1727], "valid"], [[1728, 1742], "valid"], [[1743, 1743], "valid"], [[1744, 1747], "valid"], [[1748, 1748], "valid", [], "NV8"], [[1749, 1756], "valid"], [[1757, 1757], "disallowed"], [[1758, 1758], "valid", [], "NV8"], [[1759, 1768], "valid"], [[1769, 1769], "valid", [], "NV8"], [[1770, 1773], "valid"], [[1774, 1775], "valid"], [[1776, 1785], "valid"], [[1786, 1790], "valid"], [[1791, 1791], "valid"], [[1792, 1805], "valid", [], "NV8"], [[1806, 1806], "disallowed"], [[1807, 1807], "disallowed"], [[1808, 1836], "valid"], [[1837, 1839], "valid"], [[1840, 1866], "valid"], [[1867, 1868], "disallowed"], [[1869, 1871], "valid"], [[1872, 1901], "valid"], [[1902, 1919], "valid"], [[1920, 1968], "valid"], [[1969, 1969], "valid"], [[1970, 1983], "disallowed"], [[1984, 2037], "valid"], [[2038, 2042], "valid", [], "NV8"], [[2043, 2047], "disallowed"], [[2048, 2093], "valid"], [[2094, 2095], "disallowed"], [[2096, 2110], "valid", [], "NV8"], [[2111, 2111], "disallowed"], [[2112, 2139], "valid"], [[2140, 2141], "disallowed"], [[2142, 2142], "valid", [], "NV8"], [[2143, 2207], "disallowed"], [[2208, 2208], "valid"], [[2209, 2209], "valid"], [[2210, 2220], "valid"], [[2221, 2226], "valid"], [[2227, 2228], "valid"], [[2229, 2274], "disallowed"], [[2275, 2275], "valid"], [[2276, 2302], "valid"], [[2303, 2303], "valid"], [[2304, 2304], "valid"], [[2305, 2307], "valid"], [[2308, 2308], "valid"], [[2309, 2361], "valid"], [[2362, 2363], "valid"], [[2364, 2381], "valid"], [[2382, 2382], "valid"], [[2383, 2383], "valid"], [[2384, 2388], "valid"], [[2389, 2389], "valid"], [[2390, 2391], "valid"], [[2392, 2392], "mapped", [2325, 2364]], [[2393, 2393], "mapped", [2326, 2364]], [[2394, 2394], "mapped", [2327, 2364]], [[2395, 2395], "mapped", [2332, 2364]], [[2396, 2396], "mapped", [2337, 2364]], [[2397, 2397], "mapped", [2338, 2364]], [[2398, 2398], "mapped", [2347, 2364]], [[2399, 2399], "mapped", [2351, 2364]], [[2400, 2403], "valid"], [[2404, 2405], "valid", [], "NV8"], [[2406, 2415], "valid"], [[2416, 2416], "valid", [], "NV8"], [[2417, 2418], "valid"], [[2419, 2423], "valid"], [[2424, 2424], "valid"], [[2425, 2426], "valid"], [[2427, 2428], "valid"], [[2429, 2429], "valid"], [[2430, 2431], "valid"], [[2432, 2432], "valid"], [[2433, 2435], "valid"], [[2436, 2436], "disallowed"], [[2437, 2444], "valid"], [[2445, 2446], "disallowed"], [[2447, 2448], "valid"], [[2449, 2450], "disallowed"], [[2451, 2472], "valid"], [[2473, 2473], "disallowed"], [[2474, 2480], "valid"], [[2481, 2481], "disallowed"], [[2482, 2482], "valid"], [[2483, 2485], "disallowed"], [[2486, 2489], "valid"], [[2490, 2491], "disallowed"], [[2492, 2492], "valid"], [[2493, 2493], "valid"], [[2494, 2500], "valid"], [[2501, 2502], "disallowed"], [[2503, 2504], "valid"], [[2505, 2506], "disallowed"], [[2507, 2509], "valid"], [[2510, 2510], "valid"], [[2511, 2518], "disallowed"], [[2519, 2519], "valid"], [[2520, 2523], "disallowed"], [[2524, 2524], "mapped", [2465, 2492]], [[2525, 2525], "mapped", [2466, 2492]], [[2526, 2526], "disallowed"], [[2527, 2527], "mapped", [2479, 2492]], [[2528, 2531], "valid"], [[2532, 2533], "disallowed"], [[2534, 2545], "valid"], [[2546, 2554], "valid", [], "NV8"], [[2555, 2555], "valid", [], "NV8"], [[2556, 2560], "disallowed"], [[2561, 2561], "valid"], [[2562, 2562], "valid"], [[2563, 2563], "valid"], [[2564, 2564], "disallowed"], [[2565, 2570], "valid"], [[2571, 2574], "disallowed"], [[2575, 2576], "valid"], [[2577, 2578], "disallowed"], [[2579, 2600], "valid"], [[2601, 2601], "disallowed"], [[2602, 2608], "valid"], [[2609, 2609], "disallowed"], [[2610, 2610], "valid"], [[2611, 2611], "mapped", [2610, 2620]], [[2612, 2612], "disallowed"], [[2613, 2613], "valid"], [[2614, 2614], "mapped", [2616, 2620]], [[2615, 2615], "disallowed"], [[2616, 2617], "valid"], [[2618, 2619], "disallowed"], [[2620, 2620], "valid"], [[2621, 2621], "disallowed"], [[2622, 2626], "valid"], [[2627, 2630], "disallowed"], [[2631, 2632], "valid"], [[2633, 2634], "disallowed"], [[2635, 2637], "valid"], [[2638, 2640], "disallowed"], [[2641, 2641], "valid"], [[2642, 2648], "disallowed"], [[2649, 2649], "mapped", [2582, 2620]], [[2650, 2650], "mapped", [2583, 2620]], [[2651, 2651], "mapped", [2588, 2620]], [[2652, 2652], "valid"], [[2653, 2653], "disallowed"], [[2654, 2654], "mapped", [2603, 2620]], [[2655, 2661], "disallowed"], [[2662, 2676], "valid"], [[2677, 2677], "valid"], [[2678, 2688], "disallowed"], [[2689, 2691], "valid"], [[2692, 2692], "disallowed"], [[2693, 2699], "valid"], [[2700, 2700], "valid"], [[2701, 2701], "valid"], [[2702, 2702], "disallowed"], [[2703, 2705], "valid"], [[2706, 2706], "disallowed"], [[2707, 2728], "valid"], [[2729, 2729], "disallowed"], [[2730, 2736], "valid"], [[2737, 2737], "disallowed"], [[2738, 2739], "valid"], [[2740, 2740], "disallowed"], [[2741, 2745], "valid"], [[2746, 2747], "disallowed"], [[2748, 2757], "valid"], [[2758, 2758], "disallowed"], [[2759, 2761], "valid"], [[2762, 2762], "disallowed"], [[2763, 2765], "valid"], [[2766, 2767], "disallowed"], [[2768, 2768], "valid"], [[2769, 2783], "disallowed"], [[2784, 2784], "valid"], [[2785, 2787], "valid"], [[2788, 2789], "disallowed"], [[2790, 2799], "valid"], [[2800, 2800], "valid", [], "NV8"], [[2801, 2801], "valid", [], "NV8"], [[2802, 2808], "disallowed"], [[2809, 2809], "valid"], [[2810, 2816], "disallowed"], [[2817, 2819], "valid"], [[2820, 2820], "disallowed"], [[2821, 2828], "valid"], [[2829, 2830], "disallowed"], [[2831, 2832], "valid"], [[2833, 2834], "disallowed"], [[2835, 2856], "valid"], [[2857, 2857], "disallowed"], [[2858, 2864], "valid"], [[2865, 2865], "disallowed"], [[2866, 2867], "valid"], [[2868, 2868], "disallowed"], [[2869, 2869], "valid"], [[2870, 2873], "valid"], [[2874, 2875], "disallowed"], [[2876, 2883], "valid"], [[2884, 2884], "valid"], [[2885, 2886], "disallowed"], [[2887, 2888], "valid"], [[2889, 2890], "disallowed"], [[2891, 2893], "valid"], [[2894, 2901], "disallowed"], [[2902, 2903], "valid"], [[2904, 2907], "disallowed"], [[2908, 2908], "mapped", [2849, 2876]], [[2909, 2909], "mapped", [2850, 2876]], [[2910, 2910], "disallowed"], [[2911, 2913], "valid"], [[2914, 2915], "valid"], [[2916, 2917], "disallowed"], [[2918, 2927], "valid"], [[2928, 2928], "valid", [], "NV8"], [[2929, 2929], "valid"], [[2930, 2935], "valid", [], "NV8"], [[2936, 2945], "disallowed"], [[2946, 2947], "valid"], [[2948, 2948], "disallowed"], [[2949, 2954], "valid"], [[2955, 2957], "disallowed"], [[2958, 2960], "valid"], [[2961, 2961], "disallowed"], [[2962, 2965], "valid"], [[2966, 2968], "disallowed"], [[2969, 2970], "valid"], [[2971, 2971], "disallowed"], [[2972, 2972], "valid"], [[2973, 2973], "disallowed"], [[2974, 2975], "valid"], [[2976, 2978], "disallowed"], [[2979, 2980], "valid"], [[2981, 2983], "disallowed"], [[2984, 2986], "valid"], [[2987, 2989], "disallowed"], [[2990, 2997], "valid"], [[2998, 2998], "valid"], [[2999, 3001], "valid"], [[3002, 3005], "disallowed"], [[3006, 3010], "valid"], [[3011, 3013], "disallowed"], [[3014, 3016], "valid"], [[3017, 3017], "disallowed"], [[3018, 3021], "valid"], [[3022, 3023], "disallowed"], [[3024, 3024], "valid"], [[3025, 3030], "disallowed"], [[3031, 3031], "valid"], [[3032, 3045], "disallowed"], [[3046, 3046], "valid"], [[3047, 3055], "valid"], [[3056, 3058], "valid", [], "NV8"], [[3059, 3066], "valid", [], "NV8"], [[3067, 3071], "disallowed"], [[3072, 3072], "valid"], [[3073, 3075], "valid"], [[3076, 3076], "disallowed"], [[3077, 3084], "valid"], [[3085, 3085], "disallowed"], [[3086, 3088], "valid"], [[3089, 3089], "disallowed"], [[3090, 3112], "valid"], [[3113, 3113], "disallowed"], [[3114, 3123], "valid"], [[3124, 3124], "valid"], [[3125, 3129], "valid"], [[3130, 3132], "disallowed"], [[3133, 3133], "valid"], [[3134, 3140], "valid"], [[3141, 3141], "disallowed"], [[3142, 3144], "valid"], [[3145, 3145], "disallowed"], [[3146, 3149], "valid"], [[3150, 3156], "disallowed"], [[3157, 3158], "valid"], [[3159, 3159], "disallowed"], [[3160, 3161], "valid"], [[3162, 3162], "valid"], [[3163, 3167], "disallowed"], [[3168, 3169], "valid"], [[3170, 3171], "valid"], [[3172, 3173], "disallowed"], [[3174, 3183], "valid"], [[3184, 3191], "disallowed"], [[3192, 3199], "valid", [], "NV8"], [[3200, 3200], "disallowed"], [[3201, 3201], "valid"], [[3202, 3203], "valid"], [[3204, 3204], "disallowed"], [[3205, 3212], "valid"], [[3213, 3213], "disallowed"], [[3214, 3216], "valid"], [[3217, 3217], "disallowed"], [[3218, 3240], "valid"], [[3241, 3241], "disallowed"], [[3242, 3251], "valid"], [[3252, 3252], "disallowed"], [[3253, 3257], "valid"], [[3258, 3259], "disallowed"], [[3260, 3261], "valid"], [[3262, 3268], "valid"], [[3269, 3269], "disallowed"], [[3270, 3272], "valid"], [[3273, 3273], "disallowed"], [[3274, 3277], "valid"], [[3278, 3284], "disallowed"], [[3285, 3286], "valid"], [[3287, 3293], "disallowed"], [[3294, 3294], "valid"], [[3295, 3295], "disallowed"], [[3296, 3297], "valid"], [[3298, 3299], "valid"], [[3300, 3301], "disallowed"], [[3302, 3311], "valid"], [[3312, 3312], "disallowed"], [[3313, 3314], "valid"], [[3315, 3328], "disallowed"], [[3329, 3329], "valid"], [[3330, 3331], "valid"], [[3332, 3332], "disallowed"], [[3333, 3340], "valid"], [[3341, 3341], "disallowed"], [[3342, 3344], "valid"], [[3345, 3345], "disallowed"], [[3346, 3368], "valid"], [[3369, 3369], "valid"], [[3370, 3385], "valid"], [[3386, 3386], "valid"], [[3387, 3388], "disallowed"], [[3389, 3389], "valid"], [[3390, 3395], "valid"], [[3396, 3396], "valid"], [[3397, 3397], "disallowed"], [[3398, 3400], "valid"], [[3401, 3401], "disallowed"], [[3402, 3405], "valid"], [[3406, 3406], "valid"], [[3407, 3414], "disallowed"], [[3415, 3415], "valid"], [[3416, 3422], "disallowed"], [[3423, 3423], "valid"], [[3424, 3425], "valid"], [[3426, 3427], "valid"], [[3428, 3429], "disallowed"], [[3430, 3439], "valid"], [[3440, 3445], "valid", [], "NV8"], [[3446, 3448], "disallowed"], [[3449, 3449], "valid", [], "NV8"], [[3450, 3455], "valid"], [[3456, 3457], "disallowed"], [[3458, 3459], "valid"], [[3460, 3460], "disallowed"], [[3461, 3478], "valid"], [[3479, 3481], "disallowed"], [[3482, 3505], "valid"], [[3506, 3506], "disallowed"], [[3507, 3515], "valid"], [[3516, 3516], "disallowed"], [[3517, 3517], "valid"], [[3518, 3519], "disallowed"], [[3520, 3526], "valid"], [[3527, 3529], "disallowed"], [[3530, 3530], "valid"], [[3531, 3534], "disallowed"], [[3535, 3540], "valid"], [[3541, 3541], "disallowed"], [[3542, 3542], "valid"], [[3543, 3543], "disallowed"], [[3544, 3551], "valid"], [[3552, 3557], "disallowed"], [[3558, 3567], "valid"], [[3568, 3569], "disallowed"], [[3570, 3571], "valid"], [[3572, 3572], "valid", [], "NV8"], [[3573, 3584], "disallowed"], [[3585, 3634], "valid"], [[3635, 3635], "mapped", [3661, 3634]], [[3636, 3642], "valid"], [[3643, 3646], "disallowed"], [[3647, 3647], "valid", [], "NV8"], [[3648, 3662], "valid"], [[3663, 3663], "valid", [], "NV8"], [[3664, 3673], "valid"], [[3674, 3675], "valid", [], "NV8"], [[3676, 3712], "disallowed"], [[3713, 3714], "valid"], [[3715, 3715], "disallowed"], [[3716, 3716], "valid"], [[3717, 3718], "disallowed"], [[3719, 3720], "valid"], [[3721, 3721], "disallowed"], [[3722, 3722], "valid"], [[3723, 3724], "disallowed"], [[3725, 3725], "valid"], [[3726, 3731], "disallowed"], [[3732, 3735], "valid"], [[3736, 3736], "disallowed"], [[3737, 3743], "valid"], [[3744, 3744], "disallowed"], [[3745, 3747], "valid"], [[3748, 3748], "disallowed"], [[3749, 3749], "valid"], [[3750, 3750], "disallowed"], [[3751, 3751], "valid"], [[3752, 3753], "disallowed"], [[3754, 3755], "valid"], [[3756, 3756], "disallowed"], [[3757, 3762], "valid"], [[3763, 3763], "mapped", [3789, 3762]], [[3764, 3769], "valid"], [[3770, 3770], "disallowed"], [[3771, 3773], "valid"], [[3774, 3775], "disallowed"], [[3776, 3780], "valid"], [[3781, 3781], "disallowed"], [[3782, 3782], "valid"], [[3783, 3783], "disallowed"], [[3784, 3789], "valid"], [[3790, 3791], "disallowed"], [[3792, 3801], "valid"], [[3802, 3803], "disallowed"], [[3804, 3804], "mapped", [3755, 3737]], [[3805, 3805], "mapped", [3755, 3745]], [[3806, 3807], "valid"], [[3808, 3839], "disallowed"], [[3840, 3840], "valid"], [[3841, 3850], "valid", [], "NV8"], [[3851, 3851], "valid"], [[3852, 3852], "mapped", [3851]], [[3853, 3863], "valid", [], "NV8"], [[3864, 3865], "valid"], [[3866, 3871], "valid", [], "NV8"], [[3872, 3881], "valid"], [[3882, 3892], "valid", [], "NV8"], [[3893, 3893], "valid"], [[3894, 3894], "valid", [], "NV8"], [[3895, 3895], "valid"], [[3896, 3896], "valid", [], "NV8"], [[3897, 3897], "valid"], [[3898, 3901], "valid", [], "NV8"], [[3902, 3906], "valid"], [[3907, 3907], "mapped", [3906, 4023]], [[3908, 3911], "valid"], [[3912, 3912], "disallowed"], [[3913, 3916], "valid"], [[3917, 3917], "mapped", [3916, 4023]], [[3918, 3921], "valid"], [[3922, 3922], "mapped", [3921, 4023]], [[3923, 3926], "valid"], [[3927, 3927], "mapped", [3926, 4023]], [[3928, 3931], "valid"], [[3932, 3932], "mapped", [3931, 4023]], [[3933, 3944], "valid"], [[3945, 3945], "mapped", [3904, 4021]], [[3946, 3946], "valid"], [[3947, 3948], "valid"], [[3949, 3952], "disallowed"], [[3953, 3954], "valid"], [[3955, 3955], "mapped", [3953, 3954]], [[3956, 3956], "valid"], [[3957, 3957], "mapped", [3953, 3956]], [[3958, 3958], "mapped", [4018, 3968]], [[3959, 3959], "mapped", [4018, 3953, 3968]], [[3960, 3960], "mapped", [4019, 3968]], [[3961, 3961], "mapped", [4019, 3953, 3968]], [[3962, 3968], "valid"], [[3969, 3969], "mapped", [3953, 3968]], [[3970, 3972], "valid"], [[3973, 3973], "valid", [], "NV8"], [[3974, 3979], "valid"], [[3980, 3983], "valid"], [[3984, 3986], "valid"], [[3987, 3987], "mapped", [3986, 4023]], [[3988, 3989], "valid"], [[3990, 3990], "valid"], [[3991, 3991], "valid"], [[3992, 3992], "disallowed"], [[3993, 3996], "valid"], [[3997, 3997], "mapped", [3996, 4023]], [[3998, 4001], "valid"], [[4002, 4002], "mapped", [4001, 4023]], [[4003, 4006], "valid"], [[4007, 4007], "mapped", [4006, 4023]], [[4008, 4011], "valid"], [[4012, 4012], "mapped", [4011, 4023]], [[4013, 4013], "valid"], [[4014, 4016], "valid"], [[4017, 4023], "valid"], [[4024, 4024], "valid"], [[4025, 4025], "mapped", [3984, 4021]], [[4026, 4028], "valid"], [[4029, 4029], "disallowed"], [[4030, 4037], "valid", [], "NV8"], [[4038, 4038], "valid"], [[4039, 4044], "valid", [], "NV8"], [[4045, 4045], "disallowed"], [[4046, 4046], "valid", [], "NV8"], [[4047, 4047], "valid", [], "NV8"], [[4048, 4049], "valid", [], "NV8"], [[4050, 4052], "valid", [], "NV8"], [[4053, 4056], "valid", [], "NV8"], [[4057, 4058], "valid", [], "NV8"], [[4059, 4095], "disallowed"], [[4096, 4129], "valid"], [[4130, 4130], "valid"], [[4131, 4135], "valid"], [[4136, 4136], "valid"], [[4137, 4138], "valid"], [[4139, 4139], "valid"], [[4140, 4146], "valid"], [[4147, 4149], "valid"], [[4150, 4153], "valid"], [[4154, 4159], "valid"], [[4160, 4169], "valid"], [[4170, 4175], "valid", [], "NV8"], [[4176, 4185], "valid"], [[4186, 4249], "valid"], [[4250, 4253], "valid"], [[4254, 4255], "valid", [], "NV8"], [[4256, 4293], "disallowed"], [[4294, 4294], "disallowed"], [[4295, 4295], "mapped", [11559]], [[4296, 4300], "disallowed"], [[4301, 4301], "mapped", [11565]], [[4302, 4303], "disallowed"], [[4304, 4342], "valid"], [[4343, 4344], "valid"], [[4345, 4346], "valid"], [[4347, 4347], "valid", [], "NV8"], [[4348, 4348], "mapped", [4316]], [[4349, 4351], "valid"], [[4352, 4441], "valid", [], "NV8"], [[4442, 4446], "valid", [], "NV8"], [[4447, 4448], "disallowed"], [[4449, 4514], "valid", [], "NV8"], [[4515, 4519], "valid", [], "NV8"], [[4520, 4601], "valid", [], "NV8"], [[4602, 4607], "valid", [], "NV8"], [[4608, 4614], "valid"], [[4615, 4615], "valid"], [[4616, 4678], "valid"], [[4679, 4679], "valid"], [[4680, 4680], "valid"], [[4681, 4681], "disallowed"], [[4682, 4685], "valid"], [[4686, 4687], "disallowed"], [[4688, 4694], "valid"], [[4695, 4695], "disallowed"], [[4696, 4696], "valid"], [[4697, 4697], "disallowed"], [[4698, 4701], "valid"], [[4702, 4703], "disallowed"], [[4704, 4742], "valid"], [[4743, 4743], "valid"], [[4744, 4744], "valid"], [[4745, 4745], "disallowed"], [[4746, 4749], "valid"], [[4750, 4751], "disallowed"], [[4752, 4782], "valid"], [[4783, 4783], "valid"], [[4784, 4784], "valid"], [[4785, 4785], "disallowed"], [[4786, 4789], "valid"], [[4790, 4791], "disallowed"], [[4792, 4798], "valid"], [[4799, 4799], "disallowed"], [[4800, 4800], "valid"], [[4801, 4801], "disallowed"], [[4802, 4805], "valid"], [[4806, 4807], "disallowed"], [[4808, 4814], "valid"], [[4815, 4815], "valid"], [[4816, 4822], "valid"], [[4823, 4823], "disallowed"], [[4824, 4846], "valid"], [[4847, 4847], "valid"], [[4848, 4878], "valid"], [[4879, 4879], "valid"], [[4880, 4880], "valid"], [[4881, 4881], "disallowed"], [[4882, 4885], "valid"], [[4886, 4887], "disallowed"], [[4888, 4894], "valid"], [[4895, 4895], "valid"], [[4896, 4934], "valid"], [[4935, 4935], "valid"], [[4936, 4954], "valid"], [[4955, 4956], "disallowed"], [[4957, 4958], "valid"], [[4959, 4959], "valid"], [[4960, 4960], "valid", [], "NV8"], [[4961, 4988], "valid", [], "NV8"], [[4989, 4991], "disallowed"], [[4992, 5007], "valid"], [[5008, 5017], "valid", [], "NV8"], [[5018, 5023], "disallowed"], [[5024, 5108], "valid"], [[5109, 5109], "valid"], [[5110, 5111], "disallowed"], [[5112, 5112], "mapped", [5104]], [[5113, 5113], "mapped", [5105]], [[5114, 5114], "mapped", [5106]], [[5115, 5115], "mapped", [5107]], [[5116, 5116], "mapped", [5108]], [[5117, 5117], "mapped", [5109]], [[5118, 5119], "disallowed"], [[5120, 5120], "valid", [], "NV8"], [[5121, 5740], "valid"], [[5741, 5742], "valid", [], "NV8"], [[5743, 5750], "valid"], [[5751, 5759], "valid"], [[5760, 5760], "disallowed"], [[5761, 5786], "valid"], [[5787, 5788], "valid", [], "NV8"], [[5789, 5791], "disallowed"], [[5792, 5866], "valid"], [[5867, 5872], "valid", [], "NV8"], [[5873, 5880], "valid"], [[5881, 5887], "disallowed"], [[5888, 5900], "valid"], [[5901, 5901], "disallowed"], [[5902, 5908], "valid"], [[5909, 5919], "disallowed"], [[5920, 5940], "valid"], [[5941, 5942], "valid", [], "NV8"], [[5943, 5951], "disallowed"], [[5952, 5971], "valid"], [[5972, 5983], "disallowed"], [[5984, 5996], "valid"], [[5997, 5997], "disallowed"], [[5998, 6e3], "valid"], [[6001, 6001], "disallowed"], [[6002, 6003], "valid"], [[6004, 6015], "disallowed"], [[6016, 6067], "valid"], [[6068, 6069], "disallowed"], [[6070, 6099], "valid"], [[6100, 6102], "valid", [], "NV8"], [[6103, 6103], "valid"], [[6104, 6107], "valid", [], "NV8"], [[6108, 6108], "valid"], [[6109, 6109], "valid"], [[6110, 6111], "disallowed"], [[6112, 6121], "valid"], [[6122, 6127], "disallowed"], [[6128, 6137], "valid", [], "NV8"], [[6138, 6143], "disallowed"], [[6144, 6149], "valid", [], "NV8"], [[6150, 6150], "disallowed"], [[6151, 6154], "valid", [], "NV8"], [[6155, 6157], "ignored"], [[6158, 6158], "disallowed"], [[6159, 6159], "disallowed"], [[6160, 6169], "valid"], [[6170, 6175], "disallowed"], [[6176, 6263], "valid"], [[6264, 6271], "disallowed"], [[6272, 6313], "valid"], [[6314, 6314], "valid"], [[6315, 6319], "disallowed"], [[6320, 6389], "valid"], [[6390, 6399], "disallowed"], [[6400, 6428], "valid"], [[6429, 6430], "valid"], [[6431, 6431], "disallowed"], [[6432, 6443], "valid"], [[6444, 6447], "disallowed"], [[6448, 6459], "valid"], [[6460, 6463], "disallowed"], [[6464, 6464], "valid", [], "NV8"], [[6465, 6467], "disallowed"], [[6468, 6469], "valid", [], "NV8"], [[6470, 6509], "valid"], [[6510, 6511], "disallowed"], [[6512, 6516], "valid"], [[6517, 6527], "disallowed"], [[6528, 6569], "valid"], [[6570, 6571], "valid"], [[6572, 6575], "disallowed"], [[6576, 6601], "valid"], [[6602, 6607], "disallowed"], [[6608, 6617], "valid"], [[6618, 6618], "valid", [], "XV8"], [[6619, 6621], "disallowed"], [[6622, 6623], "valid", [], "NV8"], [[6624, 6655], "valid", [], "NV8"], [[6656, 6683], "valid"], [[6684, 6685], "disallowed"], [[6686, 6687], "valid", [], "NV8"], [[6688, 6750], "valid"], [[6751, 6751], "disallowed"], [[6752, 6780], "valid"], [[6781, 6782], "disallowed"], [[6783, 6793], "valid"], [[6794, 6799], "disallowed"], [[6800, 6809], "valid"], [[6810, 6815], "disallowed"], [[6816, 6822], "valid", [], "NV8"], [[6823, 6823], "valid"], [[6824, 6829], "valid", [], "NV8"], [[6830, 6831], "disallowed"], [[6832, 6845], "valid"], [[6846, 6846], "valid", [], "NV8"], [[6847, 6911], "disallowed"], [[6912, 6987], "valid"], [[6988, 6991], "disallowed"], [[6992, 7001], "valid"], [[7002, 7018], "valid", [], "NV8"], [[7019, 7027], "valid"], [[7028, 7036], "valid", [], "NV8"], [[7037, 7039], "disallowed"], [[7040, 7082], "valid"], [[7083, 7085], "valid"], [[7086, 7097], "valid"], [[7098, 7103], "valid"], [[7104, 7155], "valid"], [[7156, 7163], "disallowed"], [[7164, 7167], "valid", [], "NV8"], [[7168, 7223], "valid"], [[7224, 7226], "disallowed"], [[7227, 7231], "valid", [], "NV8"], [[7232, 7241], "valid"], [[7242, 7244], "disallowed"], [[7245, 7293], "valid"], [[7294, 7295], "valid", [], "NV8"], [[7296, 7359], "disallowed"], [[7360, 7367], "valid", [], "NV8"], [[7368, 7375], "disallowed"], [[7376, 7378], "valid"], [[7379, 7379], "valid", [], "NV8"], [[7380, 7410], "valid"], [[7411, 7414], "valid"], [[7415, 7415], "disallowed"], [[7416, 7417], "valid"], [[7418, 7423], "disallowed"], [[7424, 7467], "valid"], [[7468, 7468], "mapped", [97]], [[7469, 7469], "mapped", [230]], [[7470, 7470], "mapped", [98]], [[7471, 7471], "valid"], [[7472, 7472], "mapped", [100]], [[7473, 7473], "mapped", [101]], [[7474, 7474], "mapped", [477]], [[7475, 7475], "mapped", [103]], [[7476, 7476], "mapped", [104]], [[7477, 7477], "mapped", [105]], [[7478, 7478], "mapped", [106]], [[7479, 7479], "mapped", [107]], [[7480, 7480], "mapped", [108]], [[7481, 7481], "mapped", [109]], [[7482, 7482], "mapped", [110]], [[7483, 7483], "valid"], [[7484, 7484], "mapped", [111]], [[7485, 7485], "mapped", [547]], [[7486, 7486], "mapped", [112]], [[7487, 7487], "mapped", [114]], [[7488, 7488], "mapped", [116]], [[7489, 7489], "mapped", [117]], [[7490, 7490], "mapped", [119]], [[7491, 7491], "mapped", [97]], [[7492, 7492], "mapped", [592]], [[7493, 7493], "mapped", [593]], [[7494, 7494], "mapped", [7426]], [[7495, 7495], "mapped", [98]], [[7496, 7496], "mapped", [100]], [[7497, 7497], "mapped", [101]], [[7498, 7498], "mapped", [601]], [[7499, 7499], "mapped", [603]], [[7500, 7500], "mapped", [604]], [[7501, 7501], "mapped", [103]], [[7502, 7502], "valid"], [[7503, 7503], "mapped", [107]], [[7504, 7504], "mapped", [109]], [[7505, 7505], "mapped", [331]], [[7506, 7506], "mapped", [111]], [[7507, 7507], "mapped", [596]], [[7508, 7508], "mapped", [7446]], [[7509, 7509], "mapped", [7447]], [[7510, 7510], "mapped", [112]], [[7511, 7511], "mapped", [116]], [[7512, 7512], "mapped", [117]], [[7513, 7513], "mapped", [7453]], [[7514, 7514], "mapped", [623]], [[7515, 7515], "mapped", [118]], [[7516, 7516], "mapped", [7461]], [[7517, 7517], "mapped", [946]], [[7518, 7518], "mapped", [947]], [[7519, 7519], "mapped", [948]], [[7520, 7520], "mapped", [966]], [[7521, 7521], "mapped", [967]], [[7522, 7522], "mapped", [105]], [[7523, 7523], "mapped", [114]], [[7524, 7524], "mapped", [117]], [[7525, 7525], "mapped", [118]], [[7526, 7526], "mapped", [946]], [[7527, 7527], "mapped", [947]], [[7528, 7528], "mapped", [961]], [[7529, 7529], "mapped", [966]], [[7530, 7530], "mapped", [967]], [[7531, 7531], "valid"], [[7532, 7543], "valid"], [[7544, 7544], "mapped", [1085]], [[7545, 7578], "valid"], [[7579, 7579], "mapped", [594]], [[7580, 7580], "mapped", [99]], [[7581, 7581], "mapped", [597]], [[7582, 7582], "mapped", [240]], [[7583, 7583], "mapped", [604]], [[7584, 7584], "mapped", [102]], [[7585, 7585], "mapped", [607]], [[7586, 7586], "mapped", [609]], [[7587, 7587], "mapped", [613]], [[7588, 7588], "mapped", [616]], [[7589, 7589], "mapped", [617]], [[7590, 7590], "mapped", [618]], [[7591, 7591], "mapped", [7547]], [[7592, 7592], "mapped", [669]], [[7593, 7593], "mapped", [621]], [[7594, 7594], "mapped", [7557]], [[7595, 7595], "mapped", [671]], [[7596, 7596], "mapped", [625]], [[7597, 7597], "mapped", [624]], [[7598, 7598], "mapped", [626]], [[7599, 7599], "mapped", [627]], [[7600, 7600], "mapped", [628]], [[7601, 7601], "mapped", [629]], [[7602, 7602], "mapped", [632]], [[7603, 7603], "mapped", [642]], [[7604, 7604], "mapped", [643]], [[7605, 7605], "mapped", [427]], [[7606, 7606], "mapped", [649]], [[7607, 7607], "mapped", [650]], [[7608, 7608], "mapped", [7452]], [[7609, 7609], "mapped", [651]], [[7610, 7610], "mapped", [652]], [[7611, 7611], "mapped", [122]], [[7612, 7612], "mapped", [656]], [[7613, 7613], "mapped", [657]], [[7614, 7614], "mapped", [658]], [[7615, 7615], "mapped", [952]], [[7616, 7619], "valid"], [[7620, 7626], "valid"], [[7627, 7654], "valid"], [[7655, 7669], "valid"], [[7670, 7675], "disallowed"], [[7676, 7676], "valid"], [[7677, 7677], "valid"], [[7678, 7679], "valid"], [[7680, 7680], "mapped", [7681]], [[7681, 7681], "valid"], [[7682, 7682], "mapped", [7683]], [[7683, 7683], "valid"], [[7684, 7684], "mapped", [7685]], [[7685, 7685], "valid"], [[7686, 7686], "mapped", [7687]], [[7687, 7687], "valid"], [[7688, 7688], "mapped", [7689]], [[7689, 7689], "valid"], [[7690, 7690], "mapped", [7691]], [[7691, 7691], "valid"], [[7692, 7692], "mapped", [7693]], [[7693, 7693], "valid"], [[7694, 7694], "mapped", [7695]], [[7695, 7695], "valid"], [[7696, 7696], "mapped", [7697]], [[7697, 7697], "valid"], [[7698, 7698], "mapped", [7699]], [[7699, 7699], "valid"], [[7700, 7700], "mapped", [7701]], [[7701, 7701], "valid"], [[7702, 7702], "mapped", [7703]], [[7703, 7703], "valid"], [[7704, 7704], "mapped", [7705]], [[7705, 7705], "valid"], [[7706, 7706], "mapped", [7707]], [[7707, 7707], "valid"], [[7708, 7708], "mapped", [7709]], [[7709, 7709], "valid"], [[7710, 7710], "mapped", [7711]], [[7711, 7711], "valid"], [[7712, 7712], "mapped", [7713]], [[7713, 7713], "valid"], [[7714, 7714], "mapped", [7715]], [[7715, 7715], "valid"], [[7716, 7716], "mapped", [7717]], [[7717, 7717], "valid"], [[7718, 7718], "mapped", [7719]], [[7719, 7719], "valid"], [[7720, 7720], "mapped", [7721]], [[7721, 7721], "valid"], [[7722, 7722], "mapped", [7723]], [[7723, 7723], "valid"], [[7724, 7724], "mapped", [7725]], [[7725, 7725], "valid"], [[7726, 7726], "mapped", [7727]], [[7727, 7727], "valid"], [[7728, 7728], "mapped", [7729]], [[7729, 7729], "valid"], [[7730, 7730], "mapped", [7731]], [[7731, 7731], "valid"], [[7732, 7732], "mapped", [7733]], [[7733, 7733], "valid"], [[7734, 7734], "mapped", [7735]], [[7735, 7735], "valid"], [[7736, 7736], "mapped", [7737]], [[7737, 7737], "valid"], [[7738, 7738], "mapped", [7739]], [[7739, 7739], "valid"], [[7740, 7740], "mapped", [7741]], [[7741, 7741], "valid"], [[7742, 7742], "mapped", [7743]], [[7743, 7743], "valid"], [[7744, 7744], "mapped", [7745]], [[7745, 7745], "valid"], [[7746, 7746], "mapped", [7747]], [[7747, 7747], "valid"], [[7748, 7748], "mapped", [7749]], [[7749, 7749], "valid"], [[7750, 7750], "mapped", [7751]], [[7751, 7751], "valid"], [[7752, 7752], "mapped", [7753]], [[7753, 7753], "valid"], [[7754, 7754], "mapped", [7755]], [[7755, 7755], "valid"], [[7756, 7756], "mapped", [7757]], [[7757, 7757], "valid"], [[7758, 7758], "mapped", [7759]], [[7759, 7759], "valid"], [[7760, 7760], "mapped", [7761]], [[7761, 7761], "valid"], [[7762, 7762], "mapped", [7763]], [[7763, 7763], "valid"], [[7764, 7764], "mapped", [7765]], [[7765, 7765], "valid"], [[7766, 7766], "mapped", [7767]], [[7767, 7767], "valid"], [[7768, 7768], "mapped", [7769]], [[7769, 7769], "valid"], [[7770, 7770], "mapped", [7771]], [[7771, 7771], "valid"], [[7772, 7772], "mapped", [7773]], [[7773, 7773], "valid"], [[7774, 7774], "mapped", [7775]], [[7775, 7775], "valid"], [[7776, 7776], "mapped", [7777]], [[7777, 7777], "valid"], [[7778, 7778], "mapped", [7779]], [[7779, 7779], "valid"], [[7780, 7780], "mapped", [7781]], [[7781, 7781], "valid"], [[7782, 7782], "mapped", [7783]], [[7783, 7783], "valid"], [[7784, 7784], "mapped", [7785]], [[7785, 7785], "valid"], [[7786, 7786], "mapped", [7787]], [[7787, 7787], "valid"], [[7788, 7788], "mapped", [7789]], [[7789, 7789], "valid"], [[7790, 7790], "mapped", [7791]], [[7791, 7791], "valid"], [[7792, 7792], "mapped", [7793]], [[7793, 7793], "valid"], [[7794, 7794], "mapped", [7795]], [[7795, 7795], "valid"], [[7796, 7796], "mapped", [7797]], [[7797, 7797], "valid"], [[7798, 7798], "mapped", [7799]], [[7799, 7799], "valid"], [[7800, 7800], "mapped", [7801]], [[7801, 7801], "valid"], [[7802, 7802], "mapped", [7803]], [[7803, 7803], "valid"], [[7804, 7804], "mapped", [7805]], [[7805, 7805], "valid"], [[7806, 7806], "mapped", [7807]], [[7807, 7807], "valid"], [[7808, 7808], "mapped", [7809]], [[7809, 7809], "valid"], [[7810, 7810], "mapped", [7811]], [[7811, 7811], "valid"], [[7812, 7812], "mapped", [7813]], [[7813, 7813], "valid"], [[7814, 7814], "mapped", [7815]], [[7815, 7815], "valid"], [[7816, 7816], "mapped", [7817]], [[7817, 7817], "valid"], [[7818, 7818], "mapped", [7819]], [[7819, 7819], "valid"], [[7820, 7820], "mapped", [7821]], [[7821, 7821], "valid"], [[7822, 7822], "mapped", [7823]], [[7823, 7823], "valid"], [[7824, 7824], "mapped", [7825]], [[7825, 7825], "valid"], [[7826, 7826], "mapped", [7827]], [[7827, 7827], "valid"], [[7828, 7828], "mapped", [7829]], [[7829, 7833], "valid"], [[7834, 7834], "mapped", [97, 702]], [[7835, 7835], "mapped", [7777]], [[7836, 7837], "valid"], [[7838, 7838], "mapped", [115, 115]], [[7839, 7839], "valid"], [[7840, 7840], "mapped", [7841]], [[7841, 7841], "valid"], [[7842, 7842], "mapped", [7843]], [[7843, 7843], "valid"], [[7844, 7844], "mapped", [7845]], [[7845, 7845], "valid"], [[7846, 7846], "mapped", [7847]], [[7847, 7847], "valid"], [[7848, 7848], "mapped", [7849]], [[7849, 7849], "valid"], [[7850, 7850], "mapped", [7851]], [[7851, 7851], "valid"], [[7852, 7852], "mapped", [7853]], [[7853, 7853], "valid"], [[7854, 7854], "mapped", [7855]], [[7855, 7855], "valid"], [[7856, 7856], "mapped", [7857]], [[7857, 7857], "valid"], [[7858, 7858], "mapped", [7859]], [[7859, 7859], "valid"], [[7860, 7860], "mapped", [7861]], [[7861, 7861], "valid"], [[7862, 7862], "mapped", [7863]], [[7863, 7863], "valid"], [[7864, 7864], "mapped", [7865]], [[7865, 7865], "valid"], [[7866, 7866], "mapped", [7867]], [[7867, 7867], "valid"], [[7868, 7868], "mapped", [7869]], [[7869, 7869], "valid"], [[7870, 7870], "mapped", [7871]], [[7871, 7871], "valid"], [[7872, 7872], "mapped", [7873]], [[7873, 7873], "valid"], [[7874, 7874], "mapped", [7875]], [[7875, 7875], "valid"], [[7876, 7876], "mapped", [7877]], [[7877, 7877], "valid"], [[7878, 7878], "mapped", [7879]], [[7879, 7879], "valid"], [[7880, 7880], "mapped", [7881]], [[7881, 7881], "valid"], [[7882, 7882], "mapped", [7883]], [[7883, 7883], "valid"], [[7884, 7884], "mapped", [7885]], [[7885, 7885], "valid"], [[7886, 7886], "mapped", [7887]], [[7887, 7887], "valid"], [[7888, 7888], "mapped", [7889]], [[7889, 7889], "valid"], [[7890, 7890], "mapped", [7891]], [[7891, 7891], "valid"], [[7892, 7892], "mapped", [7893]], [[7893, 7893], "valid"], [[7894, 7894], "mapped", [7895]], [[7895, 7895], "valid"], [[7896, 7896], "mapped", [7897]], [[7897, 7897], "valid"], [[7898, 7898], "mapped", [7899]], [[7899, 7899], "valid"], [[7900, 7900], "mapped", [7901]], [[7901, 7901], "valid"], [[7902, 7902], "mapped", [7903]], [[7903, 7903], "valid"], [[7904, 7904], "mapped", [7905]], [[7905, 7905], "valid"], [[7906, 7906], "mapped", [7907]], [[7907, 7907], "valid"], [[7908, 7908], "mapped", [7909]], [[7909, 7909], "valid"], [[7910, 7910], "mapped", [7911]], [[7911, 7911], "valid"], [[7912, 7912], "mapped", [7913]], [[7913, 7913], "valid"], [[7914, 7914], "mapped", [7915]], [[7915, 7915], "valid"], [[7916, 7916], "mapped", [7917]], [[7917, 7917], "valid"], [[7918, 7918], "mapped", [7919]], [[7919, 7919], "valid"], [[7920, 7920], "mapped", [7921]], [[7921, 7921], "valid"], [[7922, 7922], "mapped", [7923]], [[7923, 7923], "valid"], [[7924, 7924], "mapped", [7925]], [[7925, 7925], "valid"], [[7926, 7926], "mapped", [7927]], [[7927, 7927], "valid"], [[7928, 7928], "mapped", [7929]], [[7929, 7929], "valid"], [[7930, 7930], "mapped", [7931]], [[7931, 7931], "valid"], [[7932, 7932], "mapped", [7933]], [[7933, 7933], "valid"], [[7934, 7934], "mapped", [7935]], [[7935, 7935], "valid"], [[7936, 7943], "valid"], [[7944, 7944], "mapped", [7936]], [[7945, 7945], "mapped", [7937]], [[7946, 7946], "mapped", [7938]], [[7947, 7947], "mapped", [7939]], [[7948, 7948], "mapped", [7940]], [[7949, 7949], "mapped", [7941]], [[7950, 7950], "mapped", [7942]], [[7951, 7951], "mapped", [7943]], [[7952, 7957], "valid"], [[7958, 7959], "disallowed"], [[7960, 7960], "mapped", [7952]], [[7961, 7961], "mapped", [7953]], [[7962, 7962], "mapped", [7954]], [[7963, 7963], "mapped", [7955]], [[7964, 7964], "mapped", [7956]], [[7965, 7965], "mapped", [7957]], [[7966, 7967], "disallowed"], [[7968, 7975], "valid"], [[7976, 7976], "mapped", [7968]], [[7977, 7977], "mapped", [7969]], [[7978, 7978], "mapped", [7970]], [[7979, 7979], "mapped", [7971]], [[7980, 7980], "mapped", [7972]], [[7981, 7981], "mapped", [7973]], [[7982, 7982], "mapped", [7974]], [[7983, 7983], "mapped", [7975]], [[7984, 7991], "valid"], [[7992, 7992], "mapped", [7984]], [[7993, 7993], "mapped", [7985]], [[7994, 7994], "mapped", [7986]], [[7995, 7995], "mapped", [7987]], [[7996, 7996], "mapped", [7988]], [[7997, 7997], "mapped", [7989]], [[7998, 7998], "mapped", [7990]], [[7999, 7999], "mapped", [7991]], [[8e3, 8005], "valid"], [[8006, 8007], "disallowed"], [[8008, 8008], "mapped", [8e3]], [[8009, 8009], "mapped", [8001]], [[8010, 8010], "mapped", [8002]], [[8011, 8011], "mapped", [8003]], [[8012, 8012], "mapped", [8004]], [[8013, 8013], "mapped", [8005]], [[8014, 8015], "disallowed"], [[8016, 8023], "valid"], [[8024, 8024], "disallowed"], [[8025, 8025], "mapped", [8017]], [[8026, 8026], "disallowed"], [[8027, 8027], "mapped", [8019]], [[8028, 8028], "disallowed"], [[8029, 8029], "mapped", [8021]], [[8030, 8030], "disallowed"], [[8031, 8031], "mapped", [8023]], [[8032, 8039], "valid"], [[8040, 8040], "mapped", [8032]], [[8041, 8041], "mapped", [8033]], [[8042, 8042], "mapped", [8034]], [[8043, 8043], "mapped", [8035]], [[8044, 8044], "mapped", [8036]], [[8045, 8045], "mapped", [8037]], [[8046, 8046], "mapped", [8038]], [[8047, 8047], "mapped", [8039]], [[8048, 8048], "valid"], [[8049, 8049], "mapped", [940]], [[8050, 8050], "valid"], [[8051, 8051], "mapped", [941]], [[8052, 8052], "valid"], [[8053, 8053], "mapped", [942]], [[8054, 8054], "valid"], [[8055, 8055], "mapped", [943]], [[8056, 8056], "valid"], [[8057, 8057], "mapped", [972]], [[8058, 8058], "valid"], [[8059, 8059], "mapped", [973]], [[8060, 8060], "valid"], [[8061, 8061], "mapped", [974]], [[8062, 8063], "disallowed"], [[8064, 8064], "mapped", [7936, 953]], [[8065, 8065], "mapped", [7937, 953]], [[8066, 8066], "mapped", [7938, 953]], [[8067, 8067], "mapped", [7939, 953]], [[8068, 8068], "mapped", [7940, 953]], [[8069, 8069], "mapped", [7941, 953]], [[8070, 8070], "mapped", [7942, 953]], [[8071, 8071], "mapped", [7943, 953]], [[8072, 8072], "mapped", [7936, 953]], [[8073, 8073], "mapped", [7937, 953]], [[8074, 8074], "mapped", [7938, 953]], [[8075, 8075], "mapped", [7939, 953]], [[8076, 8076], "mapped", [7940, 953]], [[8077, 8077], "mapped", [7941, 953]], [[8078, 8078], "mapped", [7942, 953]], [[8079, 8079], "mapped", [7943, 953]], [[8080, 8080], "mapped", [7968, 953]], [[8081, 8081], "mapped", [7969, 953]], [[8082, 8082], "mapped", [7970, 953]], [[8083, 8083], "mapped", [7971, 953]], [[8084, 8084], "mapped", [7972, 953]], [[8085, 8085], "mapped", [7973, 953]], [[8086, 8086], "mapped", [7974, 953]], [[8087, 8087], "mapped", [7975, 953]], [[8088, 8088], "mapped", [7968, 953]], [[8089, 8089], "mapped", [7969, 953]], [[8090, 8090], "mapped", [7970, 953]], [[8091, 8091], "mapped", [7971, 953]], [[8092, 8092], "mapped", [7972, 953]], [[8093, 8093], "mapped", [7973, 953]], [[8094, 8094], "mapped", [7974, 953]], [[8095, 8095], "mapped", [7975, 953]], [[8096, 8096], "mapped", [8032, 953]], [[8097, 8097], "mapped", [8033, 953]], [[8098, 8098], "mapped", [8034, 953]], [[8099, 8099], "mapped", [8035, 953]], [[8100, 8100], "mapped", [8036, 953]], [[8101, 8101], "mapped", [8037, 953]], [[8102, 8102], "mapped", [8038, 953]], [[8103, 8103], "mapped", [8039, 953]], [[8104, 8104], "mapped", [8032, 953]], [[8105, 8105], "mapped", [8033, 953]], [[8106, 8106], "mapped", [8034, 953]], [[8107, 8107], "mapped", [8035, 953]], [[8108, 8108], "mapped", [8036, 953]], [[8109, 8109], "mapped", [8037, 953]], [[8110, 8110], "mapped", [8038, 953]], [[8111, 8111], "mapped", [8039, 953]], [[8112, 8113], "valid"], [[8114, 8114], "mapped", [8048, 953]], [[8115, 8115], "mapped", [945, 953]], [[8116, 8116], "mapped", [940, 953]], [[8117, 8117], "disallowed"], [[8118, 8118], "valid"], [[8119, 8119], "mapped", [8118, 953]], [[8120, 8120], "mapped", [8112]], [[8121, 8121], "mapped", [8113]], [[8122, 8122], "mapped", [8048]], [[8123, 8123], "mapped", [940]], [[8124, 8124], "mapped", [945, 953]], [[8125, 8125], "disallowed_STD3_mapped", [32, 787]], [[8126, 8126], "mapped", [953]], [[8127, 8127], "disallowed_STD3_mapped", [32, 787]], [[8128, 8128], "disallowed_STD3_mapped", [32, 834]], [[8129, 8129], "disallowed_STD3_mapped", [32, 776, 834]], [[8130, 8130], "mapped", [8052, 953]], [[8131, 8131], "mapped", [951, 953]], [[8132, 8132], "mapped", [942, 953]], [[8133, 8133], "disallowed"], [[8134, 8134], "valid"], [[8135, 8135], "mapped", [8134, 953]], [[8136, 8136], "mapped", [8050]], [[8137, 8137], "mapped", [941]], [[8138, 8138], "mapped", [8052]], [[8139, 8139], "mapped", [942]], [[8140, 8140], "mapped", [951, 953]], [[8141, 8141], "disallowed_STD3_mapped", [32, 787, 768]], [[8142, 8142], "disallowed_STD3_mapped", [32, 787, 769]], [[8143, 8143], "disallowed_STD3_mapped", [32, 787, 834]], [[8144, 8146], "valid"], [[8147, 8147], "mapped", [912]], [[8148, 8149], "disallowed"], [[8150, 8151], "valid"], [[8152, 8152], "mapped", [8144]], [[8153, 8153], "mapped", [8145]], [[8154, 8154], "mapped", [8054]], [[8155, 8155], "mapped", [943]], [[8156, 8156], "disallowed"], [[8157, 8157], "disallowed_STD3_mapped", [32, 788, 768]], [[8158, 8158], "disallowed_STD3_mapped", [32, 788, 769]], [[8159, 8159], "disallowed_STD3_mapped", [32, 788, 834]], [[8160, 8162], "valid"], [[8163, 8163], "mapped", [944]], [[8164, 8167], "valid"], [[8168, 8168], "mapped", [8160]], [[8169, 8169], "mapped", [8161]], [[8170, 8170], "mapped", [8058]], [[8171, 8171], "mapped", [973]], [[8172, 8172], "mapped", [8165]], [[8173, 8173], "disallowed_STD3_mapped", [32, 776, 768]], [[8174, 8174], "disallowed_STD3_mapped", [32, 776, 769]], [[8175, 8175], "disallowed_STD3_mapped", [96]], [[8176, 8177], "disallowed"], [[8178, 8178], "mapped", [8060, 953]], [[8179, 8179], "mapped", [969, 953]], [[8180, 8180], "mapped", [974, 953]], [[8181, 8181], "disallowed"], [[8182, 8182], "valid"], [[8183, 8183], "mapped", [8182, 953]], [[8184, 8184], "mapped", [8056]], [[8185, 8185], "mapped", [972]], [[8186, 8186], "mapped", [8060]], [[8187, 8187], "mapped", [974]], [[8188, 8188], "mapped", [969, 953]], [[8189, 8189], "disallowed_STD3_mapped", [32, 769]], [[8190, 8190], "disallowed_STD3_mapped", [32, 788]], [[8191, 8191], "disallowed"], [[8192, 8202], "disallowed_STD3_mapped", [32]], [[8203, 8203], "ignored"], [[8204, 8205], "deviation", []], [[8206, 8207], "disallowed"], [[8208, 8208], "valid", [], "NV8"], [[8209, 8209], "mapped", [8208]], [[8210, 8214], "valid", [], "NV8"], [[8215, 8215], "disallowed_STD3_mapped", [32, 819]], [[8216, 8227], "valid", [], "NV8"], [[8228, 8230], "disallowed"], [[8231, 8231], "valid", [], "NV8"], [[8232, 8238], "disallowed"], [[8239, 8239], "disallowed_STD3_mapped", [32]], [[8240, 8242], "valid", [], "NV8"], [[8243, 8243], "mapped", [8242, 8242]], [[8244, 8244], "mapped", [8242, 8242, 8242]], [[8245, 8245], "valid", [], "NV8"], [[8246, 8246], "mapped", [8245, 8245]], [[8247, 8247], "mapped", [8245, 8245, 8245]], [[8248, 8251], "valid", [], "NV8"], [[8252, 8252], "disallowed_STD3_mapped", [33, 33]], [[8253, 8253], "valid", [], "NV8"], [[8254, 8254], "disallowed_STD3_mapped", [32, 773]], [[8255, 8262], "valid", [], "NV8"], [[8263, 8263], "disallowed_STD3_mapped", [63, 63]], [[8264, 8264], "disallowed_STD3_mapped", [63, 33]], [[8265, 8265], "disallowed_STD3_mapped", [33, 63]], [[8266, 8269], "valid", [], "NV8"], [[8270, 8274], "valid", [], "NV8"], [[8275, 8276], "valid", [], "NV8"], [[8277, 8278], "valid", [], "NV8"], [[8279, 8279], "mapped", [8242, 8242, 8242, 8242]], [[8280, 8286], "valid", [], "NV8"], [[8287, 8287], "disallowed_STD3_mapped", [32]], [[8288, 8288], "ignored"], [[8289, 8291], "disallowed"], [[8292, 8292], "ignored"], [[8293, 8293], "disallowed"], [[8294, 8297], "disallowed"], [[8298, 8303], "disallowed"], [[8304, 8304], "mapped", [48]], [[8305, 8305], "mapped", [105]], [[8306, 8307], "disallowed"], [[8308, 8308], "mapped", [52]], [[8309, 8309], "mapped", [53]], [[8310, 8310], "mapped", [54]], [[8311, 8311], "mapped", [55]], [[8312, 8312], "mapped", [56]], [[8313, 8313], "mapped", [57]], [[8314, 8314], "disallowed_STD3_mapped", [43]], [[8315, 8315], "mapped", [8722]], [[8316, 8316], "disallowed_STD3_mapped", [61]], [[8317, 8317], "disallowed_STD3_mapped", [40]], [[8318, 8318], "disallowed_STD3_mapped", [41]], [[8319, 8319], "mapped", [110]], [[8320, 8320], "mapped", [48]], [[8321, 8321], "mapped", [49]], [[8322, 8322], "mapped", [50]], [[8323, 8323], "mapped", [51]], [[8324, 8324], "mapped", [52]], [[8325, 8325], "mapped", [53]], [[8326, 8326], "mapped", [54]], [[8327, 8327], "mapped", [55]], [[8328, 8328], "mapped", [56]], [[8329, 8329], "mapped", [57]], [[8330, 8330], "disallowed_STD3_mapped", [43]], [[8331, 8331], "mapped", [8722]], [[8332, 8332], "disallowed_STD3_mapped", [61]], [[8333, 8333], "disallowed_STD3_mapped", [40]], [[8334, 8334], "disallowed_STD3_mapped", [41]], [[8335, 8335], "disallowed"], [[8336, 8336], "mapped", [97]], [[8337, 8337], "mapped", [101]], [[8338, 8338], "mapped", [111]], [[8339, 8339], "mapped", [120]], [[8340, 8340], "mapped", [601]], [[8341, 8341], "mapped", [104]], [[8342, 8342], "mapped", [107]], [[8343, 8343], "mapped", [108]], [[8344, 8344], "mapped", [109]], [[8345, 8345], "mapped", [110]], [[8346, 8346], "mapped", [112]], [[8347, 8347], "mapped", [115]], [[8348, 8348], "mapped", [116]], [[8349, 8351], "disallowed"], [[8352, 8359], "valid", [], "NV8"], [[8360, 8360], "mapped", [114, 115]], [[8361, 8362], "valid", [], "NV8"], [[8363, 8363], "valid", [], "NV8"], [[8364, 8364], "valid", [], "NV8"], [[8365, 8367], "valid", [], "NV8"], [[8368, 8369], "valid", [], "NV8"], [[8370, 8373], "valid", [], "NV8"], [[8374, 8376], "valid", [], "NV8"], [[8377, 8377], "valid", [], "NV8"], [[8378, 8378], "valid", [], "NV8"], [[8379, 8381], "valid", [], "NV8"], [[8382, 8382], "valid", [], "NV8"], [[8383, 8399], "disallowed"], [[8400, 8417], "valid", [], "NV8"], [[8418, 8419], "valid", [], "NV8"], [[8420, 8426], "valid", [], "NV8"], [[8427, 8427], "valid", [], "NV8"], [[8428, 8431], "valid", [], "NV8"], [[8432, 8432], "valid", [], "NV8"], [[8433, 8447], "disallowed"], [[8448, 8448], "disallowed_STD3_mapped", [97, 47, 99]], [[8449, 8449], "disallowed_STD3_mapped", [97, 47, 115]], [[8450, 8450], "mapped", [99]], [[8451, 8451], "mapped", [176, 99]], [[8452, 8452], "valid", [], "NV8"], [[8453, 8453], "disallowed_STD3_mapped", [99, 47, 111]], [[8454, 8454], "disallowed_STD3_mapped", [99, 47, 117]], [[8455, 8455], "mapped", [603]], [[8456, 8456], "valid", [], "NV8"], [[8457, 8457], "mapped", [176, 102]], [[8458, 8458], "mapped", [103]], [[8459, 8462], "mapped", [104]], [[8463, 8463], "mapped", [295]], [[8464, 8465], "mapped", [105]], [[8466, 8467], "mapped", [108]], [[8468, 8468], "valid", [], "NV8"], [[8469, 8469], "mapped", [110]], [[8470, 8470], "mapped", [110, 111]], [[8471, 8472], "valid", [], "NV8"], [[8473, 8473], "mapped", [112]], [[8474, 8474], "mapped", [113]], [[8475, 8477], "mapped", [114]], [[8478, 8479], "valid", [], "NV8"], [[8480, 8480], "mapped", [115, 109]], [[8481, 8481], "mapped", [116, 101, 108]], [[8482, 8482], "mapped", [116, 109]], [[8483, 8483], "valid", [], "NV8"], [[8484, 8484], "mapped", [122]], [[8485, 8485], "valid", [], "NV8"], [[8486, 8486], "mapped", [969]], [[8487, 8487], "valid", [], "NV8"], [[8488, 8488], "mapped", [122]], [[8489, 8489], "valid", [], "NV8"], [[8490, 8490], "mapped", [107]], [[8491, 8491], "mapped", [229]], [[8492, 8492], "mapped", [98]], [[8493, 8493], "mapped", [99]], [[8494, 8494], "valid", [], "NV8"], [[8495, 8496], "mapped", [101]], [[8497, 8497], "mapped", [102]], [[8498, 8498], "disallowed"], [[8499, 8499], "mapped", [109]], [[8500, 8500], "mapped", [111]], [[8501, 8501], "mapped", [1488]], [[8502, 8502], "mapped", [1489]], [[8503, 8503], "mapped", [1490]], [[8504, 8504], "mapped", [1491]], [[8505, 8505], "mapped", [105]], [[8506, 8506], "valid", [], "NV8"], [[8507, 8507], "mapped", [102, 97, 120]], [[8508, 8508], "mapped", [960]], [[8509, 8510], "mapped", [947]], [[8511, 8511], "mapped", [960]], [[8512, 8512], "mapped", [8721]], [[8513, 8516], "valid", [], "NV8"], [[8517, 8518], "mapped", [100]], [[8519, 8519], "mapped", [101]], [[8520, 8520], "mapped", [105]], [[8521, 8521], "mapped", [106]], [[8522, 8523], "valid", [], "NV8"], [[8524, 8524], "valid", [], "NV8"], [[8525, 8525], "valid", [], "NV8"], [[8526, 8526], "valid"], [[8527, 8527], "valid", [], "NV8"], [[8528, 8528], "mapped", [49, 8260, 55]], [[8529, 8529], "mapped", [49, 8260, 57]], [[8530, 8530], "mapped", [49, 8260, 49, 48]], [[8531, 8531], "mapped", [49, 8260, 51]], [[8532, 8532], "mapped", [50, 8260, 51]], [[8533, 8533], "mapped", [49, 8260, 53]], [[8534, 8534], "mapped", [50, 8260, 53]], [[8535, 8535], "mapped", [51, 8260, 53]], [[8536, 8536], "mapped", [52, 8260, 53]], [[8537, 8537], "mapped", [49, 8260, 54]], [[8538, 8538], "mapped", [53, 8260, 54]], [[8539, 8539], "mapped", [49, 8260, 56]], [[8540, 8540], "mapped", [51, 8260, 56]], [[8541, 8541], "mapped", [53, 8260, 56]], [[8542, 8542], "mapped", [55, 8260, 56]], [[8543, 8543], "mapped", [49, 8260]], [[8544, 8544], "mapped", [105]], [[8545, 8545], "mapped", [105, 105]], [[8546, 8546], "mapped", [105, 105, 105]], [[8547, 8547], "mapped", [105, 118]], [[8548, 8548], "mapped", [118]], [[8549, 8549], "mapped", [118, 105]], [[8550, 8550], "mapped", [118, 105, 105]], [[8551, 8551], "mapped", [118, 105, 105, 105]], [[8552, 8552], "mapped", [105, 120]], [[8553, 8553], "mapped", [120]], [[8554, 8554], "mapped", [120, 105]], [[8555, 8555], "mapped", [120, 105, 105]], [[8556, 8556], "mapped", [108]], [[8557, 8557], "mapped", [99]], [[8558, 8558], "mapped", [100]], [[8559, 8559], "mapped", [109]], [[8560, 8560], "mapped", [105]], [[8561, 8561], "mapped", [105, 105]], [[8562, 8562], "mapped", [105, 105, 105]], [[8563, 8563], "mapped", [105, 118]], [[8564, 8564], "mapped", [118]], [[8565, 8565], "mapped", [118, 105]], [[8566, 8566], "mapped", [118, 105, 105]], [[8567, 8567], "mapped", [118, 105, 105, 105]], [[8568, 8568], "mapped", [105, 120]], [[8569, 8569], "mapped", [120]], [[8570, 8570], "mapped", [120, 105]], [[8571, 8571], "mapped", [120, 105, 105]], [[8572, 8572], "mapped", [108]], [[8573, 8573], "mapped", [99]], [[8574, 8574], "mapped", [100]], [[8575, 8575], "mapped", [109]], [[8576, 8578], "valid", [], "NV8"], [[8579, 8579], "disallowed"], [[8580, 8580], "valid"], [[8581, 8584], "valid", [], "NV8"], [[8585, 8585], "mapped", [48, 8260, 51]], [[8586, 8587], "valid", [], "NV8"], [[8588, 8591], "disallowed"], [[8592, 8682], "valid", [], "NV8"], [[8683, 8691], "valid", [], "NV8"], [[8692, 8703], "valid", [], "NV8"], [[8704, 8747], "valid", [], "NV8"], [[8748, 8748], "mapped", [8747, 8747]], [[8749, 8749], "mapped", [8747, 8747, 8747]], [[8750, 8750], "valid", [], "NV8"], [[8751, 8751], "mapped", [8750, 8750]], [[8752, 8752], "mapped", [8750, 8750, 8750]], [[8753, 8799], "valid", [], "NV8"], [[8800, 8800], "disallowed_STD3_valid"], [[8801, 8813], "valid", [], "NV8"], [[8814, 8815], "disallowed_STD3_valid"], [[8816, 8945], "valid", [], "NV8"], [[8946, 8959], "valid", [], "NV8"], [[8960, 8960], "valid", [], "NV8"], [[8961, 8961], "valid", [], "NV8"], [[8962, 9e3], "valid", [], "NV8"], [[9001, 9001], "mapped", [12296]], [[9002, 9002], "mapped", [12297]], [[9003, 9082], "valid", [], "NV8"], [[9083, 9083], "valid", [], "NV8"], [[9084, 9084], "valid", [], "NV8"], [[9085, 9114], "valid", [], "NV8"], [[9115, 9166], "valid", [], "NV8"], [[9167, 9168], "valid", [], "NV8"], [[9169, 9179], "valid", [], "NV8"], [[9180, 9191], "valid", [], "NV8"], [[9192, 9192], "valid", [], "NV8"], [[9193, 9203], "valid", [], "NV8"], [[9204, 9210], "valid", [], "NV8"], [[9211, 9215], "disallowed"], [[9216, 9252], "valid", [], "NV8"], [[9253, 9254], "valid", [], "NV8"], [[9255, 9279], "disallowed"], [[9280, 9290], "valid", [], "NV8"], [[9291, 9311], "disallowed"], [[9312, 9312], "mapped", [49]], [[9313, 9313], "mapped", [50]], [[9314, 9314], "mapped", [51]], [[9315, 9315], "mapped", [52]], [[9316, 9316], "mapped", [53]], [[9317, 9317], "mapped", [54]], [[9318, 9318], "mapped", [55]], [[9319, 9319], "mapped", [56]], [[9320, 9320], "mapped", [57]], [[9321, 9321], "mapped", [49, 48]], [[9322, 9322], "mapped", [49, 49]], [[9323, 9323], "mapped", [49, 50]], [[9324, 9324], "mapped", [49, 51]], [[9325, 9325], "mapped", [49, 52]], [[9326, 9326], "mapped", [49, 53]], [[9327, 9327], "mapped", [49, 54]], [[9328, 9328], "mapped", [49, 55]], [[9329, 9329], "mapped", [49, 56]], [[9330, 9330], "mapped", [49, 57]], [[9331, 9331], "mapped", [50, 48]], [[9332, 9332], "disallowed_STD3_mapped", [40, 49, 41]], [[9333, 9333], "disallowed_STD3_mapped", [40, 50, 41]], [[9334, 9334], "disallowed_STD3_mapped", [40, 51, 41]], [[9335, 9335], "disallowed_STD3_mapped", [40, 52, 41]], [[9336, 9336], "disallowed_STD3_mapped", [40, 53, 41]], [[9337, 9337], "disallowed_STD3_mapped", [40, 54, 41]], [[9338, 9338], "disallowed_STD3_mapped", [40, 55, 41]], [[9339, 9339], "disallowed_STD3_mapped", [40, 56, 41]], [[9340, 9340], "disallowed_STD3_mapped", [40, 57, 41]], [[9341, 9341], "disallowed_STD3_mapped", [40, 49, 48, 41]], [[9342, 9342], "disallowed_STD3_mapped", [40, 49, 49, 41]], [[9343, 9343], "disallowed_STD3_mapped", [40, 49, 50, 41]], [[9344, 9344], "disallowed_STD3_mapped", [40, 49, 51, 41]], [[9345, 9345], "disallowed_STD3_mapped", [40, 49, 52, 41]], [[9346, 9346], "disallowed_STD3_mapped", [40, 49, 53, 41]], [[9347, 9347], "disallowed_STD3_mapped", [40, 49, 54, 41]], [[9348, 9348], "disallowed_STD3_mapped", [40, 49, 55, 41]], [[9349, 9349], "disallowed_STD3_mapped", [40, 49, 56, 41]], [[9350, 9350], "disallowed_STD3_mapped", [40, 49, 57, 41]], [[9351, 9351], "disallowed_STD3_mapped", [40, 50, 48, 41]], [[9352, 9371], "disallowed"], [[9372, 9372], "disallowed_STD3_mapped", [40, 97, 41]], [[9373, 9373], "disallowed_STD3_mapped", [40, 98, 41]], [[9374, 9374], "disallowed_STD3_mapped", [40, 99, 41]], [[9375, 9375], "disallowed_STD3_mapped", [40, 100, 41]], [[9376, 9376], "disallowed_STD3_mapped", [40, 101, 41]], [[9377, 9377], "disallowed_STD3_mapped", [40, 102, 41]], [[9378, 9378], "disallowed_STD3_mapped", [40, 103, 41]], [[9379, 9379], "disallowed_STD3_mapped", [40, 104, 41]], [[9380, 9380], "disallowed_STD3_mapped", [40, 105, 41]], [[9381, 9381], "disallowed_STD3_mapped", [40, 106, 41]], [[9382, 9382], "disallowed_STD3_mapped", [40, 107, 41]], [[9383, 9383], "disallowed_STD3_mapped", [40, 108, 41]], [[9384, 9384], "disallowed_STD3_mapped", [40, 109, 41]], [[9385, 9385], "disallowed_STD3_mapped", [40, 110, 41]], [[9386, 9386], "disallowed_STD3_mapped", [40, 111, 41]], [[9387, 9387], "disallowed_STD3_mapped", [40, 112, 41]], [[9388, 9388], "disallowed_STD3_mapped", [40, 113, 41]], [[9389, 9389], "disallowed_STD3_mapped", [40, 114, 41]], [[9390, 9390], "disallowed_STD3_mapped", [40, 115, 41]], [[9391, 9391], "disallowed_STD3_mapped", [40, 116, 41]], [[9392, 9392], "disallowed_STD3_mapped", [40, 117, 41]], [[9393, 9393], "disallowed_STD3_mapped", [40, 118, 41]], [[9394, 9394], "disallowed_STD3_mapped", [40, 119, 41]], [[9395, 9395], "disallowed_STD3_mapped", [40, 120, 41]], [[9396, 9396], "disallowed_STD3_mapped", [40, 121, 41]], [[9397, 9397], "disallowed_STD3_mapped", [40, 122, 41]], [[9398, 9398], "mapped", [97]], [[9399, 9399], "mapped", [98]], [[9400, 9400], "mapped", [99]], [[9401, 9401], "mapped", [100]], [[9402, 9402], "mapped", [101]], [[9403, 9403], "mapped", [102]], [[9404, 9404], "mapped", [103]], [[9405, 9405], "mapped", [104]], [[9406, 9406], "mapped", [105]], [[9407, 9407], "mapped", [106]], [[9408, 9408], "mapped", [107]], [[9409, 9409], "mapped", [108]], [[9410, 9410], "mapped", [109]], [[9411, 9411], "mapped", [110]], [[9412, 9412], "mapped", [111]], [[9413, 9413], "mapped", [112]], [[9414, 9414], "mapped", [113]], [[9415, 9415], "mapped", [114]], [[9416, 9416], "mapped", [115]], [[9417, 9417], "mapped", [116]], [[9418, 9418], "mapped", [117]], [[9419, 9419], "mapped", [118]], [[9420, 9420], "mapped", [119]], [[9421, 9421], "mapped", [120]], [[9422, 9422], "mapped", [121]], [[9423, 9423], "mapped", [122]], [[9424, 9424], "mapped", [97]], [[9425, 9425], "mapped", [98]], [[9426, 9426], "mapped", [99]], [[9427, 9427], "mapped", [100]], [[9428, 9428], "mapped", [101]], [[9429, 9429], "mapped", [102]], [[9430, 9430], "mapped", [103]], [[9431, 9431], "mapped", [104]], [[9432, 9432], "mapped", [105]], [[9433, 9433], "mapped", [106]], [[9434, 9434], "mapped", [107]], [[9435, 9435], "mapped", [108]], [[9436, 9436], "mapped", [109]], [[9437, 9437], "mapped", [110]], [[9438, 9438], "mapped", [111]], [[9439, 9439], "mapped", [112]], [[9440, 9440], "mapped", [113]], [[9441, 9441], "mapped", [114]], [[9442, 9442], "mapped", [115]], [[9443, 9443], "mapped", [116]], [[9444, 9444], "mapped", [117]], [[9445, 9445], "mapped", [118]], [[9446, 9446], "mapped", [119]], [[9447, 9447], "mapped", [120]], [[9448, 9448], "mapped", [121]], [[9449, 9449], "mapped", [122]], [[9450, 9450], "mapped", [48]], [[9451, 9470], "valid", [], "NV8"], [[9471, 9471], "valid", [], "NV8"], [[9472, 9621], "valid", [], "NV8"], [[9622, 9631], "valid", [], "NV8"], [[9632, 9711], "valid", [], "NV8"], [[9712, 9719], "valid", [], "NV8"], [[9720, 9727], "valid", [], "NV8"], [[9728, 9747], "valid", [], "NV8"], [[9748, 9749], "valid", [], "NV8"], [[9750, 9751], "valid", [], "NV8"], [[9752, 9752], "valid", [], "NV8"], [[9753, 9753], "valid", [], "NV8"], [[9754, 9839], "valid", [], "NV8"], [[9840, 9841], "valid", [], "NV8"], [[9842, 9853], "valid", [], "NV8"], [[9854, 9855], "valid", [], "NV8"], [[9856, 9865], "valid", [], "NV8"], [[9866, 9873], "valid", [], "NV8"], [[9874, 9884], "valid", [], "NV8"], [[9885, 9885], "valid", [], "NV8"], [[9886, 9887], "valid", [], "NV8"], [[9888, 9889], "valid", [], "NV8"], [[9890, 9905], "valid", [], "NV8"], [[9906, 9906], "valid", [], "NV8"], [[9907, 9916], "valid", [], "NV8"], [[9917, 9919], "valid", [], "NV8"], [[9920, 9923], "valid", [], "NV8"], [[9924, 9933], "valid", [], "NV8"], [[9934, 9934], "valid", [], "NV8"], [[9935, 9953], "valid", [], "NV8"], [[9954, 9954], "valid", [], "NV8"], [[9955, 9955], "valid", [], "NV8"], [[9956, 9959], "valid", [], "NV8"], [[9960, 9983], "valid", [], "NV8"], [[9984, 9984], "valid", [], "NV8"], [[9985, 9988], "valid", [], "NV8"], [[9989, 9989], "valid", [], "NV8"], [[9990, 9993], "valid", [], "NV8"], [[9994, 9995], "valid", [], "NV8"], [[9996, 10023], "valid", [], "NV8"], [[10024, 10024], "valid", [], "NV8"], [[10025, 10059], "valid", [], "NV8"], [[10060, 10060], "valid", [], "NV8"], [[10061, 10061], "valid", [], "NV8"], [[10062, 10062], "valid", [], "NV8"], [[10063, 10066], "valid", [], "NV8"], [[10067, 10069], "valid", [], "NV8"], [[10070, 10070], "valid", [], "NV8"], [[10071, 10071], "valid", [], "NV8"], [[10072, 10078], "valid", [], "NV8"], [[10079, 10080], "valid", [], "NV8"], [[10081, 10087], "valid", [], "NV8"], [[10088, 10101], "valid", [], "NV8"], [[10102, 10132], "valid", [], "NV8"], [[10133, 10135], "valid", [], "NV8"], [[10136, 10159], "valid", [], "NV8"], [[10160, 10160], "valid", [], "NV8"], [[10161, 10174], "valid", [], "NV8"], [[10175, 10175], "valid", [], "NV8"], [[10176, 10182], "valid", [], "NV8"], [[10183, 10186], "valid", [], "NV8"], [[10187, 10187], "valid", [], "NV8"], [[10188, 10188], "valid", [], "NV8"], [[10189, 10189], "valid", [], "NV8"], [[10190, 10191], "valid", [], "NV8"], [[10192, 10219], "valid", [], "NV8"], [[10220, 10223], "valid", [], "NV8"], [[10224, 10239], "valid", [], "NV8"], [[10240, 10495], "valid", [], "NV8"], [[10496, 10763], "valid", [], "NV8"], [[10764, 10764], "mapped", [8747, 8747, 8747, 8747]], [[10765, 10867], "valid", [], "NV8"], [[10868, 10868], "disallowed_STD3_mapped", [58, 58, 61]], [[10869, 10869], "disallowed_STD3_mapped", [61, 61]], [[10870, 10870], "disallowed_STD3_mapped", [61, 61, 61]], [[10871, 10971], "valid", [], "NV8"], [[10972, 10972], "mapped", [10973, 824]], [[10973, 11007], "valid", [], "NV8"], [[11008, 11021], "valid", [], "NV8"], [[11022, 11027], "valid", [], "NV8"], [[11028, 11034], "valid", [], "NV8"], [[11035, 11039], "valid", [], "NV8"], [[11040, 11043], "valid", [], "NV8"], [[11044, 11084], "valid", [], "NV8"], [[11085, 11087], "valid", [], "NV8"], [[11088, 11092], "valid", [], "NV8"], [[11093, 11097], "valid", [], "NV8"], [[11098, 11123], "valid", [], "NV8"], [[11124, 11125], "disallowed"], [[11126, 11157], "valid", [], "NV8"], [[11158, 11159], "disallowed"], [[11160, 11193], "valid", [], "NV8"], [[11194, 11196], "disallowed"], [[11197, 11208], "valid", [], "NV8"], [[11209, 11209], "disallowed"], [[11210, 11217], "valid", [], "NV8"], [[11218, 11243], "disallowed"], [[11244, 11247], "valid", [], "NV8"], [[11248, 11263], "disallowed"], [[11264, 11264], "mapped", [11312]], [[11265, 11265], "mapped", [11313]], [[11266, 11266], "mapped", [11314]], [[11267, 11267], "mapped", [11315]], [[11268, 11268], "mapped", [11316]], [[11269, 11269], "mapped", [11317]], [[11270, 11270], "mapped", [11318]], [[11271, 11271], "mapped", [11319]], [[11272, 11272], "mapped", [11320]], [[11273, 11273], "mapped", [11321]], [[11274, 11274], "mapped", [11322]], [[11275, 11275], "mapped", [11323]], [[11276, 11276], "mapped", [11324]], [[11277, 11277], "mapped", [11325]], [[11278, 11278], "mapped", [11326]], [[11279, 11279], "mapped", [11327]], [[11280, 11280], "mapped", [11328]], [[11281, 11281], "mapped", [11329]], [[11282, 11282], "mapped", [11330]], [[11283, 11283], "mapped", [11331]], [[11284, 11284], "mapped", [11332]], [[11285, 11285], "mapped", [11333]], [[11286, 11286], "mapped", [11334]], [[11287, 11287], "mapped", [11335]], [[11288, 11288], "mapped", [11336]], [[11289, 11289], "mapped", [11337]], [[11290, 11290], "mapped", [11338]], [[11291, 11291], "mapped", [11339]], [[11292, 11292], "mapped", [11340]], [[11293, 11293], "mapped", [11341]], [[11294, 11294], "mapped", [11342]], [[11295, 11295], "mapped", [11343]], [[11296, 11296], "mapped", [11344]], [[11297, 11297], "mapped", [11345]], [[11298, 11298], "mapped", [11346]], [[11299, 11299], "mapped", [11347]], [[11300, 11300], "mapped", [11348]], [[11301, 11301], "mapped", [11349]], [[11302, 11302], "mapped", [11350]], [[11303, 11303], "mapped", [11351]], [[11304, 11304], "mapped", [11352]], [[11305, 11305], "mapped", [11353]], [[11306, 11306], "mapped", [11354]], [[11307, 11307], "mapped", [11355]], [[11308, 11308], "mapped", [11356]], [[11309, 11309], "mapped", [11357]], [[11310, 11310], "mapped", [11358]], [[11311, 11311], "disallowed"], [[11312, 11358], "valid"], [[11359, 11359], "disallowed"], [[11360, 11360], "mapped", [11361]], [[11361, 11361], "valid"], [[11362, 11362], "mapped", [619]], [[11363, 11363], "mapped", [7549]], [[11364, 11364], "mapped", [637]], [[11365, 11366], "valid"], [[11367, 11367], "mapped", [11368]], [[11368, 11368], "valid"], [[11369, 11369], "mapped", [11370]], [[11370, 11370], "valid"], [[11371, 11371], "mapped", [11372]], [[11372, 11372], "valid"], [[11373, 11373], "mapped", [593]], [[11374, 11374], "mapped", [625]], [[11375, 11375], "mapped", [592]], [[11376, 11376], "mapped", [594]], [[11377, 11377], "valid"], [[11378, 11378], "mapped", [11379]], [[11379, 11379], "valid"], [[11380, 11380], "valid"], [[11381, 11381], "mapped", [11382]], [[11382, 11383], "valid"], [[11384, 11387], "valid"], [[11388, 11388], "mapped", [106]], [[11389, 11389], "mapped", [118]], [[11390, 11390], "mapped", [575]], [[11391, 11391], "mapped", [576]], [[11392, 11392], "mapped", [11393]], [[11393, 11393], "valid"], [[11394, 11394], "mapped", [11395]], [[11395, 11395], "valid"], [[11396, 11396], "mapped", [11397]], [[11397, 11397], "valid"], [[11398, 11398], "mapped", [11399]], [[11399, 11399], "valid"], [[11400, 11400], "mapped", [11401]], [[11401, 11401], "valid"], [[11402, 11402], "mapped", [11403]], [[11403, 11403], "valid"], [[11404, 11404], "mapped", [11405]], [[11405, 11405], "valid"], [[11406, 11406], "mapped", [11407]], [[11407, 11407], "valid"], [[11408, 11408], "mapped", [11409]], [[11409, 11409], "valid"], [[11410, 11410], "mapped", [11411]], [[11411, 11411], "valid"], [[11412, 11412], "mapped", [11413]], [[11413, 11413], "valid"], [[11414, 11414], "mapped", [11415]], [[11415, 11415], "valid"], [[11416, 11416], "mapped", [11417]], [[11417, 11417], "valid"], [[11418, 11418], "mapped", [11419]], [[11419, 11419], "valid"], [[11420, 11420], "mapped", [11421]], [[11421, 11421], "valid"], [[11422, 11422], "mapped", [11423]], [[11423, 11423], "valid"], [[11424, 11424], "mapped", [11425]], [[11425, 11425], "valid"], [[11426, 11426], "mapped", [11427]], [[11427, 11427], "valid"], [[11428, 11428], "mapped", [11429]], [[11429, 11429], "valid"], [[11430, 11430], "mapped", [11431]], [[11431, 11431], "valid"], [[11432, 11432], "mapped", [11433]], [[11433, 11433], "valid"], [[11434, 11434], "mapped", [11435]], [[11435, 11435], "valid"], [[11436, 11436], "mapped", [11437]], [[11437, 11437], "valid"], [[11438, 11438], "mapped", [11439]], [[11439, 11439], "valid"], [[11440, 11440], "mapped", [11441]], [[11441, 11441], "valid"], [[11442, 11442], "mapped", [11443]], [[11443, 11443], "valid"], [[11444, 11444], "mapped", [11445]], [[11445, 11445], "valid"], [[11446, 11446], "mapped", [11447]], [[11447, 11447], "valid"], [[11448, 11448], "mapped", [11449]], [[11449, 11449], "valid"], [[11450, 11450], "mapped", [11451]], [[11451, 11451], "valid"], [[11452, 11452], "mapped", [11453]], [[11453, 11453], "valid"], [[11454, 11454], "mapped", [11455]], [[11455, 11455], "valid"], [[11456, 11456], "mapped", [11457]], [[11457, 11457], "valid"], [[11458, 11458], "mapped", [11459]], [[11459, 11459], "valid"], [[11460, 11460], "mapped", [11461]], [[11461, 11461], "valid"], [[11462, 11462], "mapped", [11463]], [[11463, 11463], "valid"], [[11464, 11464], "mapped", [11465]], [[11465, 11465], "valid"], [[11466, 11466], "mapped", [11467]], [[11467, 11467], "valid"], [[11468, 11468], "mapped", [11469]], [[11469, 11469], "valid"], [[11470, 11470], "mapped", [11471]], [[11471, 11471], "valid"], [[11472, 11472], "mapped", [11473]], [[11473, 11473], "valid"], [[11474, 11474], "mapped", [11475]], [[11475, 11475], "valid"], [[11476, 11476], "mapped", [11477]], [[11477, 11477], "valid"], [[11478, 11478], "mapped", [11479]], [[11479, 11479], "valid"], [[11480, 11480], "mapped", [11481]], [[11481, 11481], "valid"], [[11482, 11482], "mapped", [11483]], [[11483, 11483], "valid"], [[11484, 11484], "mapped", [11485]], [[11485, 11485], "valid"], [[11486, 11486], "mapped", [11487]], [[11487, 11487], "valid"], [[11488, 11488], "mapped", [11489]], [[11489, 11489], "valid"], [[11490, 11490], "mapped", [11491]], [[11491, 11492], "valid"], [[11493, 11498], "valid", [], "NV8"], [[11499, 11499], "mapped", [11500]], [[11500, 11500], "valid"], [[11501, 11501], "mapped", [11502]], [[11502, 11505], "valid"], [[11506, 11506], "mapped", [11507]], [[11507, 11507], "valid"], [[11508, 11512], "disallowed"], [[11513, 11519], "valid", [], "NV8"], [[11520, 11557], "valid"], [[11558, 11558], "disallowed"], [[11559, 11559], "valid"], [[11560, 11564], "disallowed"], [[11565, 11565], "valid"], [[11566, 11567], "disallowed"], [[11568, 11621], "valid"], [[11622, 11623], "valid"], [[11624, 11630], "disallowed"], [[11631, 11631], "mapped", [11617]], [[11632, 11632], "valid", [], "NV8"], [[11633, 11646], "disallowed"], [[11647, 11647], "valid"], [[11648, 11670], "valid"], [[11671, 11679], "disallowed"], [[11680, 11686], "valid"], [[11687, 11687], "disallowed"], [[11688, 11694], "valid"], [[11695, 11695], "disallowed"], [[11696, 11702], "valid"], [[11703, 11703], "disallowed"], [[11704, 11710], "valid"], [[11711, 11711], "disallowed"], [[11712, 11718], "valid"], [[11719, 11719], "disallowed"], [[11720, 11726], "valid"], [[11727, 11727], "disallowed"], [[11728, 11734], "valid"], [[11735, 11735], "disallowed"], [[11736, 11742], "valid"], [[11743, 11743], "disallowed"], [[11744, 11775], "valid"], [[11776, 11799], "valid", [], "NV8"], [[11800, 11803], "valid", [], "NV8"], [[11804, 11805], "valid", [], "NV8"], [[11806, 11822], "valid", [], "NV8"], [[11823, 11823], "valid"], [[11824, 11824], "valid", [], "NV8"], [[11825, 11825], "valid", [], "NV8"], [[11826, 11835], "valid", [], "NV8"], [[11836, 11842], "valid", [], "NV8"], [[11843, 11903], "disallowed"], [[11904, 11929], "valid", [], "NV8"], [[11930, 11930], "disallowed"], [[11931, 11934], "valid", [], "NV8"], [[11935, 11935], "mapped", [27597]], [[11936, 12018], "valid", [], "NV8"], [[12019, 12019], "mapped", [40863]], [[12020, 12031], "disallowed"], [[12032, 12032], "mapped", [19968]], [[12033, 12033], "mapped", [20008]], [[12034, 12034], "mapped", [20022]], [[12035, 12035], "mapped", [20031]], [[12036, 12036], "mapped", [20057]], [[12037, 12037], "mapped", [20101]], [[12038, 12038], "mapped", [20108]], [[12039, 12039], "mapped", [20128]], [[12040, 12040], "mapped", [20154]], [[12041, 12041], "mapped", [20799]], [[12042, 12042], "mapped", [20837]], [[12043, 12043], "mapped", [20843]], [[12044, 12044], "mapped", [20866]], [[12045, 12045], "mapped", [20886]], [[12046, 12046], "mapped", [20907]], [[12047, 12047], "mapped", [20960]], [[12048, 12048], "mapped", [20981]], [[12049, 12049], "mapped", [20992]], [[12050, 12050], "mapped", [21147]], [[12051, 12051], "mapped", [21241]], [[12052, 12052], "mapped", [21269]], [[12053, 12053], "mapped", [21274]], [[12054, 12054], "mapped", [21304]], [[12055, 12055], "mapped", [21313]], [[12056, 12056], "mapped", [21340]], [[12057, 12057], "mapped", [21353]], [[12058, 12058], "mapped", [21378]], [[12059, 12059], "mapped", [21430]], [[12060, 12060], "mapped", [21448]], [[12061, 12061], "mapped", [21475]], [[12062, 12062], "mapped", [22231]], [[12063, 12063], "mapped", [22303]], [[12064, 12064], "mapped", [22763]], [[12065, 12065], "mapped", [22786]], [[12066, 12066], "mapped", [22794]], [[12067, 12067], "mapped", [22805]], [[12068, 12068], "mapped", [22823]], [[12069, 12069], "mapped", [22899]], [[12070, 12070], "mapped", [23376]], [[12071, 12071], "mapped", [23424]], [[12072, 12072], "mapped", [23544]], [[12073, 12073], "mapped", [23567]], [[12074, 12074], "mapped", [23586]], [[12075, 12075], "mapped", [23608]], [[12076, 12076], "mapped", [23662]], [[12077, 12077], "mapped", [23665]], [[12078, 12078], "mapped", [24027]], [[12079, 12079], "mapped", [24037]], [[12080, 12080], "mapped", [24049]], [[12081, 12081], "mapped", [24062]], [[12082, 12082], "mapped", [24178]], [[12083, 12083], "mapped", [24186]], [[12084, 12084], "mapped", [24191]], [[12085, 12085], "mapped", [24308]], [[12086, 12086], "mapped", [24318]], [[12087, 12087], "mapped", [24331]], [[12088, 12088], "mapped", [24339]], [[12089, 12089], "mapped", [24400]], [[12090, 12090], "mapped", [24417]], [[12091, 12091], "mapped", [24435]], [[12092, 12092], "mapped", [24515]], [[12093, 12093], "mapped", [25096]], [[12094, 12094], "mapped", [25142]], [[12095, 12095], "mapped", [25163]], [[12096, 12096], "mapped", [25903]], [[12097, 12097], "mapped", [25908]], [[12098, 12098], "mapped", [25991]], [[12099, 12099], "mapped", [26007]], [[12100, 12100], "mapped", [26020]], [[12101, 12101], "mapped", [26041]], [[12102, 12102], "mapped", [26080]], [[12103, 12103], "mapped", [26085]], [[12104, 12104], "mapped", [26352]], [[12105, 12105], "mapped", [26376]], [[12106, 12106], "mapped", [26408]], [[12107, 12107], "mapped", [27424]], [[12108, 12108], "mapped", [27490]], [[12109, 12109], "mapped", [27513]], [[12110, 12110], "mapped", [27571]], [[12111, 12111], "mapped", [27595]], [[12112, 12112], "mapped", [27604]], [[12113, 12113], "mapped", [27611]], [[12114, 12114], "mapped", [27663]], [[12115, 12115], "mapped", [27668]], [[12116, 12116], "mapped", [27700]], [[12117, 12117], "mapped", [28779]], [[12118, 12118], "mapped", [29226]], [[12119, 12119], "mapped", [29238]], [[12120, 12120], "mapped", [29243]], [[12121, 12121], "mapped", [29247]], [[12122, 12122], "mapped", [29255]], [[12123, 12123], "mapped", [29273]], [[12124, 12124], "mapped", [29275]], [[12125, 12125], "mapped", [29356]], [[12126, 12126], "mapped", [29572]], [[12127, 12127], "mapped", [29577]], [[12128, 12128], "mapped", [29916]], [[12129, 12129], "mapped", [29926]], [[12130, 12130], "mapped", [29976]], [[12131, 12131], "mapped", [29983]], [[12132, 12132], "mapped", [29992]], [[12133, 12133], "mapped", [3e4]], [[12134, 12134], "mapped", [30091]], [[12135, 12135], "mapped", [30098]], [[12136, 12136], "mapped", [30326]], [[12137, 12137], "mapped", [30333]], [[12138, 12138], "mapped", [30382]], [[12139, 12139], "mapped", [30399]], [[12140, 12140], "mapped", [30446]], [[12141, 12141], "mapped", [30683]], [[12142, 12142], "mapped", [30690]], [[12143, 12143], "mapped", [30707]], [[12144, 12144], "mapped", [31034]], [[12145, 12145], "mapped", [31160]], [[12146, 12146], "mapped", [31166]], [[12147, 12147], "mapped", [31348]], [[12148, 12148], "mapped", [31435]], [[12149, 12149], "mapped", [31481]], [[12150, 12150], "mapped", [31859]], [[12151, 12151], "mapped", [31992]], [[12152, 12152], "mapped", [32566]], [[12153, 12153], "mapped", [32593]], [[12154, 12154], "mapped", [32650]], [[12155, 12155], "mapped", [32701]], [[12156, 12156], "mapped", [32769]], [[12157, 12157], "mapped", [32780]], [[12158, 12158], "mapped", [32786]], [[12159, 12159], "mapped", [32819]], [[12160, 12160], "mapped", [32895]], [[12161, 12161], "mapped", [32905]], [[12162, 12162], "mapped", [33251]], [[12163, 12163], "mapped", [33258]], [[12164, 12164], "mapped", [33267]], [[12165, 12165], "mapped", [33276]], [[12166, 12166], "mapped", [33292]], [[12167, 12167], "mapped", [33307]], [[12168, 12168], "mapped", [33311]], [[12169, 12169], "mapped", [33390]], [[12170, 12170], "mapped", [33394]], [[12171, 12171], "mapped", [33400]], [[12172, 12172], "mapped", [34381]], [[12173, 12173], "mapped", [34411]], [[12174, 12174], "mapped", [34880]], [[12175, 12175], "mapped", [34892]], [[12176, 12176], "mapped", [34915]], [[12177, 12177], "mapped", [35198]], [[12178, 12178], "mapped", [35211]], [[12179, 12179], "mapped", [35282]], [[12180, 12180], "mapped", [35328]], [[12181, 12181], "mapped", [35895]], [[12182, 12182], "mapped", [35910]], [[12183, 12183], "mapped", [35925]], [[12184, 12184], "mapped", [35960]], [[12185, 12185], "mapped", [35997]], [[12186, 12186], "mapped", [36196]], [[12187, 12187], "mapped", [36208]], [[12188, 12188], "mapped", [36275]], [[12189, 12189], "mapped", [36523]], [[12190, 12190], "mapped", [36554]], [[12191, 12191], "mapped", [36763]], [[12192, 12192], "mapped", [36784]], [[12193, 12193], "mapped", [36789]], [[12194, 12194], "mapped", [37009]], [[12195, 12195], "mapped", [37193]], [[12196, 12196], "mapped", [37318]], [[12197, 12197], "mapped", [37324]], [[12198, 12198], "mapped", [37329]], [[12199, 12199], "mapped", [38263]], [[12200, 12200], "mapped", [38272]], [[12201, 12201], "mapped", [38428]], [[12202, 12202], "mapped", [38582]], [[12203, 12203], "mapped", [38585]], [[12204, 12204], "mapped", [38632]], [[12205, 12205], "mapped", [38737]], [[12206, 12206], "mapped", [38750]], [[12207, 12207], "mapped", [38754]], [[12208, 12208], "mapped", [38761]], [[12209, 12209], "mapped", [38859]], [[12210, 12210], "mapped", [38893]], [[12211, 12211], "mapped", [38899]], [[12212, 12212], "mapped", [38913]], [[12213, 12213], "mapped", [39080]], [[12214, 12214], "mapped", [39131]], [[12215, 12215], "mapped", [39135]], [[12216, 12216], "mapped", [39318]], [[12217, 12217], "mapped", [39321]], [[12218, 12218], "mapped", [39340]], [[12219, 12219], "mapped", [39592]], [[12220, 12220], "mapped", [39640]], [[12221, 12221], "mapped", [39647]], [[12222, 12222], "mapped", [39717]], [[12223, 12223], "mapped", [39727]], [[12224, 12224], "mapped", [39730]], [[12225, 12225], "mapped", [39740]], [[12226, 12226], "mapped", [39770]], [[12227, 12227], "mapped", [40165]], [[12228, 12228], "mapped", [40565]], [[12229, 12229], "mapped", [40575]], [[12230, 12230], "mapped", [40613]], [[12231, 12231], "mapped", [40635]], [[12232, 12232], "mapped", [40643]], [[12233, 12233], "mapped", [40653]], [[12234, 12234], "mapped", [40657]], [[12235, 12235], "mapped", [40697]], [[12236, 12236], "mapped", [40701]], [[12237, 12237], "mapped", [40718]], [[12238, 12238], "mapped", [40723]], [[12239, 12239], "mapped", [40736]], [[12240, 12240], "mapped", [40763]], [[12241, 12241], "mapped", [40778]], [[12242, 12242], "mapped", [40786]], [[12243, 12243], "mapped", [40845]], [[12244, 12244], "mapped", [40860]], [[12245, 12245], "mapped", [40864]], [[12246, 12271], "disallowed"], [[12272, 12283], "disallowed"], [[12284, 12287], "disallowed"], [[12288, 12288], "disallowed_STD3_mapped", [32]], [[12289, 12289], "valid", [], "NV8"], [[12290, 12290], "mapped", [46]], [[12291, 12292], "valid", [], "NV8"], [[12293, 12295], "valid"], [[12296, 12329], "valid", [], "NV8"], [[12330, 12333], "valid"], [[12334, 12341], "valid", [], "NV8"], [[12342, 12342], "mapped", [12306]], [[12343, 12343], "valid", [], "NV8"], [[12344, 12344], "mapped", [21313]], [[12345, 12345], "mapped", [21316]], [[12346, 12346], "mapped", [21317]], [[12347, 12347], "valid", [], "NV8"], [[12348, 12348], "valid"], [[12349, 12349], "valid", [], "NV8"], [[12350, 12350], "valid", [], "NV8"], [[12351, 12351], "valid", [], "NV8"], [[12352, 12352], "disallowed"], [[12353, 12436], "valid"], [[12437, 12438], "valid"], [[12439, 12440], "disallowed"], [[12441, 12442], "valid"], [[12443, 12443], "disallowed_STD3_mapped", [32, 12441]], [[12444, 12444], "disallowed_STD3_mapped", [32, 12442]], [[12445, 12446], "valid"], [[12447, 12447], "mapped", [12424, 12426]], [[12448, 12448], "valid", [], "NV8"], [[12449, 12542], "valid"], [[12543, 12543], "mapped", [12467, 12488]], [[12544, 12548], "disallowed"], [[12549, 12588], "valid"], [[12589, 12589], "valid"], [[12590, 12592], "disallowed"], [[12593, 12593], "mapped", [4352]], [[12594, 12594], "mapped", [4353]], [[12595, 12595], "mapped", [4522]], [[12596, 12596], "mapped", [4354]], [[12597, 12597], "mapped", [4524]], [[12598, 12598], "mapped", [4525]], [[12599, 12599], "mapped", [4355]], [[12600, 12600], "mapped", [4356]], [[12601, 12601], "mapped", [4357]], [[12602, 12602], "mapped", [4528]], [[12603, 12603], "mapped", [4529]], [[12604, 12604], "mapped", [4530]], [[12605, 12605], "mapped", [4531]], [[12606, 12606], "mapped", [4532]], [[12607, 12607], "mapped", [4533]], [[12608, 12608], "mapped", [4378]], [[12609, 12609], "mapped", [4358]], [[12610, 12610], "mapped", [4359]], [[12611, 12611], "mapped", [4360]], [[12612, 12612], "mapped", [4385]], [[12613, 12613], "mapped", [4361]], [[12614, 12614], "mapped", [4362]], [[12615, 12615], "mapped", [4363]], [[12616, 12616], "mapped", [4364]], [[12617, 12617], "mapped", [4365]], [[12618, 12618], "mapped", [4366]], [[12619, 12619], "mapped", [4367]], [[12620, 12620], "mapped", [4368]], [[12621, 12621], "mapped", [4369]], [[12622, 12622], "mapped", [4370]], [[12623, 12623], "mapped", [4449]], [[12624, 12624], "mapped", [4450]], [[12625, 12625], "mapped", [4451]], [[12626, 12626], "mapped", [4452]], [[12627, 12627], "mapped", [4453]], [[12628, 12628], "mapped", [4454]], [[12629, 12629], "mapped", [4455]], [[12630, 12630], "mapped", [4456]], [[12631, 12631], "mapped", [4457]], [[12632, 12632], "mapped", [4458]], [[12633, 12633], "mapped", [4459]], [[12634, 12634], "mapped", [4460]], [[12635, 12635], "mapped", [4461]], [[12636, 12636], "mapped", [4462]], [[12637, 12637], "mapped", [4463]], [[12638, 12638], "mapped", [4464]], [[12639, 12639], "mapped", [4465]], [[12640, 12640], "mapped", [4466]], [[12641, 12641], "mapped", [4467]], [[12642, 12642], "mapped", [4468]], [[12643, 12643], "mapped", [4469]], [[12644, 12644], "disallowed"], [[12645, 12645], "mapped", [4372]], [[12646, 12646], "mapped", [4373]], [[12647, 12647], "mapped", [4551]], [[12648, 12648], "mapped", [4552]], [[12649, 12649], "mapped", [4556]], [[12650, 12650], "mapped", [4558]], [[12651, 12651], "mapped", [4563]], [[12652, 12652], "mapped", [4567]], [[12653, 12653], "mapped", [4569]], [[12654, 12654], "mapped", [4380]], [[12655, 12655], "mapped", [4573]], [[12656, 12656], "mapped", [4575]], [[12657, 12657], "mapped", [4381]], [[12658, 12658], "mapped", [4382]], [[12659, 12659], "mapped", [4384]], [[12660, 12660], "mapped", [4386]], [[12661, 12661], "mapped", [4387]], [[12662, 12662], "mapped", [4391]], [[12663, 12663], "mapped", [4393]], [[12664, 12664], "mapped", [4395]], [[12665, 12665], "mapped", [4396]], [[12666, 12666], "mapped", [4397]], [[12667, 12667], "mapped", [4398]], [[12668, 12668], "mapped", [4399]], [[12669, 12669], "mapped", [4402]], [[12670, 12670], "mapped", [4406]], [[12671, 12671], "mapped", [4416]], [[12672, 12672], "mapped", [4423]], [[12673, 12673], "mapped", [4428]], [[12674, 12674], "mapped", [4593]], [[12675, 12675], "mapped", [4594]], [[12676, 12676], "mapped", [4439]], [[12677, 12677], "mapped", [4440]], [[12678, 12678], "mapped", [4441]], [[12679, 12679], "mapped", [4484]], [[12680, 12680], "mapped", [4485]], [[12681, 12681], "mapped", [4488]], [[12682, 12682], "mapped", [4497]], [[12683, 12683], "mapped", [4498]], [[12684, 12684], "mapped", [4500]], [[12685, 12685], "mapped", [4510]], [[12686, 12686], "mapped", [4513]], [[12687, 12687], "disallowed"], [[12688, 12689], "valid", [], "NV8"], [[12690, 12690], "mapped", [19968]], [[12691, 12691], "mapped", [20108]], [[12692, 12692], "mapped", [19977]], [[12693, 12693], "mapped", [22235]], [[12694, 12694], "mapped", [19978]], [[12695, 12695], "mapped", [20013]], [[12696, 12696], "mapped", [19979]], [[12697, 12697], "mapped", [30002]], [[12698, 12698], "mapped", [20057]], [[12699, 12699], "mapped", [19993]], [[12700, 12700], "mapped", [19969]], [[12701, 12701], "mapped", [22825]], [[12702, 12702], "mapped", [22320]], [[12703, 12703], "mapped", [20154]], [[12704, 12727], "valid"], [[12728, 12730], "valid"], [[12731, 12735], "disallowed"], [[12736, 12751], "valid", [], "NV8"], [[12752, 12771], "valid", [], "NV8"], [[12772, 12783], "disallowed"], [[12784, 12799], "valid"], [[12800, 12800], "disallowed_STD3_mapped", [40, 4352, 41]], [[12801, 12801], "disallowed_STD3_mapped", [40, 4354, 41]], [[12802, 12802], "disallowed_STD3_mapped", [40, 4355, 41]], [[12803, 12803], "disallowed_STD3_mapped", [40, 4357, 41]], [[12804, 12804], "disallowed_STD3_mapped", [40, 4358, 41]], [[12805, 12805], "disallowed_STD3_mapped", [40, 4359, 41]], [[12806, 12806], "disallowed_STD3_mapped", [40, 4361, 41]], [[12807, 12807], "disallowed_STD3_mapped", [40, 4363, 41]], [[12808, 12808], "disallowed_STD3_mapped", [40, 4364, 41]], [[12809, 12809], "disallowed_STD3_mapped", [40, 4366, 41]], [[12810, 12810], "disallowed_STD3_mapped", [40, 4367, 41]], [[12811, 12811], "disallowed_STD3_mapped", [40, 4368, 41]], [[12812, 12812], "disallowed_STD3_mapped", [40, 4369, 41]], [[12813, 12813], "disallowed_STD3_mapped", [40, 4370, 41]], [[12814, 12814], "disallowed_STD3_mapped", [40, 44032, 41]], [[12815, 12815], "disallowed_STD3_mapped", [40, 45208, 41]], [[12816, 12816], "disallowed_STD3_mapped", [40, 45796, 41]], [[12817, 12817], "disallowed_STD3_mapped", [40, 46972, 41]], [[12818, 12818], "disallowed_STD3_mapped", [40, 47560, 41]], [[12819, 12819], "disallowed_STD3_mapped", [40, 48148, 41]], [[12820, 12820], "disallowed_STD3_mapped", [40, 49324, 41]], [[12821, 12821], "disallowed_STD3_mapped", [40, 50500, 41]], [[12822, 12822], "disallowed_STD3_mapped", [40, 51088, 41]], [[12823, 12823], "disallowed_STD3_mapped", [40, 52264, 41]], [[12824, 12824], "disallowed_STD3_mapped", [40, 52852, 41]], [[12825, 12825], "disallowed_STD3_mapped", [40, 53440, 41]], [[12826, 12826], "disallowed_STD3_mapped", [40, 54028, 41]], [[12827, 12827], "disallowed_STD3_mapped", [40, 54616, 41]], [[12828, 12828], "disallowed_STD3_mapped", [40, 51452, 41]], [[12829, 12829], "disallowed_STD3_mapped", [40, 50724, 51204, 41]], [[12830, 12830], "disallowed_STD3_mapped", [40, 50724, 54980, 41]], [[12831, 12831], "disallowed"], [[12832, 12832], "disallowed_STD3_mapped", [40, 19968, 41]], [[12833, 12833], "disallowed_STD3_mapped", [40, 20108, 41]], [[12834, 12834], "disallowed_STD3_mapped", [40, 19977, 41]], [[12835, 12835], "disallowed_STD3_mapped", [40, 22235, 41]], [[12836, 12836], "disallowed_STD3_mapped", [40, 20116, 41]], [[12837, 12837], "disallowed_STD3_mapped", [40, 20845, 41]], [[12838, 12838], "disallowed_STD3_mapped", [40, 19971, 41]], [[12839, 12839], "disallowed_STD3_mapped", [40, 20843, 41]], [[12840, 12840], "disallowed_STD3_mapped", [40, 20061, 41]], [[12841, 12841], "disallowed_STD3_mapped", [40, 21313, 41]], [[12842, 12842], "disallowed_STD3_mapped", [40, 26376, 41]], [[12843, 12843], "disallowed_STD3_mapped", [40, 28779, 41]], [[12844, 12844], "disallowed_STD3_mapped", [40, 27700, 41]], [[12845, 12845], "disallowed_STD3_mapped", [40, 26408, 41]], [[12846, 12846], "disallowed_STD3_mapped", [40, 37329, 41]], [[12847, 12847], "disallowed_STD3_mapped", [40, 22303, 41]], [[12848, 12848], "disallowed_STD3_mapped", [40, 26085, 41]], [[12849, 12849], "disallowed_STD3_mapped", [40, 26666, 41]], [[12850, 12850], "disallowed_STD3_mapped", [40, 26377, 41]], [[12851, 12851], "disallowed_STD3_mapped", [40, 31038, 41]], [[12852, 12852], "disallowed_STD3_mapped", [40, 21517, 41]], [[12853, 12853], "disallowed_STD3_mapped", [40, 29305, 41]], [[12854, 12854], "disallowed_STD3_mapped", [40, 36001, 41]], [[12855, 12855], "disallowed_STD3_mapped", [40, 31069, 41]], [[12856, 12856], "disallowed_STD3_mapped", [40, 21172, 41]], [[12857, 12857], "disallowed_STD3_mapped", [40, 20195, 41]], [[12858, 12858], "disallowed_STD3_mapped", [40, 21628, 41]], [[12859, 12859], "disallowed_STD3_mapped", [40, 23398, 41]], [[12860, 12860], "disallowed_STD3_mapped", [40, 30435, 41]], [[12861, 12861], "disallowed_STD3_mapped", [40, 20225, 41]], [[12862, 12862], "disallowed_STD3_mapped", [40, 36039, 41]], [[12863, 12863], "disallowed_STD3_mapped", [40, 21332, 41]], [[12864, 12864], "disallowed_STD3_mapped", [40, 31085, 41]], [[12865, 12865], "disallowed_STD3_mapped", [40, 20241, 41]], [[12866, 12866], "disallowed_STD3_mapped", [40, 33258, 41]], [[12867, 12867], "disallowed_STD3_mapped", [40, 33267, 41]], [[12868, 12868], "mapped", [21839]], [[12869, 12869], "mapped", [24188]], [[12870, 12870], "mapped", [25991]], [[12871, 12871], "mapped", [31631]], [[12872, 12879], "valid", [], "NV8"], [[12880, 12880], "mapped", [112, 116, 101]], [[12881, 12881], "mapped", [50, 49]], [[12882, 12882], "mapped", [50, 50]], [[12883, 12883], "mapped", [50, 51]], [[12884, 12884], "mapped", [50, 52]], [[12885, 12885], "mapped", [50, 53]], [[12886, 12886], "mapped", [50, 54]], [[12887, 12887], "mapped", [50, 55]], [[12888, 12888], "mapped", [50, 56]], [[12889, 12889], "mapped", [50, 57]], [[12890, 12890], "mapped", [51, 48]], [[12891, 12891], "mapped", [51, 49]], [[12892, 12892], "mapped", [51, 50]], [[12893, 12893], "mapped", [51, 51]], [[12894, 12894], "mapped", [51, 52]], [[12895, 12895], "mapped", [51, 53]], [[12896, 12896], "mapped", [4352]], [[12897, 12897], "mapped", [4354]], [[12898, 12898], "mapped", [4355]], [[12899, 12899], "mapped", [4357]], [[12900, 12900], "mapped", [4358]], [[12901, 12901], "mapped", [4359]], [[12902, 12902], "mapped", [4361]], [[12903, 12903], "mapped", [4363]], [[12904, 12904], "mapped", [4364]], [[12905, 12905], "mapped", [4366]], [[12906, 12906], "mapped", [4367]], [[12907, 12907], "mapped", [4368]], [[12908, 12908], "mapped", [4369]], [[12909, 12909], "mapped", [4370]], [[12910, 12910], "mapped", [44032]], [[12911, 12911], "mapped", [45208]], [[12912, 12912], "mapped", [45796]], [[12913, 12913], "mapped", [46972]], [[12914, 12914], "mapped", [47560]], [[12915, 12915], "mapped", [48148]], [[12916, 12916], "mapped", [49324]], [[12917, 12917], "mapped", [50500]], [[12918, 12918], "mapped", [51088]], [[12919, 12919], "mapped", [52264]], [[12920, 12920], "mapped", [52852]], [[12921, 12921], "mapped", [53440]], [[12922, 12922], "mapped", [54028]], [[12923, 12923], "mapped", [54616]], [[12924, 12924], "mapped", [52280, 44256]], [[12925, 12925], "mapped", [51452, 51032]], [[12926, 12926], "mapped", [50864]], [[12927, 12927], "valid", [], "NV8"], [[12928, 12928], "mapped", [19968]], [[12929, 12929], "mapped", [20108]], [[12930, 12930], "mapped", [19977]], [[12931, 12931], "mapped", [22235]], [[12932, 12932], "mapped", [20116]], [[12933, 12933], "mapped", [20845]], [[12934, 12934], "mapped", [19971]], [[12935, 12935], "mapped", [20843]], [[12936, 12936], "mapped", [20061]], [[12937, 12937], "mapped", [21313]], [[12938, 12938], "mapped", [26376]], [[12939, 12939], "mapped", [28779]], [[12940, 12940], "mapped", [27700]], [[12941, 12941], "mapped", [26408]], [[12942, 12942], "mapped", [37329]], [[12943, 12943], "mapped", [22303]], [[12944, 12944], "mapped", [26085]], [[12945, 12945], "mapped", [26666]], [[12946, 12946], "mapped", [26377]], [[12947, 12947], "mapped", [31038]], [[12948, 12948], "mapped", [21517]], [[12949, 12949], "mapped", [29305]], [[12950, 12950], "mapped", [36001]], [[12951, 12951], "mapped", [31069]], [[12952, 12952], "mapped", [21172]], [[12953, 12953], "mapped", [31192]], [[12954, 12954], "mapped", [30007]], [[12955, 12955], "mapped", [22899]], [[12956, 12956], "mapped", [36969]], [[12957, 12957], "mapped", [20778]], [[12958, 12958], "mapped", [21360]], [[12959, 12959], "mapped", [27880]], [[12960, 12960], "mapped", [38917]], [[12961, 12961], "mapped", [20241]], [[12962, 12962], "mapped", [20889]], [[12963, 12963], "mapped", [27491]], [[12964, 12964], "mapped", [19978]], [[12965, 12965], "mapped", [20013]], [[12966, 12966], "mapped", [19979]], [[12967, 12967], "mapped", [24038]], [[12968, 12968], "mapped", [21491]], [[12969, 12969], "mapped", [21307]], [[12970, 12970], "mapped", [23447]], [[12971, 12971], "mapped", [23398]], [[12972, 12972], "mapped", [30435]], [[12973, 12973], "mapped", [20225]], [[12974, 12974], "mapped", [36039]], [[12975, 12975], "mapped", [21332]], [[12976, 12976], "mapped", [22812]], [[12977, 12977], "mapped", [51, 54]], [[12978, 12978], "mapped", [51, 55]], [[12979, 12979], "mapped", [51, 56]], [[12980, 12980], "mapped", [51, 57]], [[12981, 12981], "mapped", [52, 48]], [[12982, 12982], "mapped", [52, 49]], [[12983, 12983], "mapped", [52, 50]], [[12984, 12984], "mapped", [52, 51]], [[12985, 12985], "mapped", [52, 52]], [[12986, 12986], "mapped", [52, 53]], [[12987, 12987], "mapped", [52, 54]], [[12988, 12988], "mapped", [52, 55]], [[12989, 12989], "mapped", [52, 56]], [[12990, 12990], "mapped", [52, 57]], [[12991, 12991], "mapped", [53, 48]], [[12992, 12992], "mapped", [49, 26376]], [[12993, 12993], "mapped", [50, 26376]], [[12994, 12994], "mapped", [51, 26376]], [[12995, 12995], "mapped", [52, 26376]], [[12996, 12996], "mapped", [53, 26376]], [[12997, 12997], "mapped", [54, 26376]], [[12998, 12998], "mapped", [55, 26376]], [[12999, 12999], "mapped", [56, 26376]], [[13e3, 13e3], "mapped", [57, 26376]], [[13001, 13001], "mapped", [49, 48, 26376]], [[13002, 13002], "mapped", [49, 49, 26376]], [[13003, 13003], "mapped", [49, 50, 26376]], [[13004, 13004], "mapped", [104, 103]], [[13005, 13005], "mapped", [101, 114, 103]], [[13006, 13006], "mapped", [101, 118]], [[13007, 13007], "mapped", [108, 116, 100]], [[13008, 13008], "mapped", [12450]], [[13009, 13009], "mapped", [12452]], [[13010, 13010], "mapped", [12454]], [[13011, 13011], "mapped", [12456]], [[13012, 13012], "mapped", [12458]], [[13013, 13013], "mapped", [12459]], [[13014, 13014], "mapped", [12461]], [[13015, 13015], "mapped", [12463]], [[13016, 13016], "mapped", [12465]], [[13017, 13017], "mapped", [12467]], [[13018, 13018], "mapped", [12469]], [[13019, 13019], "mapped", [12471]], [[13020, 13020], "mapped", [12473]], [[13021, 13021], "mapped", [12475]], [[13022, 13022], "mapped", [12477]], [[13023, 13023], "mapped", [12479]], [[13024, 13024], "mapped", [12481]], [[13025, 13025], "mapped", [12484]], [[13026, 13026], "mapped", [12486]], [[13027, 13027], "mapped", [12488]], [[13028, 13028], "mapped", [12490]], [[13029, 13029], "mapped", [12491]], [[13030, 13030], "mapped", [12492]], [[13031, 13031], "mapped", [12493]], [[13032, 13032], "mapped", [12494]], [[13033, 13033], "mapped", [12495]], [[13034, 13034], "mapped", [12498]], [[13035, 13035], "mapped", [12501]], [[13036, 13036], "mapped", [12504]], [[13037, 13037], "mapped", [12507]], [[13038, 13038], "mapped", [12510]], [[13039, 13039], "mapped", [12511]], [[13040, 13040], "mapped", [12512]], [[13041, 13041], "mapped", [12513]], [[13042, 13042], "mapped", [12514]], [[13043, 13043], "mapped", [12516]], [[13044, 13044], "mapped", [12518]], [[13045, 13045], "mapped", [12520]], [[13046, 13046], "mapped", [12521]], [[13047, 13047], "mapped", [12522]], [[13048, 13048], "mapped", [12523]], [[13049, 13049], "mapped", [12524]], [[13050, 13050], "mapped", [12525]], [[13051, 13051], "mapped", [12527]], [[13052, 13052], "mapped", [12528]], [[13053, 13053], "mapped", [12529]], [[13054, 13054], "mapped", [12530]], [[13055, 13055], "disallowed"], [[13056, 13056], "mapped", [12450, 12497, 12540, 12488]], [[13057, 13057], "mapped", [12450, 12523, 12501, 12449]], [[13058, 13058], "mapped", [12450, 12531, 12506, 12450]], [[13059, 13059], "mapped", [12450, 12540, 12523]], [[13060, 13060], "mapped", [12452, 12491, 12531, 12464]], [[13061, 13061], "mapped", [12452, 12531, 12481]], [[13062, 13062], "mapped", [12454, 12457, 12531]], [[13063, 13063], "mapped", [12456, 12473, 12463, 12540, 12489]], [[13064, 13064], "mapped", [12456, 12540, 12459, 12540]], [[13065, 13065], "mapped", [12458, 12531, 12473]], [[13066, 13066], "mapped", [12458, 12540, 12512]], [[13067, 13067], "mapped", [12459, 12452, 12522]], [[13068, 13068], "mapped", [12459, 12521, 12483, 12488]], [[13069, 13069], "mapped", [12459, 12525, 12522, 12540]], [[13070, 13070], "mapped", [12460, 12525, 12531]], [[13071, 13071], "mapped", [12460, 12531, 12510]], [[13072, 13072], "mapped", [12462, 12460]], [[13073, 13073], "mapped", [12462, 12491, 12540]], [[13074, 13074], "mapped", [12461, 12517, 12522, 12540]], [[13075, 13075], "mapped", [12462, 12523, 12480, 12540]], [[13076, 13076], "mapped", [12461, 12525]], [[13077, 13077], "mapped", [12461, 12525, 12464, 12521, 12512]], [[13078, 13078], "mapped", [12461, 12525, 12513, 12540, 12488, 12523]], [[13079, 13079], "mapped", [12461, 12525, 12527, 12483, 12488]], [[13080, 13080], "mapped", [12464, 12521, 12512]], [[13081, 13081], "mapped", [12464, 12521, 12512, 12488, 12531]], [[13082, 13082], "mapped", [12463, 12523, 12476, 12452, 12525]], [[13083, 13083], "mapped", [12463, 12525, 12540, 12493]], [[13084, 13084], "mapped", [12465, 12540, 12473]], [[13085, 13085], "mapped", [12467, 12523, 12490]], [[13086, 13086], "mapped", [12467, 12540, 12509]], [[13087, 13087], "mapped", [12469, 12452, 12463, 12523]], [[13088, 13088], "mapped", [12469, 12531, 12481, 12540, 12512]], [[13089, 13089], "mapped", [12471, 12522, 12531, 12464]], [[13090, 13090], "mapped", [12475, 12531, 12481]], [[13091, 13091], "mapped", [12475, 12531, 12488]], [[13092, 13092], "mapped", [12480, 12540, 12473]], [[13093, 13093], "mapped", [12487, 12471]], [[13094, 13094], "mapped", [12489, 12523]], [[13095, 13095], "mapped", [12488, 12531]], [[13096, 13096], "mapped", [12490, 12494]], [[13097, 13097], "mapped", [12494, 12483, 12488]], [[13098, 13098], "mapped", [12495, 12452, 12484]], [[13099, 13099], "mapped", [12497, 12540, 12475, 12531, 12488]], [[13100, 13100], "mapped", [12497, 12540, 12484]], [[13101, 13101], "mapped", [12496, 12540, 12524, 12523]], [[13102, 13102], "mapped", [12500, 12450, 12473, 12488, 12523]], [[13103, 13103], "mapped", [12500, 12463, 12523]], [[13104, 13104], "mapped", [12500, 12467]], [[13105, 13105], "mapped", [12499, 12523]], [[13106, 13106], "mapped", [12501, 12449, 12521, 12483, 12489]], [[13107, 13107], "mapped", [12501, 12451, 12540, 12488]], [[13108, 13108], "mapped", [12502, 12483, 12471, 12455, 12523]], [[13109, 13109], "mapped", [12501, 12521, 12531]], [[13110, 13110], "mapped", [12504, 12463, 12479, 12540, 12523]], [[13111, 13111], "mapped", [12506, 12477]], [[13112, 13112], "mapped", [12506, 12491, 12498]], [[13113, 13113], "mapped", [12504, 12523, 12484]], [[13114, 13114], "mapped", [12506, 12531, 12473]], [[13115, 13115], "mapped", [12506, 12540, 12472]], [[13116, 13116], "mapped", [12505, 12540, 12479]], [[13117, 13117], "mapped", [12509, 12452, 12531, 12488]], [[13118, 13118], "mapped", [12508, 12523, 12488]], [[13119, 13119], "mapped", [12507, 12531]], [[13120, 13120], "mapped", [12509, 12531, 12489]], [[13121, 13121], "mapped", [12507, 12540, 12523]], [[13122, 13122], "mapped", [12507, 12540, 12531]], [[13123, 13123], "mapped", [12510, 12452, 12463, 12525]], [[13124, 13124], "mapped", [12510, 12452, 12523]], [[13125, 13125], "mapped", [12510, 12483, 12495]], [[13126, 13126], "mapped", [12510, 12523, 12463]], [[13127, 13127], "mapped", [12510, 12531, 12471, 12519, 12531]], [[13128, 13128], "mapped", [12511, 12463, 12525, 12531]], [[13129, 13129], "mapped", [12511, 12522]], [[13130, 13130], "mapped", [12511, 12522, 12496, 12540, 12523]], [[13131, 13131], "mapped", [12513, 12460]], [[13132, 13132], "mapped", [12513, 12460, 12488, 12531]], [[13133, 13133], "mapped", [12513, 12540, 12488, 12523]], [[13134, 13134], "mapped", [12516, 12540, 12489]], [[13135, 13135], "mapped", [12516, 12540, 12523]], [[13136, 13136], "mapped", [12518, 12450, 12531]], [[13137, 13137], "mapped", [12522, 12483, 12488, 12523]], [[13138, 13138], "mapped", [12522, 12521]], [[13139, 13139], "mapped", [12523, 12500, 12540]], [[13140, 13140], "mapped", [12523, 12540, 12502, 12523]], [[13141, 13141], "mapped", [12524, 12512]], [[13142, 13142], "mapped", [12524, 12531, 12488, 12466, 12531]], [[13143, 13143], "mapped", [12527, 12483, 12488]], [[13144, 13144], "mapped", [48, 28857]], [[13145, 13145], "mapped", [49, 28857]], [[13146, 13146], "mapped", [50, 28857]], [[13147, 13147], "mapped", [51, 28857]], [[13148, 13148], "mapped", [52, 28857]], [[13149, 13149], "mapped", [53, 28857]], [[13150, 13150], "mapped", [54, 28857]], [[13151, 13151], "mapped", [55, 28857]], [[13152, 13152], "mapped", [56, 28857]], [[13153, 13153], "mapped", [57, 28857]], [[13154, 13154], "mapped", [49, 48, 28857]], [[13155, 13155], "mapped", [49, 49, 28857]], [[13156, 13156], "mapped", [49, 50, 28857]], [[13157, 13157], "mapped", [49, 51, 28857]], [[13158, 13158], "mapped", [49, 52, 28857]], [[13159, 13159], "mapped", [49, 53, 28857]], [[13160, 13160], "mapped", [49, 54, 28857]], [[13161, 13161], "mapped", [49, 55, 28857]], [[13162, 13162], "mapped", [49, 56, 28857]], [[13163, 13163], "mapped", [49, 57, 28857]], [[13164, 13164], "mapped", [50, 48, 28857]], [[13165, 13165], "mapped", [50, 49, 28857]], [[13166, 13166], "mapped", [50, 50, 28857]], [[13167, 13167], "mapped", [50, 51, 28857]], [[13168, 13168], "mapped", [50, 52, 28857]], [[13169, 13169], "mapped", [104, 112, 97]], [[13170, 13170], "mapped", [100, 97]], [[13171, 13171], "mapped", [97, 117]], [[13172, 13172], "mapped", [98, 97, 114]], [[13173, 13173], "mapped", [111, 118]], [[13174, 13174], "mapped", [112, 99]], [[13175, 13175], "mapped", [100, 109]], [[13176, 13176], "mapped", [100, 109, 50]], [[13177, 13177], "mapped", [100, 109, 51]], [[13178, 13178], "mapped", [105, 117]], [[13179, 13179], "mapped", [24179, 25104]], [[13180, 13180], "mapped", [26157, 21644]], [[13181, 13181], "mapped", [22823, 27491]], [[13182, 13182], "mapped", [26126, 27835]], [[13183, 13183], "mapped", [26666, 24335, 20250, 31038]], [[13184, 13184], "mapped", [112, 97]], [[13185, 13185], "mapped", [110, 97]], [[13186, 13186], "mapped", [956, 97]], [[13187, 13187], "mapped", [109, 97]], [[13188, 13188], "mapped", [107, 97]], [[13189, 13189], "mapped", [107, 98]], [[13190, 13190], "mapped", [109, 98]], [[13191, 13191], "mapped", [103, 98]], [[13192, 13192], "mapped", [99, 97, 108]], [[13193, 13193], "mapped", [107, 99, 97, 108]], [[13194, 13194], "mapped", [112, 102]], [[13195, 13195], "mapped", [110, 102]], [[13196, 13196], "mapped", [956, 102]], [[13197, 13197], "mapped", [956, 103]], [[13198, 13198], "mapped", [109, 103]], [[13199, 13199], "mapped", [107, 103]], [[13200, 13200], "mapped", [104, 122]], [[13201, 13201], "mapped", [107, 104, 122]], [[13202, 13202], "mapped", [109, 104, 122]], [[13203, 13203], "mapped", [103, 104, 122]], [[13204, 13204], "mapped", [116, 104, 122]], [[13205, 13205], "mapped", [956, 108]], [[13206, 13206], "mapped", [109, 108]], [[13207, 13207], "mapped", [100, 108]], [[13208, 13208], "mapped", [107, 108]], [[13209, 13209], "mapped", [102, 109]], [[13210, 13210], "mapped", [110, 109]], [[13211, 13211], "mapped", [956, 109]], [[13212, 13212], "mapped", [109, 109]], [[13213, 13213], "mapped", [99, 109]], [[13214, 13214], "mapped", [107, 109]], [[13215, 13215], "mapped", [109, 109, 50]], [[13216, 13216], "mapped", [99, 109, 50]], [[13217, 13217], "mapped", [109, 50]], [[13218, 13218], "mapped", [107, 109, 50]], [[13219, 13219], "mapped", [109, 109, 51]], [[13220, 13220], "mapped", [99, 109, 51]], [[13221, 13221], "mapped", [109, 51]], [[13222, 13222], "mapped", [107, 109, 51]], [[13223, 13223], "mapped", [109, 8725, 115]], [[13224, 13224], "mapped", [109, 8725, 115, 50]], [[13225, 13225], "mapped", [112, 97]], [[13226, 13226], "mapped", [107, 112, 97]], [[13227, 13227], "mapped", [109, 112, 97]], [[13228, 13228], "mapped", [103, 112, 97]], [[13229, 13229], "mapped", [114, 97, 100]], [[13230, 13230], "mapped", [114, 97, 100, 8725, 115]], [[13231, 13231], "mapped", [114, 97, 100, 8725, 115, 50]], [[13232, 13232], "mapped", [112, 115]], [[13233, 13233], "mapped", [110, 115]], [[13234, 13234], "mapped", [956, 115]], [[13235, 13235], "mapped", [109, 115]], [[13236, 13236], "mapped", [112, 118]], [[13237, 13237], "mapped", [110, 118]], [[13238, 13238], "mapped", [956, 118]], [[13239, 13239], "mapped", [109, 118]], [[13240, 13240], "mapped", [107, 118]], [[13241, 13241], "mapped", [109, 118]], [[13242, 13242], "mapped", [112, 119]], [[13243, 13243], "mapped", [110, 119]], [[13244, 13244], "mapped", [956, 119]], [[13245, 13245], "mapped", [109, 119]], [[13246, 13246], "mapped", [107, 119]], [[13247, 13247], "mapped", [109, 119]], [[13248, 13248], "mapped", [107, 969]], [[13249, 13249], "mapped", [109, 969]], [[13250, 13250], "disallowed"], [[13251, 13251], "mapped", [98, 113]], [[13252, 13252], "mapped", [99, 99]], [[13253, 13253], "mapped", [99, 100]], [[13254, 13254], "mapped", [99, 8725, 107, 103]], [[13255, 13255], "disallowed"], [[13256, 13256], "mapped", [100, 98]], [[13257, 13257], "mapped", [103, 121]], [[13258, 13258], "mapped", [104, 97]], [[13259, 13259], "mapped", [104, 112]], [[13260, 13260], "mapped", [105, 110]], [[13261, 13261], "mapped", [107, 107]], [[13262, 13262], "mapped", [107, 109]], [[13263, 13263], "mapped", [107, 116]], [[13264, 13264], "mapped", [108, 109]], [[13265, 13265], "mapped", [108, 110]], [[13266, 13266], "mapped", [108, 111, 103]], [[13267, 13267], "mapped", [108, 120]], [[13268, 13268], "mapped", [109, 98]], [[13269, 13269], "mapped", [109, 105, 108]], [[13270, 13270], "mapped", [109, 111, 108]], [[13271, 13271], "mapped", [112, 104]], [[13272, 13272], "disallowed"], [[13273, 13273], "mapped", [112, 112, 109]], [[13274, 13274], "mapped", [112, 114]], [[13275, 13275], "mapped", [115, 114]], [[13276, 13276], "mapped", [115, 118]], [[13277, 13277], "mapped", [119, 98]], [[13278, 13278], "mapped", [118, 8725, 109]], [[13279, 13279], "mapped", [97, 8725, 109]], [[13280, 13280], "mapped", [49, 26085]], [[13281, 13281], "mapped", [50, 26085]], [[13282, 13282], "mapped", [51, 26085]], [[13283, 13283], "mapped", [52, 26085]], [[13284, 13284], "mapped", [53, 26085]], [[13285, 13285], "mapped", [54, 26085]], [[13286, 13286], "mapped", [55, 26085]], [[13287, 13287], "mapped", [56, 26085]], [[13288, 13288], "mapped", [57, 26085]], [[13289, 13289], "mapped", [49, 48, 26085]], [[13290, 13290], "mapped", [49, 49, 26085]], [[13291, 13291], "mapped", [49, 50, 26085]], [[13292, 13292], "mapped", [49, 51, 26085]], [[13293, 13293], "mapped", [49, 52, 26085]], [[13294, 13294], "mapped", [49, 53, 26085]], [[13295, 13295], "mapped", [49, 54, 26085]], [[13296, 13296], "mapped", [49, 55, 26085]], [[13297, 13297], "mapped", [49, 56, 26085]], [[13298, 13298], "mapped", [49, 57, 26085]], [[13299, 13299], "mapped", [50, 48, 26085]], [[13300, 13300], "mapped", [50, 49, 26085]], [[13301, 13301], "mapped", [50, 50, 26085]], [[13302, 13302], "mapped", [50, 51, 26085]], [[13303, 13303], "mapped", [50, 52, 26085]], [[13304, 13304], "mapped", [50, 53, 26085]], [[13305, 13305], "mapped", [50, 54, 26085]], [[13306, 13306], "mapped", [50, 55, 26085]], [[13307, 13307], "mapped", [50, 56, 26085]], [[13308, 13308], "mapped", [50, 57, 26085]], [[13309, 13309], "mapped", [51, 48, 26085]], [[13310, 13310], "mapped", [51, 49, 26085]], [[13311, 13311], "mapped", [103, 97, 108]], [[13312, 19893], "valid"], [[19894, 19903], "disallowed"], [[19904, 19967], "valid", [], "NV8"], [[19968, 40869], "valid"], [[40870, 40891], "valid"], [[40892, 40899], "valid"], [[40900, 40907], "valid"], [[40908, 40908], "valid"], [[40909, 40917], "valid"], [[40918, 40959], "disallowed"], [[40960, 42124], "valid"], [[42125, 42127], "disallowed"], [[42128, 42145], "valid", [], "NV8"], [[42146, 42147], "valid", [], "NV8"], [[42148, 42163], "valid", [], "NV8"], [[42164, 42164], "valid", [], "NV8"], [[42165, 42176], "valid", [], "NV8"], [[42177, 42177], "valid", [], "NV8"], [[42178, 42180], "valid", [], "NV8"], [[42181, 42181], "valid", [], "NV8"], [[42182, 42182], "valid", [], "NV8"], [[42183, 42191], "disallowed"], [[42192, 42237], "valid"], [[42238, 42239], "valid", [], "NV8"], [[42240, 42508], "valid"], [[42509, 42511], "valid", [], "NV8"], [[42512, 42539], "valid"], [[42540, 42559], "disallowed"], [[42560, 42560], "mapped", [42561]], [[42561, 42561], "valid"], [[42562, 42562], "mapped", [42563]], [[42563, 42563], "valid"], [[42564, 42564], "mapped", [42565]], [[42565, 42565], "valid"], [[42566, 42566], "mapped", [42567]], [[42567, 42567], "valid"], [[42568, 42568], "mapped", [42569]], [[42569, 42569], "valid"], [[42570, 42570], "mapped", [42571]], [[42571, 42571], "valid"], [[42572, 42572], "mapped", [42573]], [[42573, 42573], "valid"], [[42574, 42574], "mapped", [42575]], [[42575, 42575], "valid"], [[42576, 42576], "mapped", [42577]], [[42577, 42577], "valid"], [[42578, 42578], "mapped", [42579]], [[42579, 42579], "valid"], [[42580, 42580], "mapped", [42581]], [[42581, 42581], "valid"], [[42582, 42582], "mapped", [42583]], [[42583, 42583], "valid"], [[42584, 42584], "mapped", [42585]], [[42585, 42585], "valid"], [[42586, 42586], "mapped", [42587]], [[42587, 42587], "valid"], [[42588, 42588], "mapped", [42589]], [[42589, 42589], "valid"], [[42590, 42590], "mapped", [42591]], [[42591, 42591], "valid"], [[42592, 42592], "mapped", [42593]], [[42593, 42593], "valid"], [[42594, 42594], "mapped", [42595]], [[42595, 42595], "valid"], [[42596, 42596], "mapped", [42597]], [[42597, 42597], "valid"], [[42598, 42598], "mapped", [42599]], [[42599, 42599], "valid"], [[42600, 42600], "mapped", [42601]], [[42601, 42601], "valid"], [[42602, 42602], "mapped", [42603]], [[42603, 42603], "valid"], [[42604, 42604], "mapped", [42605]], [[42605, 42607], "valid"], [[42608, 42611], "valid", [], "NV8"], [[42612, 42619], "valid"], [[42620, 42621], "valid"], [[42622, 42622], "valid", [], "NV8"], [[42623, 42623], "valid"], [[42624, 42624], "mapped", [42625]], [[42625, 42625], "valid"], [[42626, 42626], "mapped", [42627]], [[42627, 42627], "valid"], [[42628, 42628], "mapped", [42629]], [[42629, 42629], "valid"], [[42630, 42630], "mapped", [42631]], [[42631, 42631], "valid"], [[42632, 42632], "mapped", [42633]], [[42633, 42633], "valid"], [[42634, 42634], "mapped", [42635]], [[42635, 42635], "valid"], [[42636, 42636], "mapped", [42637]], [[42637, 42637], "valid"], [[42638, 42638], "mapped", [42639]], [[42639, 42639], "valid"], [[42640, 42640], "mapped", [42641]], [[42641, 42641], "valid"], [[42642, 42642], "mapped", [42643]], [[42643, 42643], "valid"], [[42644, 42644], "mapped", [42645]], [[42645, 42645], "valid"], [[42646, 42646], "mapped", [42647]], [[42647, 42647], "valid"], [[42648, 42648], "mapped", [42649]], [[42649, 42649], "valid"], [[42650, 42650], "mapped", [42651]], [[42651, 42651], "valid"], [[42652, 42652], "mapped", [1098]], [[42653, 42653], "mapped", [1100]], [[42654, 42654], "valid"], [[42655, 42655], "valid"], [[42656, 42725], "valid"], [[42726, 42735], "valid", [], "NV8"], [[42736, 42737], "valid"], [[42738, 42743], "valid", [], "NV8"], [[42744, 42751], "disallowed"], [[42752, 42774], "valid", [], "NV8"], [[42775, 42778], "valid"], [[42779, 42783], "valid"], [[42784, 42785], "valid", [], "NV8"], [[42786, 42786], "mapped", [42787]], [[42787, 42787], "valid"], [[42788, 42788], "mapped", [42789]], [[42789, 42789], "valid"], [[42790, 42790], "mapped", [42791]], [[42791, 42791], "valid"], [[42792, 42792], "mapped", [42793]], [[42793, 42793], "valid"], [[42794, 42794], "mapped", [42795]], [[42795, 42795], "valid"], [[42796, 42796], "mapped", [42797]], [[42797, 42797], "valid"], [[42798, 42798], "mapped", [42799]], [[42799, 42801], "valid"], [[42802, 42802], "mapped", [42803]], [[42803, 42803], "valid"], [[42804, 42804], "mapped", [42805]], [[42805, 42805], "valid"], [[42806, 42806], "mapped", [42807]], [[42807, 42807], "valid"], [[42808, 42808], "mapped", [42809]], [[42809, 42809], "valid"], [[42810, 42810], "mapped", [42811]], [[42811, 42811], "valid"], [[42812, 42812], "mapped", [42813]], [[42813, 42813], "valid"], [[42814, 42814], "mapped", [42815]], [[42815, 42815], "valid"], [[42816, 42816], "mapped", [42817]], [[42817, 42817], "valid"], [[42818, 42818], "mapped", [42819]], [[42819, 42819], "valid"], [[42820, 42820], "mapped", [42821]], [[42821, 42821], "valid"], [[42822, 42822], "mapped", [42823]], [[42823, 42823], "valid"], [[42824, 42824], "mapped", [42825]], [[42825, 42825], "valid"], [[42826, 42826], "mapped", [42827]], [[42827, 42827], "valid"], [[42828, 42828], "mapped", [42829]], [[42829, 42829], "valid"], [[42830, 42830], "mapped", [42831]], [[42831, 42831], "valid"], [[42832, 42832], "mapped", [42833]], [[42833, 42833], "valid"], [[42834, 42834], "mapped", [42835]], [[42835, 42835], "valid"], [[42836, 42836], "mapped", [42837]], [[42837, 42837], "valid"], [[42838, 42838], "mapped", [42839]], [[42839, 42839], "valid"], [[42840, 42840], "mapped", [42841]], [[42841, 42841], "valid"], [[42842, 42842], "mapped", [42843]], [[42843, 42843], "valid"], [[42844, 42844], "mapped", [42845]], [[42845, 42845], "valid"], [[42846, 42846], "mapped", [42847]], [[42847, 42847], "valid"], [[42848, 42848], "mapped", [42849]], [[42849, 42849], "valid"], [[42850, 42850], "mapped", [42851]], [[42851, 42851], "valid"], [[42852, 42852], "mapped", [42853]], [[42853, 42853], "valid"], [[42854, 42854], "mapped", [42855]], [[42855, 42855], "valid"], [[42856, 42856], "mapped", [42857]], [[42857, 42857], "valid"], [[42858, 42858], "mapped", [42859]], [[42859, 42859], "valid"], [[42860, 42860], "mapped", [42861]], [[42861, 42861], "valid"], [[42862, 42862], "mapped", [42863]], [[42863, 42863], "valid"], [[42864, 42864], "mapped", [42863]], [[42865, 42872], "valid"], [[42873, 42873], "mapped", [42874]], [[42874, 42874], "valid"], [[42875, 42875], "mapped", [42876]], [[42876, 42876], "valid"], [[42877, 42877], "mapped", [7545]], [[42878, 42878], "mapped", [42879]], [[42879, 42879], "valid"], [[42880, 42880], "mapped", [42881]], [[42881, 42881], "valid"], [[42882, 42882], "mapped", [42883]], [[42883, 42883], "valid"], [[42884, 42884], "mapped", [42885]], [[42885, 42885], "valid"], [[42886, 42886], "mapped", [42887]], [[42887, 42888], "valid"], [[42889, 42890], "valid", [], "NV8"], [[42891, 42891], "mapped", [42892]], [[42892, 42892], "valid"], [[42893, 42893], "mapped", [613]], [[42894, 42894], "valid"], [[42895, 42895], "valid"], [[42896, 42896], "mapped", [42897]], [[42897, 42897], "valid"], [[42898, 42898], "mapped", [42899]], [[42899, 42899], "valid"], [[42900, 42901], "valid"], [[42902, 42902], "mapped", [42903]], [[42903, 42903], "valid"], [[42904, 42904], "mapped", [42905]], [[42905, 42905], "valid"], [[42906, 42906], "mapped", [42907]], [[42907, 42907], "valid"], [[42908, 42908], "mapped", [42909]], [[42909, 42909], "valid"], [[42910, 42910], "mapped", [42911]], [[42911, 42911], "valid"], [[42912, 42912], "mapped", [42913]], [[42913, 42913], "valid"], [[42914, 42914], "mapped", [42915]], [[42915, 42915], "valid"], [[42916, 42916], "mapped", [42917]], [[42917, 42917], "valid"], [[42918, 42918], "mapped", [42919]], [[42919, 42919], "valid"], [[42920, 42920], "mapped", [42921]], [[42921, 42921], "valid"], [[42922, 42922], "mapped", [614]], [[42923, 42923], "mapped", [604]], [[42924, 42924], "mapped", [609]], [[42925, 42925], "mapped", [620]], [[42926, 42927], "disallowed"], [[42928, 42928], "mapped", [670]], [[42929, 42929], "mapped", [647]], [[42930, 42930], "mapped", [669]], [[42931, 42931], "mapped", [43859]], [[42932, 42932], "mapped", [42933]], [[42933, 42933], "valid"], [[42934, 42934], "mapped", [42935]], [[42935, 42935], "valid"], [[42936, 42998], "disallowed"], [[42999, 42999], "valid"], [[43e3, 43e3], "mapped", [295]], [[43001, 43001], "mapped", [339]], [[43002, 43002], "valid"], [[43003, 43007], "valid"], [[43008, 43047], "valid"], [[43048, 43051], "valid", [], "NV8"], [[43052, 43055], "disallowed"], [[43056, 43065], "valid", [], "NV8"], [[43066, 43071], "disallowed"], [[43072, 43123], "valid"], [[43124, 43127], "valid", [], "NV8"], [[43128, 43135], "disallowed"], [[43136, 43204], "valid"], [[43205, 43213], "disallowed"], [[43214, 43215], "valid", [], "NV8"], [[43216, 43225], "valid"], [[43226, 43231], "disallowed"], [[43232, 43255], "valid"], [[43256, 43258], "valid", [], "NV8"], [[43259, 43259], "valid"], [[43260, 43260], "valid", [], "NV8"], [[43261, 43261], "valid"], [[43262, 43263], "disallowed"], [[43264, 43309], "valid"], [[43310, 43311], "valid", [], "NV8"], [[43312, 43347], "valid"], [[43348, 43358], "disallowed"], [[43359, 43359], "valid", [], "NV8"], [[43360, 43388], "valid", [], "NV8"], [[43389, 43391], "disallowed"], [[43392, 43456], "valid"], [[43457, 43469], "valid", [], "NV8"], [[43470, 43470], "disallowed"], [[43471, 43481], "valid"], [[43482, 43485], "disallowed"], [[43486, 43487], "valid", [], "NV8"], [[43488, 43518], "valid"], [[43519, 43519], "disallowed"], [[43520, 43574], "valid"], [[43575, 43583], "disallowed"], [[43584, 43597], "valid"], [[43598, 43599], "disallowed"], [[43600, 43609], "valid"], [[43610, 43611], "disallowed"], [[43612, 43615], "valid", [], "NV8"], [[43616, 43638], "valid"], [[43639, 43641], "valid", [], "NV8"], [[43642, 43643], "valid"], [[43644, 43647], "valid"], [[43648, 43714], "valid"], [[43715, 43738], "disallowed"], [[43739, 43741], "valid"], [[43742, 43743], "valid", [], "NV8"], [[43744, 43759], "valid"], [[43760, 43761], "valid", [], "NV8"], [[43762, 43766], "valid"], [[43767, 43776], "disallowed"], [[43777, 43782], "valid"], [[43783, 43784], "disallowed"], [[43785, 43790], "valid"], [[43791, 43792], "disallowed"], [[43793, 43798], "valid"], [[43799, 43807], "disallowed"], [[43808, 43814], "valid"], [[43815, 43815], "disallowed"], [[43816, 43822], "valid"], [[43823, 43823], "disallowed"], [[43824, 43866], "valid"], [[43867, 43867], "valid", [], "NV8"], [[43868, 43868], "mapped", [42791]], [[43869, 43869], "mapped", [43831]], [[43870, 43870], "mapped", [619]], [[43871, 43871], "mapped", [43858]], [[43872, 43875], "valid"], [[43876, 43877], "valid"], [[43878, 43887], "disallowed"], [[43888, 43888], "mapped", [5024]], [[43889, 43889], "mapped", [5025]], [[43890, 43890], "mapped", [5026]], [[43891, 43891], "mapped", [5027]], [[43892, 43892], "mapped", [5028]], [[43893, 43893], "mapped", [5029]], [[43894, 43894], "mapped", [5030]], [[43895, 43895], "mapped", [5031]], [[43896, 43896], "mapped", [5032]], [[43897, 43897], "mapped", [5033]], [[43898, 43898], "mapped", [5034]], [[43899, 43899], "mapped", [5035]], [[43900, 43900], "mapped", [5036]], [[43901, 43901], "mapped", [5037]], [[43902, 43902], "mapped", [5038]], [[43903, 43903], "mapped", [5039]], [[43904, 43904], "mapped", [5040]], [[43905, 43905], "mapped", [5041]], [[43906, 43906], "mapped", [5042]], [[43907, 43907], "mapped", [5043]], [[43908, 43908], "mapped", [5044]], [[43909, 43909], "mapped", [5045]], [[43910, 43910], "mapped", [5046]], [[43911, 43911], "mapped", [5047]], [[43912, 43912], "mapped", [5048]], [[43913, 43913], "mapped", [5049]], [[43914, 43914], "mapped", [5050]], [[43915, 43915], "mapped", [5051]], [[43916, 43916], "mapped", [5052]], [[43917, 43917], "mapped", [5053]], [[43918, 43918], "mapped", [5054]], [[43919, 43919], "mapped", [5055]], [[43920, 43920], "mapped", [5056]], [[43921, 43921], "mapped", [5057]], [[43922, 43922], "mapped", [5058]], [[43923, 43923], "mapped", [5059]], [[43924, 43924], "mapped", [5060]], [[43925, 43925], "mapped", [5061]], [[43926, 43926], "mapped", [5062]], [[43927, 43927], "mapped", [5063]], [[43928, 43928], "mapped", [5064]], [[43929, 43929], "mapped", [5065]], [[43930, 43930], "mapped", [5066]], [[43931, 43931], "mapped", [5067]], [[43932, 43932], "mapped", [5068]], [[43933, 43933], "mapped", [5069]], [[43934, 43934], "mapped", [5070]], [[43935, 43935], "mapped", [5071]], [[43936, 43936], "mapped", [5072]], [[43937, 43937], "mapped", [5073]], [[43938, 43938], "mapped", [5074]], [[43939, 43939], "mapped", [5075]], [[43940, 43940], "mapped", [5076]], [[43941, 43941], "mapped", [5077]], [[43942, 43942], "mapped", [5078]], [[43943, 43943], "mapped", [5079]], [[43944, 43944], "mapped", [5080]], [[43945, 43945], "mapped", [5081]], [[43946, 43946], "mapped", [5082]], [[43947, 43947], "mapped", [5083]], [[43948, 43948], "mapped", [5084]], [[43949, 43949], "mapped", [5085]], [[43950, 43950], "mapped", [5086]], [[43951, 43951], "mapped", [5087]], [[43952, 43952], "mapped", [5088]], [[43953, 43953], "mapped", [5089]], [[43954, 43954], "mapped", [5090]], [[43955, 43955], "mapped", [5091]], [[43956, 43956], "mapped", [5092]], [[43957, 43957], "mapped", [5093]], [[43958, 43958], "mapped", [5094]], [[43959, 43959], "mapped", [5095]], [[43960, 43960], "mapped", [5096]], [[43961, 43961], "mapped", [5097]], [[43962, 43962], "mapped", [5098]], [[43963, 43963], "mapped", [5099]], [[43964, 43964], "mapped", [5100]], [[43965, 43965], "mapped", [5101]], [[43966, 43966], "mapped", [5102]], [[43967, 43967], "mapped", [5103]], [[43968, 44010], "valid"], [[44011, 44011], "valid", [], "NV8"], [[44012, 44013], "valid"], [[44014, 44015], "disallowed"], [[44016, 44025], "valid"], [[44026, 44031], "disallowed"], [[44032, 55203], "valid"], [[55204, 55215], "disallowed"], [[55216, 55238], "valid", [], "NV8"], [[55239, 55242], "disallowed"], [[55243, 55291], "valid", [], "NV8"], [[55292, 55295], "disallowed"], [[55296, 57343], "disallowed"], [[57344, 63743], "disallowed"], [[63744, 63744], "mapped", [35912]], [[63745, 63745], "mapped", [26356]], [[63746, 63746], "mapped", [36554]], [[63747, 63747], "mapped", [36040]], [[63748, 63748], "mapped", [28369]], [[63749, 63749], "mapped", [20018]], [[63750, 63750], "mapped", [21477]], [[63751, 63752], "mapped", [40860]], [[63753, 63753], "mapped", [22865]], [[63754, 63754], "mapped", [37329]], [[63755, 63755], "mapped", [21895]], [[63756, 63756], "mapped", [22856]], [[63757, 63757], "mapped", [25078]], [[63758, 63758], "mapped", [30313]], [[63759, 63759], "mapped", [32645]], [[63760, 63760], "mapped", [34367]], [[63761, 63761], "mapped", [34746]], [[63762, 63762], "mapped", [35064]], [[63763, 63763], "mapped", [37007]], [[63764, 63764], "mapped", [27138]], [[63765, 63765], "mapped", [27931]], [[63766, 63766], "mapped", [28889]], [[63767, 63767], "mapped", [29662]], [[63768, 63768], "mapped", [33853]], [[63769, 63769], "mapped", [37226]], [[63770, 63770], "mapped", [39409]], [[63771, 63771], "mapped", [20098]], [[63772, 63772], "mapped", [21365]], [[63773, 63773], "mapped", [27396]], [[63774, 63774], "mapped", [29211]], [[63775, 63775], "mapped", [34349]], [[63776, 63776], "mapped", [40478]], [[63777, 63777], "mapped", [23888]], [[63778, 63778], "mapped", [28651]], [[63779, 63779], "mapped", [34253]], [[63780, 63780], "mapped", [35172]], [[63781, 63781], "mapped", [25289]], [[63782, 63782], "mapped", [33240]], [[63783, 63783], "mapped", [34847]], [[63784, 63784], "mapped", [24266]], [[63785, 63785], "mapped", [26391]], [[63786, 63786], "mapped", [28010]], [[63787, 63787], "mapped", [29436]], [[63788, 63788], "mapped", [37070]], [[63789, 63789], "mapped", [20358]], [[63790, 63790], "mapped", [20919]], [[63791, 63791], "mapped", [21214]], [[63792, 63792], "mapped", [25796]], [[63793, 63793], "mapped", [27347]], [[63794, 63794], "mapped", [29200]], [[63795, 63795], "mapped", [30439]], [[63796, 63796], "mapped", [32769]], [[63797, 63797], "mapped", [34310]], [[63798, 63798], "mapped", [34396]], [[63799, 63799], "mapped", [36335]], [[63800, 63800], "mapped", [38706]], [[63801, 63801], "mapped", [39791]], [[63802, 63802], "mapped", [40442]], [[63803, 63803], "mapped", [30860]], [[63804, 63804], "mapped", [31103]], [[63805, 63805], "mapped", [32160]], [[63806, 63806], "mapped", [33737]], [[63807, 63807], "mapped", [37636]], [[63808, 63808], "mapped", [40575]], [[63809, 63809], "mapped", [35542]], [[63810, 63810], "mapped", [22751]], [[63811, 63811], "mapped", [24324]], [[63812, 63812], "mapped", [31840]], [[63813, 63813], "mapped", [32894]], [[63814, 63814], "mapped", [29282]], [[63815, 63815], "mapped", [30922]], [[63816, 63816], "mapped", [36034]], [[63817, 63817], "mapped", [38647]], [[63818, 63818], "mapped", [22744]], [[63819, 63819], "mapped", [23650]], [[63820, 63820], "mapped", [27155]], [[63821, 63821], "mapped", [28122]], [[63822, 63822], "mapped", [28431]], [[63823, 63823], "mapped", [32047]], [[63824, 63824], "mapped", [32311]], [[63825, 63825], "mapped", [38475]], [[63826, 63826], "mapped", [21202]], [[63827, 63827], "mapped", [32907]], [[63828, 63828], "mapped", [20956]], [[63829, 63829], "mapped", [20940]], [[63830, 63830], "mapped", [31260]], [[63831, 63831], "mapped", [32190]], [[63832, 63832], "mapped", [33777]], [[63833, 63833], "mapped", [38517]], [[63834, 63834], "mapped", [35712]], [[63835, 63835], "mapped", [25295]], [[63836, 63836], "mapped", [27138]], [[63837, 63837], "mapped", [35582]], [[63838, 63838], "mapped", [20025]], [[63839, 63839], "mapped", [23527]], [[63840, 63840], "mapped", [24594]], [[63841, 63841], "mapped", [29575]], [[63842, 63842], "mapped", [30064]], [[63843, 63843], "mapped", [21271]], [[63844, 63844], "mapped", [30971]], [[63845, 63845], "mapped", [20415]], [[63846, 63846], "mapped", [24489]], [[63847, 63847], "mapped", [19981]], [[63848, 63848], "mapped", [27852]], [[63849, 63849], "mapped", [25976]], [[63850, 63850], "mapped", [32034]], [[63851, 63851], "mapped", [21443]], [[63852, 63852], "mapped", [22622]], [[63853, 63853], "mapped", [30465]], [[63854, 63854], "mapped", [33865]], [[63855, 63855], "mapped", [35498]], [[63856, 63856], "mapped", [27578]], [[63857, 63857], "mapped", [36784]], [[63858, 63858], "mapped", [27784]], [[63859, 63859], "mapped", [25342]], [[63860, 63860], "mapped", [33509]], [[63861, 63861], "mapped", [25504]], [[63862, 63862], "mapped", [30053]], [[63863, 63863], "mapped", [20142]], [[63864, 63864], "mapped", [20841]], [[63865, 63865], "mapped", [20937]], [[63866, 63866], "mapped", [26753]], [[63867, 63867], "mapped", [31975]], [[63868, 63868], "mapped", [33391]], [[63869, 63869], "mapped", [35538]], [[63870, 63870], "mapped", [37327]], [[63871, 63871], "mapped", [21237]], [[63872, 63872], "mapped", [21570]], [[63873, 63873], "mapped", [22899]], [[63874, 63874], "mapped", [24300]], [[63875, 63875], "mapped", [26053]], [[63876, 63876], "mapped", [28670]], [[63877, 63877], "mapped", [31018]], [[63878, 63878], "mapped", [38317]], [[63879, 63879], "mapped", [39530]], [[63880, 63880], "mapped", [40599]], [[63881, 63881], "mapped", [40654]], [[63882, 63882], "mapped", [21147]], [[63883, 63883], "mapped", [26310]], [[63884, 63884], "mapped", [27511]], [[63885, 63885], "mapped", [36706]], [[63886, 63886], "mapped", [24180]], [[63887, 63887], "mapped", [24976]], [[63888, 63888], "mapped", [25088]], [[63889, 63889], "mapped", [25754]], [[63890, 63890], "mapped", [28451]], [[63891, 63891], "mapped", [29001]], [[63892, 63892], "mapped", [29833]], [[63893, 63893], "mapped", [31178]], [[63894, 63894], "mapped", [32244]], [[63895, 63895], "mapped", [32879]], [[63896, 63896], "mapped", [36646]], [[63897, 63897], "mapped", [34030]], [[63898, 63898], "mapped", [36899]], [[63899, 63899], "mapped", [37706]], [[63900, 63900], "mapped", [21015]], [[63901, 63901], "mapped", [21155]], [[63902, 63902], "mapped", [21693]], [[63903, 63903], "mapped", [28872]], [[63904, 63904], "mapped", [35010]], [[63905, 63905], "mapped", [35498]], [[63906, 63906], "mapped", [24265]], [[63907, 63907], "mapped", [24565]], [[63908, 63908], "mapped", [25467]], [[63909, 63909], "mapped", [27566]], [[63910, 63910], "mapped", [31806]], [[63911, 63911], "mapped", [29557]], [[63912, 63912], "mapped", [20196]], [[63913, 63913], "mapped", [22265]], [[63914, 63914], "mapped", [23527]], [[63915, 63915], "mapped", [23994]], [[63916, 63916], "mapped", [24604]], [[63917, 63917], "mapped", [29618]], [[63918, 63918], "mapped", [29801]], [[63919, 63919], "mapped", [32666]], [[63920, 63920], "mapped", [32838]], [[63921, 63921], "mapped", [37428]], [[63922, 63922], "mapped", [38646]], [[63923, 63923], "mapped", [38728]], [[63924, 63924], "mapped", [38936]], [[63925, 63925], "mapped", [20363]], [[63926, 63926], "mapped", [31150]], [[63927, 63927], "mapped", [37300]], [[63928, 63928], "mapped", [38584]], [[63929, 63929], "mapped", [24801]], [[63930, 63930], "mapped", [20102]], [[63931, 63931], "mapped", [20698]], [[63932, 63932], "mapped", [23534]], [[63933, 63933], "mapped", [23615]], [[63934, 63934], "mapped", [26009]], [[63935, 63935], "mapped", [27138]], [[63936, 63936], "mapped", [29134]], [[63937, 63937], "mapped", [30274]], [[63938, 63938], "mapped", [34044]], [[63939, 63939], "mapped", [36988]], [[63940, 63940], "mapped", [40845]], [[63941, 63941], "mapped", [26248]], [[63942, 63942], "mapped", [38446]], [[63943, 63943], "mapped", [21129]], [[63944, 63944], "mapped", [26491]], [[63945, 63945], "mapped", [26611]], [[63946, 63946], "mapped", [27969]], [[63947, 63947], "mapped", [28316]], [[63948, 63948], "mapped", [29705]], [[63949, 63949], "mapped", [30041]], [[63950, 63950], "mapped", [30827]], [[63951, 63951], "mapped", [32016]], [[63952, 63952], "mapped", [39006]], [[63953, 63953], "mapped", [20845]], [[63954, 63954], "mapped", [25134]], [[63955, 63955], "mapped", [38520]], [[63956, 63956], "mapped", [20523]], [[63957, 63957], "mapped", [23833]], [[63958, 63958], "mapped", [28138]], [[63959, 63959], "mapped", [36650]], [[63960, 63960], "mapped", [24459]], [[63961, 63961], "mapped", [24900]], [[63962, 63962], "mapped", [26647]], [[63963, 63963], "mapped", [29575]], [[63964, 63964], "mapped", [38534]], [[63965, 63965], "mapped", [21033]], [[63966, 63966], "mapped", [21519]], [[63967, 63967], "mapped", [23653]], [[63968, 63968], "mapped", [26131]], [[63969, 63969], "mapped", [26446]], [[63970, 63970], "mapped", [26792]], [[63971, 63971], "mapped", [27877]], [[63972, 63972], "mapped", [29702]], [[63973, 63973], "mapped", [30178]], [[63974, 63974], "mapped", [32633]], [[63975, 63975], "mapped", [35023]], [[63976, 63976], "mapped", [35041]], [[63977, 63977], "mapped", [37324]], [[63978, 63978], "mapped", [38626]], [[63979, 63979], "mapped", [21311]], [[63980, 63980], "mapped", [28346]], [[63981, 63981], "mapped", [21533]], [[63982, 63982], "mapped", [29136]], [[63983, 63983], "mapped", [29848]], [[63984, 63984], "mapped", [34298]], [[63985, 63985], "mapped", [38563]], [[63986, 63986], "mapped", [40023]], [[63987, 63987], "mapped", [40607]], [[63988, 63988], "mapped", [26519]], [[63989, 63989], "mapped", [28107]], [[63990, 63990], "mapped", [33256]], [[63991, 63991], "mapped", [31435]], [[63992, 63992], "mapped", [31520]], [[63993, 63993], "mapped", [31890]], [[63994, 63994], "mapped", [29376]], [[63995, 63995], "mapped", [28825]], [[63996, 63996], "mapped", [35672]], [[63997, 63997], "mapped", [20160]], [[63998, 63998], "mapped", [33590]], [[63999, 63999], "mapped", [21050]], [[64e3, 64e3], "mapped", [20999]], [[64001, 64001], "mapped", [24230]], [[64002, 64002], "mapped", [25299]], [[64003, 64003], "mapped", [31958]], [[64004, 64004], "mapped", [23429]], [[64005, 64005], "mapped", [27934]], [[64006, 64006], "mapped", [26292]], [[64007, 64007], "mapped", [36667]], [[64008, 64008], "mapped", [34892]], [[64009, 64009], "mapped", [38477]], [[64010, 64010], "mapped", [35211]], [[64011, 64011], "mapped", [24275]], [[64012, 64012], "mapped", [20800]], [[64013, 64013], "mapped", [21952]], [[64014, 64015], "valid"], [[64016, 64016], "mapped", [22618]], [[64017, 64017], "valid"], [[64018, 64018], "mapped", [26228]], [[64019, 64020], "valid"], [[64021, 64021], "mapped", [20958]], [[64022, 64022], "mapped", [29482]], [[64023, 64023], "mapped", [30410]], [[64024, 64024], "mapped", [31036]], [[64025, 64025], "mapped", [31070]], [[64026, 64026], "mapped", [31077]], [[64027, 64027], "mapped", [31119]], [[64028, 64028], "mapped", [38742]], [[64029, 64029], "mapped", [31934]], [[64030, 64030], "mapped", [32701]], [[64031, 64031], "valid"], [[64032, 64032], "mapped", [34322]], [[64033, 64033], "valid"], [[64034, 64034], "mapped", [35576]], [[64035, 64036], "valid"], [[64037, 64037], "mapped", [36920]], [[64038, 64038], "mapped", [37117]], [[64039, 64041], "valid"], [[64042, 64042], "mapped", [39151]], [[64043, 64043], "mapped", [39164]], [[64044, 64044], "mapped", [39208]], [[64045, 64045], "mapped", [40372]], [[64046, 64046], "mapped", [37086]], [[64047, 64047], "mapped", [38583]], [[64048, 64048], "mapped", [20398]], [[64049, 64049], "mapped", [20711]], [[64050, 64050], "mapped", [20813]], [[64051, 64051], "mapped", [21193]], [[64052, 64052], "mapped", [21220]], [[64053, 64053], "mapped", [21329]], [[64054, 64054], "mapped", [21917]], [[64055, 64055], "mapped", [22022]], [[64056, 64056], "mapped", [22120]], [[64057, 64057], "mapped", [22592]], [[64058, 64058], "mapped", [22696]], [[64059, 64059], "mapped", [23652]], [[64060, 64060], "mapped", [23662]], [[64061, 64061], "mapped", [24724]], [[64062, 64062], "mapped", [24936]], [[64063, 64063], "mapped", [24974]], [[64064, 64064], "mapped", [25074]], [[64065, 64065], "mapped", [25935]], [[64066, 64066], "mapped", [26082]], [[64067, 64067], "mapped", [26257]], [[64068, 64068], "mapped", [26757]], [[64069, 64069], "mapped", [28023]], [[64070, 64070], "mapped", [28186]], [[64071, 64071], "mapped", [28450]], [[64072, 64072], "mapped", [29038]], [[64073, 64073], "mapped", [29227]], [[64074, 64074], "mapped", [29730]], [[64075, 64075], "mapped", [30865]], [[64076, 64076], "mapped", [31038]], [[64077, 64077], "mapped", [31049]], [[64078, 64078], "mapped", [31048]], [[64079, 64079], "mapped", [31056]], [[64080, 64080], "mapped", [31062]], [[64081, 64081], "mapped", [31069]], [[64082, 64082], "mapped", [31117]], [[64083, 64083], "mapped", [31118]], [[64084, 64084], "mapped", [31296]], [[64085, 64085], "mapped", [31361]], [[64086, 64086], "mapped", [31680]], [[64087, 64087], "mapped", [32244]], [[64088, 64088], "mapped", [32265]], [[64089, 64089], "mapped", [32321]], [[64090, 64090], "mapped", [32626]], [[64091, 64091], "mapped", [32773]], [[64092, 64092], "mapped", [33261]], [[64093, 64094], "mapped", [33401]], [[64095, 64095], "mapped", [33879]], [[64096, 64096], "mapped", [35088]], [[64097, 64097], "mapped", [35222]], [[64098, 64098], "mapped", [35585]], [[64099, 64099], "mapped", [35641]], [[64100, 64100], "mapped", [36051]], [[64101, 64101], "mapped", [36104]], [[64102, 64102], "mapped", [36790]], [[64103, 64103], "mapped", [36920]], [[64104, 64104], "mapped", [38627]], [[64105, 64105], "mapped", [38911]], [[64106, 64106], "mapped", [38971]], [[64107, 64107], "mapped", [24693]], [[64108, 64108], "mapped", [148206]], [[64109, 64109], "mapped", [33304]], [[64110, 64111], "disallowed"], [[64112, 64112], "mapped", [20006]], [[64113, 64113], "mapped", [20917]], [[64114, 64114], "mapped", [20840]], [[64115, 64115], "mapped", [20352]], [[64116, 64116], "mapped", [20805]], [[64117, 64117], "mapped", [20864]], [[64118, 64118], "mapped", [21191]], [[64119, 64119], "mapped", [21242]], [[64120, 64120], "mapped", [21917]], [[64121, 64121], "mapped", [21845]], [[64122, 64122], "mapped", [21913]], [[64123, 64123], "mapped", [21986]], [[64124, 64124], "mapped", [22618]], [[64125, 64125], "mapped", [22707]], [[64126, 64126], "mapped", [22852]], [[64127, 64127], "mapped", [22868]], [[64128, 64128], "mapped", [23138]], [[64129, 64129], "mapped", [23336]], [[64130, 64130], "mapped", [24274]], [[64131, 64131], "mapped", [24281]], [[64132, 64132], "mapped", [24425]], [[64133, 64133], "mapped", [24493]], [[64134, 64134], "mapped", [24792]], [[64135, 64135], "mapped", [24910]], [[64136, 64136], "mapped", [24840]], [[64137, 64137], "mapped", [24974]], [[64138, 64138], "mapped", [24928]], [[64139, 64139], "mapped", [25074]], [[64140, 64140], "mapped", [25140]], [[64141, 64141], "mapped", [25540]], [[64142, 64142], "mapped", [25628]], [[64143, 64143], "mapped", [25682]], [[64144, 64144], "mapped", [25942]], [[64145, 64145], "mapped", [26228]], [[64146, 64146], "mapped", [26391]], [[64147, 64147], "mapped", [26395]], [[64148, 64148], "mapped", [26454]], [[64149, 64149], "mapped", [27513]], [[64150, 64150], "mapped", [27578]], [[64151, 64151], "mapped", [27969]], [[64152, 64152], "mapped", [28379]], [[64153, 64153], "mapped", [28363]], [[64154, 64154], "mapped", [28450]], [[64155, 64155], "mapped", [28702]], [[64156, 64156], "mapped", [29038]], [[64157, 64157], "mapped", [30631]], [[64158, 64158], "mapped", [29237]], [[64159, 64159], "mapped", [29359]], [[64160, 64160], "mapped", [29482]], [[64161, 64161], "mapped", [29809]], [[64162, 64162], "mapped", [29958]], [[64163, 64163], "mapped", [30011]], [[64164, 64164], "mapped", [30237]], [[64165, 64165], "mapped", [30239]], [[64166, 64166], "mapped", [30410]], [[64167, 64167], "mapped", [30427]], [[64168, 64168], "mapped", [30452]], [[64169, 64169], "mapped", [30538]], [[64170, 64170], "mapped", [30528]], [[64171, 64171], "mapped", [30924]], [[64172, 64172], "mapped", [31409]], [[64173, 64173], "mapped", [31680]], [[64174, 64174], "mapped", [31867]], [[64175, 64175], "mapped", [32091]], [[64176, 64176], "mapped", [32244]], [[64177, 64177], "mapped", [32574]], [[64178, 64178], "mapped", [32773]], [[64179, 64179], "mapped", [33618]], [[64180, 64180], "mapped", [33775]], [[64181, 64181], "mapped", [34681]], [[64182, 64182], "mapped", [35137]], [[64183, 64183], "mapped", [35206]], [[64184, 64184], "mapped", [35222]], [[64185, 64185], "mapped", [35519]], [[64186, 64186], "mapped", [35576]], [[64187, 64187], "mapped", [35531]], [[64188, 64188], "mapped", [35585]], [[64189, 64189], "mapped", [35582]], [[64190, 64190], "mapped", [35565]], [[64191, 64191], "mapped", [35641]], [[64192, 64192], "mapped", [35722]], [[64193, 64193], "mapped", [36104]], [[64194, 64194], "mapped", [36664]], [[64195, 64195], "mapped", [36978]], [[64196, 64196], "mapped", [37273]], [[64197, 64197], "mapped", [37494]], [[64198, 64198], "mapped", [38524]], [[64199, 64199], "mapped", [38627]], [[64200, 64200], "mapped", [38742]], [[64201, 64201], "mapped", [38875]], [[64202, 64202], "mapped", [38911]], [[64203, 64203], "mapped", [38923]], [[64204, 64204], "mapped", [38971]], [[64205, 64205], "mapped", [39698]], [[64206, 64206], "mapped", [40860]], [[64207, 64207], "mapped", [141386]], [[64208, 64208], "mapped", [141380]], [[64209, 64209], "mapped", [144341]], [[64210, 64210], "mapped", [15261]], [[64211, 64211], "mapped", [16408]], [[64212, 64212], "mapped", [16441]], [[64213, 64213], "mapped", [152137]], [[64214, 64214], "mapped", [154832]], [[64215, 64215], "mapped", [163539]], [[64216, 64216], "mapped", [40771]], [[64217, 64217], "mapped", [40846]], [[64218, 64255], "disallowed"], [[64256, 64256], "mapped", [102, 102]], [[64257, 64257], "mapped", [102, 105]], [[64258, 64258], "mapped", [102, 108]], [[64259, 64259], "mapped", [102, 102, 105]], [[64260, 64260], "mapped", [102, 102, 108]], [[64261, 64262], "mapped", [115, 116]], [[64263, 64274], "disallowed"], [[64275, 64275], "mapped", [1396, 1398]], [[64276, 64276], "mapped", [1396, 1381]], [[64277, 64277], "mapped", [1396, 1387]], [[64278, 64278], "mapped", [1406, 1398]], [[64279, 64279], "mapped", [1396, 1389]], [[64280, 64284], "disallowed"], [[64285, 64285], "mapped", [1497, 1460]], [[64286, 64286], "valid"], [[64287, 64287], "mapped", [1522, 1463]], [[64288, 64288], "mapped", [1506]], [[64289, 64289], "mapped", [1488]], [[64290, 64290], "mapped", [1491]], [[64291, 64291], "mapped", [1492]], [[64292, 64292], "mapped", [1499]], [[64293, 64293], "mapped", [1500]], [[64294, 64294], "mapped", [1501]], [[64295, 64295], "mapped", [1512]], [[64296, 64296], "mapped", [1514]], [[64297, 64297], "disallowed_STD3_mapped", [43]], [[64298, 64298], "mapped", [1513, 1473]], [[64299, 64299], "mapped", [1513, 1474]], [[64300, 64300], "mapped", [1513, 1468, 1473]], [[64301, 64301], "mapped", [1513, 1468, 1474]], [[64302, 64302], "mapped", [1488, 1463]], [[64303, 64303], "mapped", [1488, 1464]], [[64304, 64304], "mapped", [1488, 1468]], [[64305, 64305], "mapped", [1489, 1468]], [[64306, 64306], "mapped", [1490, 1468]], [[64307, 64307], "mapped", [1491, 1468]], [[64308, 64308], "mapped", [1492, 1468]], [[64309, 64309], "mapped", [1493, 1468]], [[64310, 64310], "mapped", [1494, 1468]], [[64311, 64311], "disallowed"], [[64312, 64312], "mapped", [1496, 1468]], [[64313, 64313], "mapped", [1497, 1468]], [[64314, 64314], "mapped", [1498, 1468]], [[64315, 64315], "mapped", [1499, 1468]], [[64316, 64316], "mapped", [1500, 1468]], [[64317, 64317], "disallowed"], [[64318, 64318], "mapped", [1502, 1468]], [[64319, 64319], "disallowed"], [[64320, 64320], "mapped", [1504, 1468]], [[64321, 64321], "mapped", [1505, 1468]], [[64322, 64322], "disallowed"], [[64323, 64323], "mapped", [1507, 1468]], [[64324, 64324], "mapped", [1508, 1468]], [[64325, 64325], "disallowed"], [[64326, 64326], "mapped", [1510, 1468]], [[64327, 64327], "mapped", [1511, 1468]], [[64328, 64328], "mapped", [1512, 1468]], [[64329, 64329], "mapped", [1513, 1468]], [[64330, 64330], "mapped", [1514, 1468]], [[64331, 64331], "mapped", [1493, 1465]], [[64332, 64332], "mapped", [1489, 1471]], [[64333, 64333], "mapped", [1499, 1471]], [[64334, 64334], "mapped", [1508, 1471]], [[64335, 64335], "mapped", [1488, 1500]], [[64336, 64337], "mapped", [1649]], [[64338, 64341], "mapped", [1659]], [[64342, 64345], "mapped", [1662]], [[64346, 64349], "mapped", [1664]], [[64350, 64353], "mapped", [1658]], [[64354, 64357], "mapped", [1663]], [[64358, 64361], "mapped", [1657]], [[64362, 64365], "mapped", [1700]], [[64366, 64369], "mapped", [1702]], [[64370, 64373], "mapped", [1668]], [[64374, 64377], "mapped", [1667]], [[64378, 64381], "mapped", [1670]], [[64382, 64385], "mapped", [1671]], [[64386, 64387], "mapped", [1677]], [[64388, 64389], "mapped", [1676]], [[64390, 64391], "mapped", [1678]], [[64392, 64393], "mapped", [1672]], [[64394, 64395], "mapped", [1688]], [[64396, 64397], "mapped", [1681]], [[64398, 64401], "mapped", [1705]], [[64402, 64405], "mapped", [1711]], [[64406, 64409], "mapped", [1715]], [[64410, 64413], "mapped", [1713]], [[64414, 64415], "mapped", [1722]], [[64416, 64419], "mapped", [1723]], [[64420, 64421], "mapped", [1728]], [[64422, 64425], "mapped", [1729]], [[64426, 64429], "mapped", [1726]], [[64430, 64431], "mapped", [1746]], [[64432, 64433], "mapped", [1747]], [[64434, 64449], "valid", [], "NV8"], [[64450, 64466], "disallowed"], [[64467, 64470], "mapped", [1709]], [[64471, 64472], "mapped", [1735]], [[64473, 64474], "mapped", [1734]], [[64475, 64476], "mapped", [1736]], [[64477, 64477], "mapped", [1735, 1652]], [[64478, 64479], "mapped", [1739]], [[64480, 64481], "mapped", [1733]], [[64482, 64483], "mapped", [1737]], [[64484, 64487], "mapped", [1744]], [[64488, 64489], "mapped", [1609]], [[64490, 64491], "mapped", [1574, 1575]], [[64492, 64493], "mapped", [1574, 1749]], [[64494, 64495], "mapped", [1574, 1608]], [[64496, 64497], "mapped", [1574, 1735]], [[64498, 64499], "mapped", [1574, 1734]], [[64500, 64501], "mapped", [1574, 1736]], [[64502, 64504], "mapped", [1574, 1744]], [[64505, 64507], "mapped", [1574, 1609]], [[64508, 64511], "mapped", [1740]], [[64512, 64512], "mapped", [1574, 1580]], [[64513, 64513], "mapped", [1574, 1581]], [[64514, 64514], "mapped", [1574, 1605]], [[64515, 64515], "mapped", [1574, 1609]], [[64516, 64516], "mapped", [1574, 1610]], [[64517, 64517], "mapped", [1576, 1580]], [[64518, 64518], "mapped", [1576, 1581]], [[64519, 64519], "mapped", [1576, 1582]], [[64520, 64520], "mapped", [1576, 1605]], [[64521, 64521], "mapped", [1576, 1609]], [[64522, 64522], "mapped", [1576, 1610]], [[64523, 64523], "mapped", [1578, 1580]], [[64524, 64524], "mapped", [1578, 1581]], [[64525, 64525], "mapped", [1578, 1582]], [[64526, 64526], "mapped", [1578, 1605]], [[64527, 64527], "mapped", [1578, 1609]], [[64528, 64528], "mapped", [1578, 1610]], [[64529, 64529], "mapped", [1579, 1580]], [[64530, 64530], "mapped", [1579, 1605]], [[64531, 64531], "mapped", [1579, 1609]], [[64532, 64532], "mapped", [1579, 1610]], [[64533, 64533], "mapped", [1580, 1581]], [[64534, 64534], "mapped", [1580, 1605]], [[64535, 64535], "mapped", [1581, 1580]], [[64536, 64536], "mapped", [1581, 1605]], [[64537, 64537], "mapped", [1582, 1580]], [[64538, 64538], "mapped", [1582, 1581]], [[64539, 64539], "mapped", [1582, 1605]], [[64540, 64540], "mapped", [1587, 1580]], [[64541, 64541], "mapped", [1587, 1581]], [[64542, 64542], "mapped", [1587, 1582]], [[64543, 64543], "mapped", [1587, 1605]], [[64544, 64544], "mapped", [1589, 1581]], [[64545, 64545], "mapped", [1589, 1605]], [[64546, 64546], "mapped", [1590, 1580]], [[64547, 64547], "mapped", [1590, 1581]], [[64548, 64548], "mapped", [1590, 1582]], [[64549, 64549], "mapped", [1590, 1605]], [[64550, 64550], "mapped", [1591, 1581]], [[64551, 64551], "mapped", [1591, 1605]], [[64552, 64552], "mapped", [1592, 1605]], [[64553, 64553], "mapped", [1593, 1580]], [[64554, 64554], "mapped", [1593, 1605]], [[64555, 64555], "mapped", [1594, 1580]], [[64556, 64556], "mapped", [1594, 1605]], [[64557, 64557], "mapped", [1601, 1580]], [[64558, 64558], "mapped", [1601, 1581]], [[64559, 64559], "mapped", [1601, 1582]], [[64560, 64560], "mapped", [1601, 1605]], [[64561, 64561], "mapped", [1601, 1609]], [[64562, 64562], "mapped", [1601, 1610]], [[64563, 64563], "mapped", [1602, 1581]], [[64564, 64564], "mapped", [1602, 1605]], [[64565, 64565], "mapped", [1602, 1609]], [[64566, 64566], "mapped", [1602, 1610]], [[64567, 64567], "mapped", [1603, 1575]], [[64568, 64568], "mapped", [1603, 1580]], [[64569, 64569], "mapped", [1603, 1581]], [[64570, 64570], "mapped", [1603, 1582]], [[64571, 64571], "mapped", [1603, 1604]], [[64572, 64572], "mapped", [1603, 1605]], [[64573, 64573], "mapped", [1603, 1609]], [[64574, 64574], "mapped", [1603, 1610]], [[64575, 64575], "mapped", [1604, 1580]], [[64576, 64576], "mapped", [1604, 1581]], [[64577, 64577], "mapped", [1604, 1582]], [[64578, 64578], "mapped", [1604, 1605]], [[64579, 64579], "mapped", [1604, 1609]], [[64580, 64580], "mapped", [1604, 1610]], [[64581, 64581], "mapped", [1605, 1580]], [[64582, 64582], "mapped", [1605, 1581]], [[64583, 64583], "mapped", [1605, 1582]], [[64584, 64584], "mapped", [1605, 1605]], [[64585, 64585], "mapped", [1605, 1609]], [[64586, 64586], "mapped", [1605, 1610]], [[64587, 64587], "mapped", [1606, 1580]], [[64588, 64588], "mapped", [1606, 1581]], [[64589, 64589], "mapped", [1606, 1582]], [[64590, 64590], "mapped", [1606, 1605]], [[64591, 64591], "mapped", [1606, 1609]], [[64592, 64592], "mapped", [1606, 1610]], [[64593, 64593], "mapped", [1607, 1580]], [[64594, 64594], "mapped", [1607, 1605]], [[64595, 64595], "mapped", [1607, 1609]], [[64596, 64596], "mapped", [1607, 1610]], [[64597, 64597], "mapped", [1610, 1580]], [[64598, 64598], "mapped", [1610, 1581]], [[64599, 64599], "mapped", [1610, 1582]], [[64600, 64600], "mapped", [1610, 1605]], [[64601, 64601], "mapped", [1610, 1609]], [[64602, 64602], "mapped", [1610, 1610]], [[64603, 64603], "mapped", [1584, 1648]], [[64604, 64604], "mapped", [1585, 1648]], [[64605, 64605], "mapped", [1609, 1648]], [[64606, 64606], "disallowed_STD3_mapped", [32, 1612, 1617]], [[64607, 64607], "disallowed_STD3_mapped", [32, 1613, 1617]], [[64608, 64608], "disallowed_STD3_mapped", [32, 1614, 1617]], [[64609, 64609], "disallowed_STD3_mapped", [32, 1615, 1617]], [[64610, 64610], "disallowed_STD3_mapped", [32, 1616, 1617]], [[64611, 64611], "disallowed_STD3_mapped", [32, 1617, 1648]], [[64612, 64612], "mapped", [1574, 1585]], [[64613, 64613], "mapped", [1574, 1586]], [[64614, 64614], "mapped", [1574, 1605]], [[64615, 64615], "mapped", [1574, 1606]], [[64616, 64616], "mapped", [1574, 1609]], [[64617, 64617], "mapped", [1574, 1610]], [[64618, 64618], "mapped", [1576, 1585]], [[64619, 64619], "mapped", [1576, 1586]], [[64620, 64620], "mapped", [1576, 1605]], [[64621, 64621], "mapped", [1576, 1606]], [[64622, 64622], "mapped", [1576, 1609]], [[64623, 64623], "mapped", [1576, 1610]], [[64624, 64624], "mapped", [1578, 1585]], [[64625, 64625], "mapped", [1578, 1586]], [[64626, 64626], "mapped", [1578, 1605]], [[64627, 64627], "mapped", [1578, 1606]], [[64628, 64628], "mapped", [1578, 1609]], [[64629, 64629], "mapped", [1578, 1610]], [[64630, 64630], "mapped", [1579, 1585]], [[64631, 64631], "mapped", [1579, 1586]], [[64632, 64632], "mapped", [1579, 1605]], [[64633, 64633], "mapped", [1579, 1606]], [[64634, 64634], "mapped", [1579, 1609]], [[64635, 64635], "mapped", [1579, 1610]], [[64636, 64636], "mapped", [1601, 1609]], [[64637, 64637], "mapped", [1601, 1610]], [[64638, 64638], "mapped", [1602, 1609]], [[64639, 64639], "mapped", [1602, 1610]], [[64640, 64640], "mapped", [1603, 1575]], [[64641, 64641], "mapped", [1603, 1604]], [[64642, 64642], "mapped", [1603, 1605]], [[64643, 64643], "mapped", [1603, 1609]], [[64644, 64644], "mapped", [1603, 1610]], [[64645, 64645], "mapped", [1604, 1605]], [[64646, 64646], "mapped", [1604, 1609]], [[64647, 64647], "mapped", [1604, 1610]], [[64648, 64648], "mapped", [1605, 1575]], [[64649, 64649], "mapped", [1605, 1605]], [[64650, 64650], "mapped", [1606, 1585]], [[64651, 64651], "mapped", [1606, 1586]], [[64652, 64652], "mapped", [1606, 1605]], [[64653, 64653], "mapped", [1606, 1606]], [[64654, 64654], "mapped", [1606, 1609]], [[64655, 64655], "mapped", [1606, 1610]], [[64656, 64656], "mapped", [1609, 1648]], [[64657, 64657], "mapped", [1610, 1585]], [[64658, 64658], "mapped", [1610, 1586]], [[64659, 64659], "mapped", [1610, 1605]], [[64660, 64660], "mapped", [1610, 1606]], [[64661, 64661], "mapped", [1610, 1609]], [[64662, 64662], "mapped", [1610, 1610]], [[64663, 64663], "mapped", [1574, 1580]], [[64664, 64664], "mapped", [1574, 1581]], [[64665, 64665], "mapped", [1574, 1582]], [[64666, 64666], "mapped", [1574, 1605]], [[64667, 64667], "mapped", [1574, 1607]], [[64668, 64668], "mapped", [1576, 1580]], [[64669, 64669], "mapped", [1576, 1581]], [[64670, 64670], "mapped", [1576, 1582]], [[64671, 64671], "mapped", [1576, 1605]], [[64672, 64672], "mapped", [1576, 1607]], [[64673, 64673], "mapped", [1578, 1580]], [[64674, 64674], "mapped", [1578, 1581]], [[64675, 64675], "mapped", [1578, 1582]], [[64676, 64676], "mapped", [1578, 1605]], [[64677, 64677], "mapped", [1578, 1607]], [[64678, 64678], "mapped", [1579, 1605]], [[64679, 64679], "mapped", [1580, 1581]], [[64680, 64680], "mapped", [1580, 1605]], [[64681, 64681], "mapped", [1581, 1580]], [[64682, 64682], "mapped", [1581, 1605]], [[64683, 64683], "mapped", [1582, 1580]], [[64684, 64684], "mapped", [1582, 1605]], [[64685, 64685], "mapped", [1587, 1580]], [[64686, 64686], "mapped", [1587, 1581]], [[64687, 64687], "mapped", [1587, 1582]], [[64688, 64688], "mapped", [1587, 1605]], [[64689, 64689], "mapped", [1589, 1581]], [[64690, 64690], "mapped", [1589, 1582]], [[64691, 64691], "mapped", [1589, 1605]], [[64692, 64692], "mapped", [1590, 1580]], [[64693, 64693], "mapped", [1590, 1581]], [[64694, 64694], "mapped", [1590, 1582]], [[64695, 64695], "mapped", [1590, 1605]], [[64696, 64696], "mapped", [1591, 1581]], [[64697, 64697], "mapped", [1592, 1605]], [[64698, 64698], "mapped", [1593, 1580]], [[64699, 64699], "mapped", [1593, 1605]], [[64700, 64700], "mapped", [1594, 1580]], [[64701, 64701], "mapped", [1594, 1605]], [[64702, 64702], "mapped", [1601, 1580]], [[64703, 64703], "mapped", [1601, 1581]], [[64704, 64704], "mapped", [1601, 1582]], [[64705, 64705], "mapped", [1601, 1605]], [[64706, 64706], "mapped", [1602, 1581]], [[64707, 64707], "mapped", [1602, 1605]], [[64708, 64708], "mapped", [1603, 1580]], [[64709, 64709], "mapped", [1603, 1581]], [[64710, 64710], "mapped", [1603, 1582]], [[64711, 64711], "mapped", [1603, 1604]], [[64712, 64712], "mapped", [1603, 1605]], [[64713, 64713], "mapped", [1604, 1580]], [[64714, 64714], "mapped", [1604, 1581]], [[64715, 64715], "mapped", [1604, 1582]], [[64716, 64716], "mapped", [1604, 1605]], [[64717, 64717], "mapped", [1604, 1607]], [[64718, 64718], "mapped", [1605, 1580]], [[64719, 64719], "mapped", [1605, 1581]], [[64720, 64720], "mapped", [1605, 1582]], [[64721, 64721], "mapped", [1605, 1605]], [[64722, 64722], "mapped", [1606, 1580]], [[64723, 64723], "mapped", [1606, 1581]], [[64724, 64724], "mapped", [1606, 1582]], [[64725, 64725], "mapped", [1606, 1605]], [[64726, 64726], "mapped", [1606, 1607]], [[64727, 64727], "mapped", [1607, 1580]], [[64728, 64728], "mapped", [1607, 1605]], [[64729, 64729], "mapped", [1607, 1648]], [[64730, 64730], "mapped", [1610, 1580]], [[64731, 64731], "mapped", [1610, 1581]], [[64732, 64732], "mapped", [1610, 1582]], [[64733, 64733], "mapped", [1610, 1605]], [[64734, 64734], "mapped", [1610, 1607]], [[64735, 64735], "mapped", [1574, 1605]], [[64736, 64736], "mapped", [1574, 1607]], [[64737, 64737], "mapped", [1576, 1605]], [[64738, 64738], "mapped", [1576, 1607]], [[64739, 64739], "mapped", [1578, 1605]], [[64740, 64740], "mapped", [1578, 1607]], [[64741, 64741], "mapped", [1579, 1605]], [[64742, 64742], "mapped", [1579, 1607]], [[64743, 64743], "mapped", [1587, 1605]], [[64744, 64744], "mapped", [1587, 1607]], [[64745, 64745], "mapped", [1588, 1605]], [[64746, 64746], "mapped", [1588, 1607]], [[64747, 64747], "mapped", [1603, 1604]], [[64748, 64748], "mapped", [1603, 1605]], [[64749, 64749], "mapped", [1604, 1605]], [[64750, 64750], "mapped", [1606, 1605]], [[64751, 64751], "mapped", [1606, 1607]], [[64752, 64752], "mapped", [1610, 1605]], [[64753, 64753], "mapped", [1610, 1607]], [[64754, 64754], "mapped", [1600, 1614, 1617]], [[64755, 64755], "mapped", [1600, 1615, 1617]], [[64756, 64756], "mapped", [1600, 1616, 1617]], [[64757, 64757], "mapped", [1591, 1609]], [[64758, 64758], "mapped", [1591, 1610]], [[64759, 64759], "mapped", [1593, 1609]], [[64760, 64760], "mapped", [1593, 1610]], [[64761, 64761], "mapped", [1594, 1609]], [[64762, 64762], "mapped", [1594, 1610]], [[64763, 64763], "mapped", [1587, 1609]], [[64764, 64764], "mapped", [1587, 1610]], [[64765, 64765], "mapped", [1588, 1609]], [[64766, 64766], "mapped", [1588, 1610]], [[64767, 64767], "mapped", [1581, 1609]], [[64768, 64768], "mapped", [1581, 1610]], [[64769, 64769], "mapped", [1580, 1609]], [[64770, 64770], "mapped", [1580, 1610]], [[64771, 64771], "mapped", [1582, 1609]], [[64772, 64772], "mapped", [1582, 1610]], [[64773, 64773], "mapped", [1589, 1609]], [[64774, 64774], "mapped", [1589, 1610]], [[64775, 64775], "mapped", [1590, 1609]], [[64776, 64776], "mapped", [1590, 1610]], [[64777, 64777], "mapped", [1588, 1580]], [[64778, 64778], "mapped", [1588, 1581]], [[64779, 64779], "mapped", [1588, 1582]], [[64780, 64780], "mapped", [1588, 1605]], [[64781, 64781], "mapped", [1588, 1585]], [[64782, 64782], "mapped", [1587, 1585]], [[64783, 64783], "mapped", [1589, 1585]], [[64784, 64784], "mapped", [1590, 1585]], [[64785, 64785], "mapped", [1591, 1609]], [[64786, 64786], "mapped", [1591, 1610]], [[64787, 64787], "mapped", [1593, 1609]], [[64788, 64788], "mapped", [1593, 1610]], [[64789, 64789], "mapped", [1594, 1609]], [[64790, 64790], "mapped", [1594, 1610]], [[64791, 64791], "mapped", [1587, 1609]], [[64792, 64792], "mapped", [1587, 1610]], [[64793, 64793], "mapped", [1588, 1609]], [[64794, 64794], "mapped", [1588, 1610]], [[64795, 64795], "mapped", [1581, 1609]], [[64796, 64796], "mapped", [1581, 1610]], [[64797, 64797], "mapped", [1580, 1609]], [[64798, 64798], "mapped", [1580, 1610]], [[64799, 64799], "mapped", [1582, 1609]], [[64800, 64800], "mapped", [1582, 1610]], [[64801, 64801], "mapped", [1589, 1609]], [[64802, 64802], "mapped", [1589, 1610]], [[64803, 64803], "mapped", [1590, 1609]], [[64804, 64804], "mapped", [1590, 1610]], [[64805, 64805], "mapped", [1588, 1580]], [[64806, 64806], "mapped", [1588, 1581]], [[64807, 64807], "mapped", [1588, 1582]], [[64808, 64808], "mapped", [1588, 1605]], [[64809, 64809], "mapped", [1588, 1585]], [[64810, 64810], "mapped", [1587, 1585]], [[64811, 64811], "mapped", [1589, 1585]], [[64812, 64812], "mapped", [1590, 1585]], [[64813, 64813], "mapped", [1588, 1580]], [[64814, 64814], "mapped", [1588, 1581]], [[64815, 64815], "mapped", [1588, 1582]], [[64816, 64816], "mapped", [1588, 1605]], [[64817, 64817], "mapped", [1587, 1607]], [[64818, 64818], "mapped", [1588, 1607]], [[64819, 64819], "mapped", [1591, 1605]], [[64820, 64820], "mapped", [1587, 1580]], [[64821, 64821], "mapped", [1587, 1581]], [[64822, 64822], "mapped", [1587, 1582]], [[64823, 64823], "mapped", [1588, 1580]], [[64824, 64824], "mapped", [1588, 1581]], [[64825, 64825], "mapped", [1588, 1582]], [[64826, 64826], "mapped", [1591, 1605]], [[64827, 64827], "mapped", [1592, 1605]], [[64828, 64829], "mapped", [1575, 1611]], [[64830, 64831], "valid", [], "NV8"], [[64832, 64847], "disallowed"], [[64848, 64848], "mapped", [1578, 1580, 1605]], [[64849, 64850], "mapped", [1578, 1581, 1580]], [[64851, 64851], "mapped", [1578, 1581, 1605]], [[64852, 64852], "mapped", [1578, 1582, 1605]], [[64853, 64853], "mapped", [1578, 1605, 1580]], [[64854, 64854], "mapped", [1578, 1605, 1581]], [[64855, 64855], "mapped", [1578, 1605, 1582]], [[64856, 64857], "mapped", [1580, 1605, 1581]], [[64858, 64858], "mapped", [1581, 1605, 1610]], [[64859, 64859], "mapped", [1581, 1605, 1609]], [[64860, 64860], "mapped", [1587, 1581, 1580]], [[64861, 64861], "mapped", [1587, 1580, 1581]], [[64862, 64862], "mapped", [1587, 1580, 1609]], [[64863, 64864], "mapped", [1587, 1605, 1581]], [[64865, 64865], "mapped", [1587, 1605, 1580]], [[64866, 64867], "mapped", [1587, 1605, 1605]], [[64868, 64869], "mapped", [1589, 1581, 1581]], [[64870, 64870], "mapped", [1589, 1605, 1605]], [[64871, 64872], "mapped", [1588, 1581, 1605]], [[64873, 64873], "mapped", [1588, 1580, 1610]], [[64874, 64875], "mapped", [1588, 1605, 1582]], [[64876, 64877], "mapped", [1588, 1605, 1605]], [[64878, 64878], "mapped", [1590, 1581, 1609]], [[64879, 64880], "mapped", [1590, 1582, 1605]], [[64881, 64882], "mapped", [1591, 1605, 1581]], [[64883, 64883], "mapped", [1591, 1605, 1605]], [[64884, 64884], "mapped", [1591, 1605, 1610]], [[64885, 64885], "mapped", [1593, 1580, 1605]], [[64886, 64887], "mapped", [1593, 1605, 1605]], [[64888, 64888], "mapped", [1593, 1605, 1609]], [[64889, 64889], "mapped", [1594, 1605, 1605]], [[64890, 64890], "mapped", [1594, 1605, 1610]], [[64891, 64891], "mapped", [1594, 1605, 1609]], [[64892, 64893], "mapped", [1601, 1582, 1605]], [[64894, 64894], "mapped", [1602, 1605, 1581]], [[64895, 64895], "mapped", [1602, 1605, 1605]], [[64896, 64896], "mapped", [1604, 1581, 1605]], [[64897, 64897], "mapped", [1604, 1581, 1610]], [[64898, 64898], "mapped", [1604, 1581, 1609]], [[64899, 64900], "mapped", [1604, 1580, 1580]], [[64901, 64902], "mapped", [1604, 1582, 1605]], [[64903, 64904], "mapped", [1604, 1605, 1581]], [[64905, 64905], "mapped", [1605, 1581, 1580]], [[64906, 64906], "mapped", [1605, 1581, 1605]], [[64907, 64907], "mapped", [1605, 1581, 1610]], [[64908, 64908], "mapped", [1605, 1580, 1581]], [[64909, 64909], "mapped", [1605, 1580, 1605]], [[64910, 64910], "mapped", [1605, 1582, 1580]], [[64911, 64911], "mapped", [1605, 1582, 1605]], [[64912, 64913], "disallowed"], [[64914, 64914], "mapped", [1605, 1580, 1582]], [[64915, 64915], "mapped", [1607, 1605, 1580]], [[64916, 64916], "mapped", [1607, 1605, 1605]], [[64917, 64917], "mapped", [1606, 1581, 1605]], [[64918, 64918], "mapped", [1606, 1581, 1609]], [[64919, 64920], "mapped", [1606, 1580, 1605]], [[64921, 64921], "mapped", [1606, 1580, 1609]], [[64922, 64922], "mapped", [1606, 1605, 1610]], [[64923, 64923], "mapped", [1606, 1605, 1609]], [[64924, 64925], "mapped", [1610, 1605, 1605]], [[64926, 64926], "mapped", [1576, 1582, 1610]], [[64927, 64927], "mapped", [1578, 1580, 1610]], [[64928, 64928], "mapped", [1578, 1580, 1609]], [[64929, 64929], "mapped", [1578, 1582, 1610]], [[64930, 64930], "mapped", [1578, 1582, 1609]], [[64931, 64931], "mapped", [1578, 1605, 1610]], [[64932, 64932], "mapped", [1578, 1605, 1609]], [[64933, 64933], "mapped", [1580, 1605, 1610]], [[64934, 64934], "mapped", [1580, 1581, 1609]], [[64935, 64935], "mapped", [1580, 1605, 1609]], [[64936, 64936], "mapped", [1587, 1582, 1609]], [[64937, 64937], "mapped", [1589, 1581, 1610]], [[64938, 64938], "mapped", [1588, 1581, 1610]], [[64939, 64939], "mapped", [1590, 1581, 1610]], [[64940, 64940], "mapped", [1604, 1580, 1610]], [[64941, 64941], "mapped", [1604, 1605, 1610]], [[64942, 64942], "mapped", [1610, 1581, 1610]], [[64943, 64943], "mapped", [1610, 1580, 1610]], [[64944, 64944], "mapped", [1610, 1605, 1610]], [[64945, 64945], "mapped", [1605, 1605, 1610]], [[64946, 64946], "mapped", [1602, 1605, 1610]], [[64947, 64947], "mapped", [1606, 1581, 1610]], [[64948, 64948], "mapped", [1602, 1605, 1581]], [[64949, 64949], "mapped", [1604, 1581, 1605]], [[64950, 64950], "mapped", [1593, 1605, 1610]], [[64951, 64951], "mapped", [1603, 1605, 1610]], [[64952, 64952], "mapped", [1606, 1580, 1581]], [[64953, 64953], "mapped", [1605, 1582, 1610]], [[64954, 64954], "mapped", [1604, 1580, 1605]], [[64955, 64955], "mapped", [1603, 1605, 1605]], [[64956, 64956], "mapped", [1604, 1580, 1605]], [[64957, 64957], "mapped", [1606, 1580, 1581]], [[64958, 64958], "mapped", [1580, 1581, 1610]], [[64959, 64959], "mapped", [1581, 1580, 1610]], [[64960, 64960], "mapped", [1605, 1580, 1610]], [[64961, 64961], "mapped", [1601, 1605, 1610]], [[64962, 64962], "mapped", [1576, 1581, 1610]], [[64963, 64963], "mapped", [1603, 1605, 1605]], [[64964, 64964], "mapped", [1593, 1580, 1605]], [[64965, 64965], "mapped", [1589, 1605, 1605]], [[64966, 64966], "mapped", [1587, 1582, 1610]], [[64967, 64967], "mapped", [1606, 1580, 1610]], [[64968, 64975], "disallowed"], [[64976, 65007], "disallowed"], [[65008, 65008], "mapped", [1589, 1604, 1746]], [[65009, 65009], "mapped", [1602, 1604, 1746]], [[65010, 65010], "mapped", [1575, 1604, 1604, 1607]], [[65011, 65011], "mapped", [1575, 1603, 1576, 1585]], [[65012, 65012], "mapped", [1605, 1581, 1605, 1583]], [[65013, 65013], "mapped", [1589, 1604, 1593, 1605]], [[65014, 65014], "mapped", [1585, 1587, 1608, 1604]], [[65015, 65015], "mapped", [1593, 1604, 1610, 1607]], [[65016, 65016], "mapped", [1608, 1587, 1604, 1605]], [[65017, 65017], "mapped", [1589, 1604, 1609]], [[65018, 65018], "disallowed_STD3_mapped", [1589, 1604, 1609, 32, 1575, 1604, 1604, 1607, 32, 1593, 1604, 1610, 1607, 32, 1608, 1587, 1604, 1605]], [[65019, 65019], "disallowed_STD3_mapped", [1580, 1604, 32, 1580, 1604, 1575, 1604, 1607]], [[65020, 65020], "mapped", [1585, 1740, 1575, 1604]], [[65021, 65021], "valid", [], "NV8"], [[65022, 65023], "disallowed"], [[65024, 65039], "ignored"], [[65040, 65040], "disallowed_STD3_mapped", [44]], [[65041, 65041], "mapped", [12289]], [[65042, 65042], "disallowed"], [[65043, 65043], "disallowed_STD3_mapped", [58]], [[65044, 65044], "disallowed_STD3_mapped", [59]], [[65045, 65045], "disallowed_STD3_mapped", [33]], [[65046, 65046], "disallowed_STD3_mapped", [63]], [[65047, 65047], "mapped", [12310]], [[65048, 65048], "mapped", [12311]], [[65049, 65049], "disallowed"], [[65050, 65055], "disallowed"], [[65056, 65059], "valid"], [[65060, 65062], "valid"], [[65063, 65069], "valid"], [[65070, 65071], "valid"], [[65072, 65072], "disallowed"], [[65073, 65073], "mapped", [8212]], [[65074, 65074], "mapped", [8211]], [[65075, 65076], "disallowed_STD3_mapped", [95]], [[65077, 65077], "disallowed_STD3_mapped", [40]], [[65078, 65078], "disallowed_STD3_mapped", [41]], [[65079, 65079], "disallowed_STD3_mapped", [123]], [[65080, 65080], "disallowed_STD3_mapped", [125]], [[65081, 65081], "mapped", [12308]], [[65082, 65082], "mapped", [12309]], [[65083, 65083], "mapped", [12304]], [[65084, 65084], "mapped", [12305]], [[65085, 65085], "mapped", [12298]], [[65086, 65086], "mapped", [12299]], [[65087, 65087], "mapped", [12296]], [[65088, 65088], "mapped", [12297]], [[65089, 65089], "mapped", [12300]], [[65090, 65090], "mapped", [12301]], [[65091, 65091], "mapped", [12302]], [[65092, 65092], "mapped", [12303]], [[65093, 65094], "valid", [], "NV8"], [[65095, 65095], "disallowed_STD3_mapped", [91]], [[65096, 65096], "disallowed_STD3_mapped", [93]], [[65097, 65100], "disallowed_STD3_mapped", [32, 773]], [[65101, 65103], "disallowed_STD3_mapped", [95]], [[65104, 65104], "disallowed_STD3_mapped", [44]], [[65105, 65105], "mapped", [12289]], [[65106, 65106], "disallowed"], [[65107, 65107], "disallowed"], [[65108, 65108], "disallowed_STD3_mapped", [59]], [[65109, 65109], "disallowed_STD3_mapped", [58]], [[65110, 65110], "disallowed_STD3_mapped", [63]], [[65111, 65111], "disallowed_STD3_mapped", [33]], [[65112, 65112], "mapped", [8212]], [[65113, 65113], "disallowed_STD3_mapped", [40]], [[65114, 65114], "disallowed_STD3_mapped", [41]], [[65115, 65115], "disallowed_STD3_mapped", [123]], [[65116, 65116], "disallowed_STD3_mapped", [125]], [[65117, 65117], "mapped", [12308]], [[65118, 65118], "mapped", [12309]], [[65119, 65119], "disallowed_STD3_mapped", [35]], [[65120, 65120], "disallowed_STD3_mapped", [38]], [[65121, 65121], "disallowed_STD3_mapped", [42]], [[65122, 65122], "disallowed_STD3_mapped", [43]], [[65123, 65123], "mapped", [45]], [[65124, 65124], "disallowed_STD3_mapped", [60]], [[65125, 65125], "disallowed_STD3_mapped", [62]], [[65126, 65126], "disallowed_STD3_mapped", [61]], [[65127, 65127], "disallowed"], [[65128, 65128], "disallowed_STD3_mapped", [92]], [[65129, 65129], "disallowed_STD3_mapped", [36]], [[65130, 65130], "disallowed_STD3_mapped", [37]], [[65131, 65131], "disallowed_STD3_mapped", [64]], [[65132, 65135], "disallowed"], [[65136, 65136], "disallowed_STD3_mapped", [32, 1611]], [[65137, 65137], "mapped", [1600, 1611]], [[65138, 65138], "disallowed_STD3_mapped", [32, 1612]], [[65139, 65139], "valid"], [[65140, 65140], "disallowed_STD3_mapped", [32, 1613]], [[65141, 65141], "disallowed"], [[65142, 65142], "disallowed_STD3_mapped", [32, 1614]], [[65143, 65143], "mapped", [1600, 1614]], [[65144, 65144], "disallowed_STD3_mapped", [32, 1615]], [[65145, 65145], "mapped", [1600, 1615]], [[65146, 65146], "disallowed_STD3_mapped", [32, 1616]], [[65147, 65147], "mapped", [1600, 1616]], [[65148, 65148], "disallowed_STD3_mapped", [32, 1617]], [[65149, 65149], "mapped", [1600, 1617]], [[65150, 65150], "disallowed_STD3_mapped", [32, 1618]], [[65151, 65151], "mapped", [1600, 1618]], [[65152, 65152], "mapped", [1569]], [[65153, 65154], "mapped", [1570]], [[65155, 65156], "mapped", [1571]], [[65157, 65158], "mapped", [1572]], [[65159, 65160], "mapped", [1573]], [[65161, 65164], "mapped", [1574]], [[65165, 65166], "mapped", [1575]], [[65167, 65170], "mapped", [1576]], [[65171, 65172], "mapped", [1577]], [[65173, 65176], "mapped", [1578]], [[65177, 65180], "mapped", [1579]], [[65181, 65184], "mapped", [1580]], [[65185, 65188], "mapped", [1581]], [[65189, 65192], "mapped", [1582]], [[65193, 65194], "mapped", [1583]], [[65195, 65196], "mapped", [1584]], [[65197, 65198], "mapped", [1585]], [[65199, 65200], "mapped", [1586]], [[65201, 65204], "mapped", [1587]], [[65205, 65208], "mapped", [1588]], [[65209, 65212], "mapped", [1589]], [[65213, 65216], "mapped", [1590]], [[65217, 65220], "mapped", [1591]], [[65221, 65224], "mapped", [1592]], [[65225, 65228], "mapped", [1593]], [[65229, 65232], "mapped", [1594]], [[65233, 65236], "mapped", [1601]], [[65237, 65240], "mapped", [1602]], [[65241, 65244], "mapped", [1603]], [[65245, 65248], "mapped", [1604]], [[65249, 65252], "mapped", [1605]], [[65253, 65256], "mapped", [1606]], [[65257, 65260], "mapped", [1607]], [[65261, 65262], "mapped", [1608]], [[65263, 65264], "mapped", [1609]], [[65265, 65268], "mapped", [1610]], [[65269, 65270], "mapped", [1604, 1570]], [[65271, 65272], "mapped", [1604, 1571]], [[65273, 65274], "mapped", [1604, 1573]], [[65275, 65276], "mapped", [1604, 1575]], [[65277, 65278], "disallowed"], [[65279, 65279], "ignored"], [[65280, 65280], "disallowed"], [[65281, 65281], "disallowed_STD3_mapped", [33]], [[65282, 65282], "disallowed_STD3_mapped", [34]], [[65283, 65283], "disallowed_STD3_mapped", [35]], [[65284, 65284], "disallowed_STD3_mapped", [36]], [[65285, 65285], "disallowed_STD3_mapped", [37]], [[65286, 65286], "disallowed_STD3_mapped", [38]], [[65287, 65287], "disallowed_STD3_mapped", [39]], [[65288, 65288], "disallowed_STD3_mapped", [40]], [[65289, 65289], "disallowed_STD3_mapped", [41]], [[65290, 65290], "disallowed_STD3_mapped", [42]], [[65291, 65291], "disallowed_STD3_mapped", [43]], [[65292, 65292], "disallowed_STD3_mapped", [44]], [[65293, 65293], "mapped", [45]], [[65294, 65294], "mapped", [46]], [[65295, 65295], "disallowed_STD3_mapped", [47]], [[65296, 65296], "mapped", [48]], [[65297, 65297], "mapped", [49]], [[65298, 65298], "mapped", [50]], [[65299, 65299], "mapped", [51]], [[65300, 65300], "mapped", [52]], [[65301, 65301], "mapped", [53]], [[65302, 65302], "mapped", [54]], [[65303, 65303], "mapped", [55]], [[65304, 65304], "mapped", [56]], [[65305, 65305], "mapped", [57]], [[65306, 65306], "disallowed_STD3_mapped", [58]], [[65307, 65307], "disallowed_STD3_mapped", [59]], [[65308, 65308], "disallowed_STD3_mapped", [60]], [[65309, 65309], "disallowed_STD3_mapped", [61]], [[65310, 65310], "disallowed_STD3_mapped", [62]], [[65311, 65311], "disallowed_STD3_mapped", [63]], [[65312, 65312], "disallowed_STD3_mapped", [64]], [[65313, 65313], "mapped", [97]], [[65314, 65314], "mapped", [98]], [[65315, 65315], "mapped", [99]], [[65316, 65316], "mapped", [100]], [[65317, 65317], "mapped", [101]], [[65318, 65318], "mapped", [102]], [[65319, 65319], "mapped", [103]], [[65320, 65320], "mapped", [104]], [[65321, 65321], "mapped", [105]], [[65322, 65322], "mapped", [106]], [[65323, 65323], "mapped", [107]], [[65324, 65324], "mapped", [108]], [[65325, 65325], "mapped", [109]], [[65326, 65326], "mapped", [110]], [[65327, 65327], "mapped", [111]], [[65328, 65328], "mapped", [112]], [[65329, 65329], "mapped", [113]], [[65330, 65330], "mapped", [114]], [[65331, 65331], "mapped", [115]], [[65332, 65332], "mapped", [116]], [[65333, 65333], "mapped", [117]], [[65334, 65334], "mapped", [118]], [[65335, 65335], "mapped", [119]], [[65336, 65336], "mapped", [120]], [[65337, 65337], "mapped", [121]], [[65338, 65338], "mapped", [122]], [[65339, 65339], "disallowed_STD3_mapped", [91]], [[65340, 65340], "disallowed_STD3_mapped", [92]], [[65341, 65341], "disallowed_STD3_mapped", [93]], [[65342, 65342], "disallowed_STD3_mapped", [94]], [[65343, 65343], "disallowed_STD3_mapped", [95]], [[65344, 65344], "disallowed_STD3_mapped", [96]], [[65345, 65345], "mapped", [97]], [[65346, 65346], "mapped", [98]], [[65347, 65347], "mapped", [99]], [[65348, 65348], "mapped", [100]], [[65349, 65349], "mapped", [101]], [[65350, 65350], "mapped", [102]], [[65351, 65351], "mapped", [103]], [[65352, 65352], "mapped", [104]], [[65353, 65353], "mapped", [105]], [[65354, 65354], "mapped", [106]], [[65355, 65355], "mapped", [107]], [[65356, 65356], "mapped", [108]], [[65357, 65357], "mapped", [109]], [[65358, 65358], "mapped", [110]], [[65359, 65359], "mapped", [111]], [[65360, 65360], "mapped", [112]], [[65361, 65361], "mapped", [113]], [[65362, 65362], "mapped", [114]], [[65363, 65363], "mapped", [115]], [[65364, 65364], "mapped", [116]], [[65365, 65365], "mapped", [117]], [[65366, 65366], "mapped", [118]], [[65367, 65367], "mapped", [119]], [[65368, 65368], "mapped", [120]], [[65369, 65369], "mapped", [121]], [[65370, 65370], "mapped", [122]], [[65371, 65371], "disallowed_STD3_mapped", [123]], [[65372, 65372], "disallowed_STD3_mapped", [124]], [[65373, 65373], "disallowed_STD3_mapped", [125]], [[65374, 65374], "disallowed_STD3_mapped", [126]], [[65375, 65375], "mapped", [10629]], [[65376, 65376], "mapped", [10630]], [[65377, 65377], "mapped", [46]], [[65378, 65378], "mapped", [12300]], [[65379, 65379], "mapped", [12301]], [[65380, 65380], "mapped", [12289]], [[65381, 65381], "mapped", [12539]], [[65382, 65382], "mapped", [12530]], [[65383, 65383], "mapped", [12449]], [[65384, 65384], "mapped", [12451]], [[65385, 65385], "mapped", [12453]], [[65386, 65386], "mapped", [12455]], [[65387, 65387], "mapped", [12457]], [[65388, 65388], "mapped", [12515]], [[65389, 65389], "mapped", [12517]], [[65390, 65390], "mapped", [12519]], [[65391, 65391], "mapped", [12483]], [[65392, 65392], "mapped", [12540]], [[65393, 65393], "mapped", [12450]], [[65394, 65394], "mapped", [12452]], [[65395, 65395], "mapped", [12454]], [[65396, 65396], "mapped", [12456]], [[65397, 65397], "mapped", [12458]], [[65398, 65398], "mapped", [12459]], [[65399, 65399], "mapped", [12461]], [[65400, 65400], "mapped", [12463]], [[65401, 65401], "mapped", [12465]], [[65402, 65402], "mapped", [12467]], [[65403, 65403], "mapped", [12469]], [[65404, 65404], "mapped", [12471]], [[65405, 65405], "mapped", [12473]], [[65406, 65406], "mapped", [12475]], [[65407, 65407], "mapped", [12477]], [[65408, 65408], "mapped", [12479]], [[65409, 65409], "mapped", [12481]], [[65410, 65410], "mapped", [12484]], [[65411, 65411], "mapped", [12486]], [[65412, 65412], "mapped", [12488]], [[65413, 65413], "mapped", [12490]], [[65414, 65414], "mapped", [12491]], [[65415, 65415], "mapped", [12492]], [[65416, 65416], "mapped", [12493]], [[65417, 65417], "mapped", [12494]], [[65418, 65418], "mapped", [12495]], [[65419, 65419], "mapped", [12498]], [[65420, 65420], "mapped", [12501]], [[65421, 65421], "mapped", [12504]], [[65422, 65422], "mapped", [12507]], [[65423, 65423], "mapped", [12510]], [[65424, 65424], "mapped", [12511]], [[65425, 65425], "mapped", [12512]], [[65426, 65426], "mapped", [12513]], [[65427, 65427], "mapped", [12514]], [[65428, 65428], "mapped", [12516]], [[65429, 65429], "mapped", [12518]], [[65430, 65430], "mapped", [12520]], [[65431, 65431], "mapped", [12521]], [[65432, 65432], "mapped", [12522]], [[65433, 65433], "mapped", [12523]], [[65434, 65434], "mapped", [12524]], [[65435, 65435], "mapped", [12525]], [[65436, 65436], "mapped", [12527]], [[65437, 65437], "mapped", [12531]], [[65438, 65438], "mapped", [12441]], [[65439, 65439], "mapped", [12442]], [[65440, 65440], "disallowed"], [[65441, 65441], "mapped", [4352]], [[65442, 65442], "mapped", [4353]], [[65443, 65443], "mapped", [4522]], [[65444, 65444], "mapped", [4354]], [[65445, 65445], "mapped", [4524]], [[65446, 65446], "mapped", [4525]], [[65447, 65447], "mapped", [4355]], [[65448, 65448], "mapped", [4356]], [[65449, 65449], "mapped", [4357]], [[65450, 65450], "mapped", [4528]], [[65451, 65451], "mapped", [4529]], [[65452, 65452], "mapped", [4530]], [[65453, 65453], "mapped", [4531]], [[65454, 65454], "mapped", [4532]], [[65455, 65455], "mapped", [4533]], [[65456, 65456], "mapped", [4378]], [[65457, 65457], "mapped", [4358]], [[65458, 65458], "mapped", [4359]], [[65459, 65459], "mapped", [4360]], [[65460, 65460], "mapped", [4385]], [[65461, 65461], "mapped", [4361]], [[65462, 65462], "mapped", [4362]], [[65463, 65463], "mapped", [4363]], [[65464, 65464], "mapped", [4364]], [[65465, 65465], "mapped", [4365]], [[65466, 65466], "mapped", [4366]], [[65467, 65467], "mapped", [4367]], [[65468, 65468], "mapped", [4368]], [[65469, 65469], "mapped", [4369]], [[65470, 65470], "mapped", [4370]], [[65471, 65473], "disallowed"], [[65474, 65474], "mapped", [4449]], [[65475, 65475], "mapped", [4450]], [[65476, 65476], "mapped", [4451]], [[65477, 65477], "mapped", [4452]], [[65478, 65478], "mapped", [4453]], [[65479, 65479], "mapped", [4454]], [[65480, 65481], "disallowed"], [[65482, 65482], "mapped", [4455]], [[65483, 65483], "mapped", [4456]], [[65484, 65484], "mapped", [4457]], [[65485, 65485], "mapped", [4458]], [[65486, 65486], "mapped", [4459]], [[65487, 65487], "mapped", [4460]], [[65488, 65489], "disallowed"], [[65490, 65490], "mapped", [4461]], [[65491, 65491], "mapped", [4462]], [[65492, 65492], "mapped", [4463]], [[65493, 65493], "mapped", [4464]], [[65494, 65494], "mapped", [4465]], [[65495, 65495], "mapped", [4466]], [[65496, 65497], "disallowed"], [[65498, 65498], "mapped", [4467]], [[65499, 65499], "mapped", [4468]], [[65500, 65500], "mapped", [4469]], [[65501, 65503], "disallowed"], [[65504, 65504], "mapped", [162]], [[65505, 65505], "mapped", [163]], [[65506, 65506], "mapped", [172]], [[65507, 65507], "disallowed_STD3_mapped", [32, 772]], [[65508, 65508], "mapped", [166]], [[65509, 65509], "mapped", [165]], [[65510, 65510], "mapped", [8361]], [[65511, 65511], "disallowed"], [[65512, 65512], "mapped", [9474]], [[65513, 65513], "mapped", [8592]], [[65514, 65514], "mapped", [8593]], [[65515, 65515], "mapped", [8594]], [[65516, 65516], "mapped", [8595]], [[65517, 65517], "mapped", [9632]], [[65518, 65518], "mapped", [9675]], [[65519, 65528], "disallowed"], [[65529, 65531], "disallowed"], [[65532, 65532], "disallowed"], [[65533, 65533], "disallowed"], [[65534, 65535], "disallowed"], [[65536, 65547], "valid"], [[65548, 65548], "disallowed"], [[65549, 65574], "valid"], [[65575, 65575], "disallowed"], [[65576, 65594], "valid"], [[65595, 65595], "disallowed"], [[65596, 65597], "valid"], [[65598, 65598], "disallowed"], [[65599, 65613], "valid"], [[65614, 65615], "disallowed"], [[65616, 65629], "valid"], [[65630, 65663], "disallowed"], [[65664, 65786], "valid"], [[65787, 65791], "disallowed"], [[65792, 65794], "valid", [], "NV8"], [[65795, 65798], "disallowed"], [[65799, 65843], "valid", [], "NV8"], [[65844, 65846], "disallowed"], [[65847, 65855], "valid", [], "NV8"], [[65856, 65930], "valid", [], "NV8"], [[65931, 65932], "valid", [], "NV8"], [[65933, 65935], "disallowed"], [[65936, 65947], "valid", [], "NV8"], [[65948, 65951], "disallowed"], [[65952, 65952], "valid", [], "NV8"], [[65953, 65999], "disallowed"], [[66e3, 66044], "valid", [], "NV8"], [[66045, 66045], "valid"], [[66046, 66175], "disallowed"], [[66176, 66204], "valid"], [[66205, 66207], "disallowed"], [[66208, 66256], "valid"], [[66257, 66271], "disallowed"], [[66272, 66272], "valid"], [[66273, 66299], "valid", [], "NV8"], [[66300, 66303], "disallowed"], [[66304, 66334], "valid"], [[66335, 66335], "valid"], [[66336, 66339], "valid", [], "NV8"], [[66340, 66351], "disallowed"], [[66352, 66368], "valid"], [[66369, 66369], "valid", [], "NV8"], [[66370, 66377], "valid"], [[66378, 66378], "valid", [], "NV8"], [[66379, 66383], "disallowed"], [[66384, 66426], "valid"], [[66427, 66431], "disallowed"], [[66432, 66461], "valid"], [[66462, 66462], "disallowed"], [[66463, 66463], "valid", [], "NV8"], [[66464, 66499], "valid"], [[66500, 66503], "disallowed"], [[66504, 66511], "valid"], [[66512, 66517], "valid", [], "NV8"], [[66518, 66559], "disallowed"], [[66560, 66560], "mapped", [66600]], [[66561, 66561], "mapped", [66601]], [[66562, 66562], "mapped", [66602]], [[66563, 66563], "mapped", [66603]], [[66564, 66564], "mapped", [66604]], [[66565, 66565], "mapped", [66605]], [[66566, 66566], "mapped", [66606]], [[66567, 66567], "mapped", [66607]], [[66568, 66568], "mapped", [66608]], [[66569, 66569], "mapped", [66609]], [[66570, 66570], "mapped", [66610]], [[66571, 66571], "mapped", [66611]], [[66572, 66572], "mapped", [66612]], [[66573, 66573], "mapped", [66613]], [[66574, 66574], "mapped", [66614]], [[66575, 66575], "mapped", [66615]], [[66576, 66576], "mapped", [66616]], [[66577, 66577], "mapped", [66617]], [[66578, 66578], "mapped", [66618]], [[66579, 66579], "mapped", [66619]], [[66580, 66580], "mapped", [66620]], [[66581, 66581], "mapped", [66621]], [[66582, 66582], "mapped", [66622]], [[66583, 66583], "mapped", [66623]], [[66584, 66584], "mapped", [66624]], [[66585, 66585], "mapped", [66625]], [[66586, 66586], "mapped", [66626]], [[66587, 66587], "mapped", [66627]], [[66588, 66588], "mapped", [66628]], [[66589, 66589], "mapped", [66629]], [[66590, 66590], "mapped", [66630]], [[66591, 66591], "mapped", [66631]], [[66592, 66592], "mapped", [66632]], [[66593, 66593], "mapped", [66633]], [[66594, 66594], "mapped", [66634]], [[66595, 66595], "mapped", [66635]], [[66596, 66596], "mapped", [66636]], [[66597, 66597], "mapped", [66637]], [[66598, 66598], "mapped", [66638]], [[66599, 66599], "mapped", [66639]], [[66600, 66637], "valid"], [[66638, 66717], "valid"], [[66718, 66719], "disallowed"], [[66720, 66729], "valid"], [[66730, 66815], "disallowed"], [[66816, 66855], "valid"], [[66856, 66863], "disallowed"], [[66864, 66915], "valid"], [[66916, 66926], "disallowed"], [[66927, 66927], "valid", [], "NV8"], [[66928, 67071], "disallowed"], [[67072, 67382], "valid"], [[67383, 67391], "disallowed"], [[67392, 67413], "valid"], [[67414, 67423], "disallowed"], [[67424, 67431], "valid"], [[67432, 67583], "disallowed"], [[67584, 67589], "valid"], [[67590, 67591], "disallowed"], [[67592, 67592], "valid"], [[67593, 67593], "disallowed"], [[67594, 67637], "valid"], [[67638, 67638], "disallowed"], [[67639, 67640], "valid"], [[67641, 67643], "disallowed"], [[67644, 67644], "valid"], [[67645, 67646], "disallowed"], [[67647, 67647], "valid"], [[67648, 67669], "valid"], [[67670, 67670], "disallowed"], [[67671, 67679], "valid", [], "NV8"], [[67680, 67702], "valid"], [[67703, 67711], "valid", [], "NV8"], [[67712, 67742], "valid"], [[67743, 67750], "disallowed"], [[67751, 67759], "valid", [], "NV8"], [[67760, 67807], "disallowed"], [[67808, 67826], "valid"], [[67827, 67827], "disallowed"], [[67828, 67829], "valid"], [[67830, 67834], "disallowed"], [[67835, 67839], "valid", [], "NV8"], [[67840, 67861], "valid"], [[67862, 67865], "valid", [], "NV8"], [[67866, 67867], "valid", [], "NV8"], [[67868, 67870], "disallowed"], [[67871, 67871], "valid", [], "NV8"], [[67872, 67897], "valid"], [[67898, 67902], "disallowed"], [[67903, 67903], "valid", [], "NV8"], [[67904, 67967], "disallowed"], [[67968, 68023], "valid"], [[68024, 68027], "disallowed"], [[68028, 68029], "valid", [], "NV8"], [[68030, 68031], "valid"], [[68032, 68047], "valid", [], "NV8"], [[68048, 68049], "disallowed"], [[68050, 68095], "valid", [], "NV8"], [[68096, 68099], "valid"], [[68100, 68100], "disallowed"], [[68101, 68102], "valid"], [[68103, 68107], "disallowed"], [[68108, 68115], "valid"], [[68116, 68116], "disallowed"], [[68117, 68119], "valid"], [[68120, 68120], "disallowed"], [[68121, 68147], "valid"], [[68148, 68151], "disallowed"], [[68152, 68154], "valid"], [[68155, 68158], "disallowed"], [[68159, 68159], "valid"], [[68160, 68167], "valid", [], "NV8"], [[68168, 68175], "disallowed"], [[68176, 68184], "valid", [], "NV8"], [[68185, 68191], "disallowed"], [[68192, 68220], "valid"], [[68221, 68223], "valid", [], "NV8"], [[68224, 68252], "valid"], [[68253, 68255], "valid", [], "NV8"], [[68256, 68287], "disallowed"], [[68288, 68295], "valid"], [[68296, 68296], "valid", [], "NV8"], [[68297, 68326], "valid"], [[68327, 68330], "disallowed"], [[68331, 68342], "valid", [], "NV8"], [[68343, 68351], "disallowed"], [[68352, 68405], "valid"], [[68406, 68408], "disallowed"], [[68409, 68415], "valid", [], "NV8"], [[68416, 68437], "valid"], [[68438, 68439], "disallowed"], [[68440, 68447], "valid", [], "NV8"], [[68448, 68466], "valid"], [[68467, 68471], "disallowed"], [[68472, 68479], "valid", [], "NV8"], [[68480, 68497], "valid"], [[68498, 68504], "disallowed"], [[68505, 68508], "valid", [], "NV8"], [[68509, 68520], "disallowed"], [[68521, 68527], "valid", [], "NV8"], [[68528, 68607], "disallowed"], [[68608, 68680], "valid"], [[68681, 68735], "disallowed"], [[68736, 68736], "mapped", [68800]], [[68737, 68737], "mapped", [68801]], [[68738, 68738], "mapped", [68802]], [[68739, 68739], "mapped", [68803]], [[68740, 68740], "mapped", [68804]], [[68741, 68741], "mapped", [68805]], [[68742, 68742], "mapped", [68806]], [[68743, 68743], "mapped", [68807]], [[68744, 68744], "mapped", [68808]], [[68745, 68745], "mapped", [68809]], [[68746, 68746], "mapped", [68810]], [[68747, 68747], "mapped", [68811]], [[68748, 68748], "mapped", [68812]], [[68749, 68749], "mapped", [68813]], [[68750, 68750], "mapped", [68814]], [[68751, 68751], "mapped", [68815]], [[68752, 68752], "mapped", [68816]], [[68753, 68753], "mapped", [68817]], [[68754, 68754], "mapped", [68818]], [[68755, 68755], "mapped", [68819]], [[68756, 68756], "mapped", [68820]], [[68757, 68757], "mapped", [68821]], [[68758, 68758], "mapped", [68822]], [[68759, 68759], "mapped", [68823]], [[68760, 68760], "mapped", [68824]], [[68761, 68761], "mapped", [68825]], [[68762, 68762], "mapped", [68826]], [[68763, 68763], "mapped", [68827]], [[68764, 68764], "mapped", [68828]], [[68765, 68765], "mapped", [68829]], [[68766, 68766], "mapped", [68830]], [[68767, 68767], "mapped", [68831]], [[68768, 68768], "mapped", [68832]], [[68769, 68769], "mapped", [68833]], [[68770, 68770], "mapped", [68834]], [[68771, 68771], "mapped", [68835]], [[68772, 68772], "mapped", [68836]], [[68773, 68773], "mapped", [68837]], [[68774, 68774], "mapped", [68838]], [[68775, 68775], "mapped", [68839]], [[68776, 68776], "mapped", [68840]], [[68777, 68777], "mapped", [68841]], [[68778, 68778], "mapped", [68842]], [[68779, 68779], "mapped", [68843]], [[68780, 68780], "mapped", [68844]], [[68781, 68781], "mapped", [68845]], [[68782, 68782], "mapped", [68846]], [[68783, 68783], "mapped", [68847]], [[68784, 68784], "mapped", [68848]], [[68785, 68785], "mapped", [68849]], [[68786, 68786], "mapped", [68850]], [[68787, 68799], "disallowed"], [[68800, 68850], "valid"], [[68851, 68857], "disallowed"], [[68858, 68863], "valid", [], "NV8"], [[68864, 69215], "disallowed"], [[69216, 69246], "valid", [], "NV8"], [[69247, 69631], "disallowed"], [[69632, 69702], "valid"], [[69703, 69709], "valid", [], "NV8"], [[69710, 69713], "disallowed"], [[69714, 69733], "valid", [], "NV8"], [[69734, 69743], "valid"], [[69744, 69758], "disallowed"], [[69759, 69759], "valid"], [[69760, 69818], "valid"], [[69819, 69820], "valid", [], "NV8"], [[69821, 69821], "disallowed"], [[69822, 69825], "valid", [], "NV8"], [[69826, 69839], "disallowed"], [[69840, 69864], "valid"], [[69865, 69871], "disallowed"], [[69872, 69881], "valid"], [[69882, 69887], "disallowed"], [[69888, 69940], "valid"], [[69941, 69941], "disallowed"], [[69942, 69951], "valid"], [[69952, 69955], "valid", [], "NV8"], [[69956, 69967], "disallowed"], [[69968, 70003], "valid"], [[70004, 70005], "valid", [], "NV8"], [[70006, 70006], "valid"], [[70007, 70015], "disallowed"], [[70016, 70084], "valid"], [[70085, 70088], "valid", [], "NV8"], [[70089, 70089], "valid", [], "NV8"], [[70090, 70092], "valid"], [[70093, 70093], "valid", [], "NV8"], [[70094, 70095], "disallowed"], [[70096, 70105], "valid"], [[70106, 70106], "valid"], [[70107, 70107], "valid", [], "NV8"], [[70108, 70108], "valid"], [[70109, 70111], "valid", [], "NV8"], [[70112, 70112], "disallowed"], [[70113, 70132], "valid", [], "NV8"], [[70133, 70143], "disallowed"], [[70144, 70161], "valid"], [[70162, 70162], "disallowed"], [[70163, 70199], "valid"], [[70200, 70205], "valid", [], "NV8"], [[70206, 70271], "disallowed"], [[70272, 70278], "valid"], [[70279, 70279], "disallowed"], [[70280, 70280], "valid"], [[70281, 70281], "disallowed"], [[70282, 70285], "valid"], [[70286, 70286], "disallowed"], [[70287, 70301], "valid"], [[70302, 70302], "disallowed"], [[70303, 70312], "valid"], [[70313, 70313], "valid", [], "NV8"], [[70314, 70319], "disallowed"], [[70320, 70378], "valid"], [[70379, 70383], "disallowed"], [[70384, 70393], "valid"], [[70394, 70399], "disallowed"], [[70400, 70400], "valid"], [[70401, 70403], "valid"], [[70404, 70404], "disallowed"], [[70405, 70412], "valid"], [[70413, 70414], "disallowed"], [[70415, 70416], "valid"], [[70417, 70418], "disallowed"], [[70419, 70440], "valid"], [[70441, 70441], "disallowed"], [[70442, 70448], "valid"], [[70449, 70449], "disallowed"], [[70450, 70451], "valid"], [[70452, 70452], "disallowed"], [[70453, 70457], "valid"], [[70458, 70459], "disallowed"], [[70460, 70468], "valid"], [[70469, 70470], "disallowed"], [[70471, 70472], "valid"], [[70473, 70474], "disallowed"], [[70475, 70477], "valid"], [[70478, 70479], "disallowed"], [[70480, 70480], "valid"], [[70481, 70486], "disallowed"], [[70487, 70487], "valid"], [[70488, 70492], "disallowed"], [[70493, 70499], "valid"], [[70500, 70501], "disallowed"], [[70502, 70508], "valid"], [[70509, 70511], "disallowed"], [[70512, 70516], "valid"], [[70517, 70783], "disallowed"], [[70784, 70853], "valid"], [[70854, 70854], "valid", [], "NV8"], [[70855, 70855], "valid"], [[70856, 70863], "disallowed"], [[70864, 70873], "valid"], [[70874, 71039], "disallowed"], [[71040, 71093], "valid"], [[71094, 71095], "disallowed"], [[71096, 71104], "valid"], [[71105, 71113], "valid", [], "NV8"], [[71114, 71127], "valid", [], "NV8"], [[71128, 71133], "valid"], [[71134, 71167], "disallowed"], [[71168, 71232], "valid"], [[71233, 71235], "valid", [], "NV8"], [[71236, 71236], "valid"], [[71237, 71247], "disallowed"], [[71248, 71257], "valid"], [[71258, 71295], "disallowed"], [[71296, 71351], "valid"], [[71352, 71359], "disallowed"], [[71360, 71369], "valid"], [[71370, 71423], "disallowed"], [[71424, 71449], "valid"], [[71450, 71452], "disallowed"], [[71453, 71467], "valid"], [[71468, 71471], "disallowed"], [[71472, 71481], "valid"], [[71482, 71487], "valid", [], "NV8"], [[71488, 71839], "disallowed"], [[71840, 71840], "mapped", [71872]], [[71841, 71841], "mapped", [71873]], [[71842, 71842], "mapped", [71874]], [[71843, 71843], "mapped", [71875]], [[71844, 71844], "mapped", [71876]], [[71845, 71845], "mapped", [71877]], [[71846, 71846], "mapped", [71878]], [[71847, 71847], "mapped", [71879]], [[71848, 71848], "mapped", [71880]], [[71849, 71849], "mapped", [71881]], [[71850, 71850], "mapped", [71882]], [[71851, 71851], "mapped", [71883]], [[71852, 71852], "mapped", [71884]], [[71853, 71853], "mapped", [71885]], [[71854, 71854], "mapped", [71886]], [[71855, 71855], "mapped", [71887]], [[71856, 71856], "mapped", [71888]], [[71857, 71857], "mapped", [71889]], [[71858, 71858], "mapped", [71890]], [[71859, 71859], "mapped", [71891]], [[71860, 71860], "mapped", [71892]], [[71861, 71861], "mapped", [71893]], [[71862, 71862], "mapped", [71894]], [[71863, 71863], "mapped", [71895]], [[71864, 71864], "mapped", [71896]], [[71865, 71865], "mapped", [71897]], [[71866, 71866], "mapped", [71898]], [[71867, 71867], "mapped", [71899]], [[71868, 71868], "mapped", [71900]], [[71869, 71869], "mapped", [71901]], [[71870, 71870], "mapped", [71902]], [[71871, 71871], "mapped", [71903]], [[71872, 71913], "valid"], [[71914, 71922], "valid", [], "NV8"], [[71923, 71934], "disallowed"], [[71935, 71935], "valid"], [[71936, 72383], "disallowed"], [[72384, 72440], "valid"], [[72441, 73727], "disallowed"], [[73728, 74606], "valid"], [[74607, 74648], "valid"], [[74649, 74649], "valid"], [[74650, 74751], "disallowed"], [[74752, 74850], "valid", [], "NV8"], [[74851, 74862], "valid", [], "NV8"], [[74863, 74863], "disallowed"], [[74864, 74867], "valid", [], "NV8"], [[74868, 74868], "valid", [], "NV8"], [[74869, 74879], "disallowed"], [[74880, 75075], "valid"], [[75076, 77823], "disallowed"], [[77824, 78894], "valid"], [[78895, 82943], "disallowed"], [[82944, 83526], "valid"], [[83527, 92159], "disallowed"], [[92160, 92728], "valid"], [[92729, 92735], "disallowed"], [[92736, 92766], "valid"], [[92767, 92767], "disallowed"], [[92768, 92777], "valid"], [[92778, 92781], "disallowed"], [[92782, 92783], "valid", [], "NV8"], [[92784, 92879], "disallowed"], [[92880, 92909], "valid"], [[92910, 92911], "disallowed"], [[92912, 92916], "valid"], [[92917, 92917], "valid", [], "NV8"], [[92918, 92927], "disallowed"], [[92928, 92982], "valid"], [[92983, 92991], "valid", [], "NV8"], [[92992, 92995], "valid"], [[92996, 92997], "valid", [], "NV8"], [[92998, 93007], "disallowed"], [[93008, 93017], "valid"], [[93018, 93018], "disallowed"], [[93019, 93025], "valid", [], "NV8"], [[93026, 93026], "disallowed"], [[93027, 93047], "valid"], [[93048, 93052], "disallowed"], [[93053, 93071], "valid"], [[93072, 93951], "disallowed"], [[93952, 94020], "valid"], [[94021, 94031], "disallowed"], [[94032, 94078], "valid"], [[94079, 94094], "disallowed"], [[94095, 94111], "valid"], [[94112, 110591], "disallowed"], [[110592, 110593], "valid"], [[110594, 113663], "disallowed"], [[113664, 113770], "valid"], [[113771, 113775], "disallowed"], [[113776, 113788], "valid"], [[113789, 113791], "disallowed"], [[113792, 113800], "valid"], [[113801, 113807], "disallowed"], [[113808, 113817], "valid"], [[113818, 113819], "disallowed"], [[113820, 113820], "valid", [], "NV8"], [[113821, 113822], "valid"], [[113823, 113823], "valid", [], "NV8"], [[113824, 113827], "ignored"], [[113828, 118783], "disallowed"], [[118784, 119029], "valid", [], "NV8"], [[119030, 119039], "disallowed"], [[119040, 119078], "valid", [], "NV8"], [[119079, 119080], "disallowed"], [[119081, 119081], "valid", [], "NV8"], [[119082, 119133], "valid", [], "NV8"], [[119134, 119134], "mapped", [119127, 119141]], [[119135, 119135], "mapped", [119128, 119141]], [[119136, 119136], "mapped", [119128, 119141, 119150]], [[119137, 119137], "mapped", [119128, 119141, 119151]], [[119138, 119138], "mapped", [119128, 119141, 119152]], [[119139, 119139], "mapped", [119128, 119141, 119153]], [[119140, 119140], "mapped", [119128, 119141, 119154]], [[119141, 119154], "valid", [], "NV8"], [[119155, 119162], "disallowed"], [[119163, 119226], "valid", [], "NV8"], [[119227, 119227], "mapped", [119225, 119141]], [[119228, 119228], "mapped", [119226, 119141]], [[119229, 119229], "mapped", [119225, 119141, 119150]], [[119230, 119230], "mapped", [119226, 119141, 119150]], [[119231, 119231], "mapped", [119225, 119141, 119151]], [[119232, 119232], "mapped", [119226, 119141, 119151]], [[119233, 119261], "valid", [], "NV8"], [[119262, 119272], "valid", [], "NV8"], [[119273, 119295], "disallowed"], [[119296, 119365], "valid", [], "NV8"], [[119366, 119551], "disallowed"], [[119552, 119638], "valid", [], "NV8"], [[119639, 119647], "disallowed"], [[119648, 119665], "valid", [], "NV8"], [[119666, 119807], "disallowed"], [[119808, 119808], "mapped", [97]], [[119809, 119809], "mapped", [98]], [[119810, 119810], "mapped", [99]], [[119811, 119811], "mapped", [100]], [[119812, 119812], "mapped", [101]], [[119813, 119813], "mapped", [102]], [[119814, 119814], "mapped", [103]], [[119815, 119815], "mapped", [104]], [[119816, 119816], "mapped", [105]], [[119817, 119817], "mapped", [106]], [[119818, 119818], "mapped", [107]], [[119819, 119819], "mapped", [108]], [[119820, 119820], "mapped", [109]], [[119821, 119821], "mapped", [110]], [[119822, 119822], "mapped", [111]], [[119823, 119823], "mapped", [112]], [[119824, 119824], "mapped", [113]], [[119825, 119825], "mapped", [114]], [[119826, 119826], "mapped", [115]], [[119827, 119827], "mapped", [116]], [[119828, 119828], "mapped", [117]], [[119829, 119829], "mapped", [118]], [[119830, 119830], "mapped", [119]], [[119831, 119831], "mapped", [120]], [[119832, 119832], "mapped", [121]], [[119833, 119833], "mapped", [122]], [[119834, 119834], "mapped", [97]], [[119835, 119835], "mapped", [98]], [[119836, 119836], "mapped", [99]], [[119837, 119837], "mapped", [100]], [[119838, 119838], "mapped", [101]], [[119839, 119839], "mapped", [102]], [[119840, 119840], "mapped", [103]], [[119841, 119841], "mapped", [104]], [[119842, 119842], "mapped", [105]], [[119843, 119843], "mapped", [106]], [[119844, 119844], "mapped", [107]], [[119845, 119845], "mapped", [108]], [[119846, 119846], "mapped", [109]], [[119847, 119847], "mapped", [110]], [[119848, 119848], "mapped", [111]], [[119849, 119849], "mapped", [112]], [[119850, 119850], "mapped", [113]], [[119851, 119851], "mapped", [114]], [[119852, 119852], "mapped", [115]], [[119853, 119853], "mapped", [116]], [[119854, 119854], "mapped", [117]], [[119855, 119855], "mapped", [118]], [[119856, 119856], "mapped", [119]], [[119857, 119857], "mapped", [120]], [[119858, 119858], "mapped", [121]], [[119859, 119859], "mapped", [122]], [[119860, 119860], "mapped", [97]], [[119861, 119861], "mapped", [98]], [[119862, 119862], "mapped", [99]], [[119863, 119863], "mapped", [100]], [[119864, 119864], "mapped", [101]], [[119865, 119865], "mapped", [102]], [[119866, 119866], "mapped", [103]], [[119867, 119867], "mapped", [104]], [[119868, 119868], "mapped", [105]], [[119869, 119869], "mapped", [106]], [[119870, 119870], "mapped", [107]], [[119871, 119871], "mapped", [108]], [[119872, 119872], "mapped", [109]], [[119873, 119873], "mapped", [110]], [[119874, 119874], "mapped", [111]], [[119875, 119875], "mapped", [112]], [[119876, 119876], "mapped", [113]], [[119877, 119877], "mapped", [114]], [[119878, 119878], "mapped", [115]], [[119879, 119879], "mapped", [116]], [[119880, 119880], "mapped", [117]], [[119881, 119881], "mapped", [118]], [[119882, 119882], "mapped", [119]], [[119883, 119883], "mapped", [120]], [[119884, 119884], "mapped", [121]], [[119885, 119885], "mapped", [122]], [[119886, 119886], "mapped", [97]], [[119887, 119887], "mapped", [98]], [[119888, 119888], "mapped", [99]], [[119889, 119889], "mapped", [100]], [[119890, 119890], "mapped", [101]], [[119891, 119891], "mapped", [102]], [[119892, 119892], "mapped", [103]], [[119893, 119893], "disallowed"], [[119894, 119894], "mapped", [105]], [[119895, 119895], "mapped", [106]], [[119896, 119896], "mapped", [107]], [[119897, 119897], "mapped", [108]], [[119898, 119898], "mapped", [109]], [[119899, 119899], "mapped", [110]], [[119900, 119900], "mapped", [111]], [[119901, 119901], "mapped", [112]], [[119902, 119902], "mapped", [113]], [[119903, 119903], "mapped", [114]], [[119904, 119904], "mapped", [115]], [[119905, 119905], "mapped", [116]], [[119906, 119906], "mapped", [117]], [[119907, 119907], "mapped", [118]], [[119908, 119908], "mapped", [119]], [[119909, 119909], "mapped", [120]], [[119910, 119910], "mapped", [121]], [[119911, 119911], "mapped", [122]], [[119912, 119912], "mapped", [97]], [[119913, 119913], "mapped", [98]], [[119914, 119914], "mapped", [99]], [[119915, 119915], "mapped", [100]], [[119916, 119916], "mapped", [101]], [[119917, 119917], "mapped", [102]], [[119918, 119918], "mapped", [103]], [[119919, 119919], "mapped", [104]], [[119920, 119920], "mapped", [105]], [[119921, 119921], "mapped", [106]], [[119922, 119922], "mapped", [107]], [[119923, 119923], "mapped", [108]], [[119924, 119924], "mapped", [109]], [[119925, 119925], "mapped", [110]], [[119926, 119926], "mapped", [111]], [[119927, 119927], "mapped", [112]], [[119928, 119928], "mapped", [113]], [[119929, 119929], "mapped", [114]], [[119930, 119930], "mapped", [115]], [[119931, 119931], "mapped", [116]], [[119932, 119932], "mapped", [117]], [[119933, 119933], "mapped", [118]], [[119934, 119934], "mapped", [119]], [[119935, 119935], "mapped", [120]], [[119936, 119936], "mapped", [121]], [[119937, 119937], "mapped", [122]], [[119938, 119938], "mapped", [97]], [[119939, 119939], "mapped", [98]], [[119940, 119940], "mapped", [99]], [[119941, 119941], "mapped", [100]], [[119942, 119942], "mapped", [101]], [[119943, 119943], "mapped", [102]], [[119944, 119944], "mapped", [103]], [[119945, 119945], "mapped", [104]], [[119946, 119946], "mapped", [105]], [[119947, 119947], "mapped", [106]], [[119948, 119948], "mapped", [107]], [[119949, 119949], "mapped", [108]], [[119950, 119950], "mapped", [109]], [[119951, 119951], "mapped", [110]], [[119952, 119952], "mapped", [111]], [[119953, 119953], "mapped", [112]], [[119954, 119954], "mapped", [113]], [[119955, 119955], "mapped", [114]], [[119956, 119956], "mapped", [115]], [[119957, 119957], "mapped", [116]], [[119958, 119958], "mapped", [117]], [[119959, 119959], "mapped", [118]], [[119960, 119960], "mapped", [119]], [[119961, 119961], "mapped", [120]], [[119962, 119962], "mapped", [121]], [[119963, 119963], "mapped", [122]], [[119964, 119964], "mapped", [97]], [[119965, 119965], "disallowed"], [[119966, 119966], "mapped", [99]], [[119967, 119967], "mapped", [100]], [[119968, 119969], "disallowed"], [[119970, 119970], "mapped", [103]], [[119971, 119972], "disallowed"], [[119973, 119973], "mapped", [106]], [[119974, 119974], "mapped", [107]], [[119975, 119976], "disallowed"], [[119977, 119977], "mapped", [110]], [[119978, 119978], "mapped", [111]], [[119979, 119979], "mapped", [112]], [[119980, 119980], "mapped", [113]], [[119981, 119981], "disallowed"], [[119982, 119982], "mapped", [115]], [[119983, 119983], "mapped", [116]], [[119984, 119984], "mapped", [117]], [[119985, 119985], "mapped", [118]], [[119986, 119986], "mapped", [119]], [[119987, 119987], "mapped", [120]], [[119988, 119988], "mapped", [121]], [[119989, 119989], "mapped", [122]], [[119990, 119990], "mapped", [97]], [[119991, 119991], "mapped", [98]], [[119992, 119992], "mapped", [99]], [[119993, 119993], "mapped", [100]], [[119994, 119994], "disallowed"], [[119995, 119995], "mapped", [102]], [[119996, 119996], "disallowed"], [[119997, 119997], "mapped", [104]], [[119998, 119998], "mapped", [105]], [[119999, 119999], "mapped", [106]], [[12e4, 12e4], "mapped", [107]], [[120001, 120001], "mapped", [108]], [[120002, 120002], "mapped", [109]], [[120003, 120003], "mapped", [110]], [[120004, 120004], "disallowed"], [[120005, 120005], "mapped", [112]], [[120006, 120006], "mapped", [113]], [[120007, 120007], "mapped", [114]], [[120008, 120008], "mapped", [115]], [[120009, 120009], "mapped", [116]], [[120010, 120010], "mapped", [117]], [[120011, 120011], "mapped", [118]], [[120012, 120012], "mapped", [119]], [[120013, 120013], "mapped", [120]], [[120014, 120014], "mapped", [121]], [[120015, 120015], "mapped", [122]], [[120016, 120016], "mapped", [97]], [[120017, 120017], "mapped", [98]], [[120018, 120018], "mapped", [99]], [[120019, 120019], "mapped", [100]], [[120020, 120020], "mapped", [101]], [[120021, 120021], "mapped", [102]], [[120022, 120022], "mapped", [103]], [[120023, 120023], "mapped", [104]], [[120024, 120024], "mapped", [105]], [[120025, 120025], "mapped", [106]], [[120026, 120026], "mapped", [107]], [[120027, 120027], "mapped", [108]], [[120028, 120028], "mapped", [109]], [[120029, 120029], "mapped", [110]], [[120030, 120030], "mapped", [111]], [[120031, 120031], "mapped", [112]], [[120032, 120032], "mapped", [113]], [[120033, 120033], "mapped", [114]], [[120034, 120034], "mapped", [115]], [[120035, 120035], "mapped", [116]], [[120036, 120036], "mapped", [117]], [[120037, 120037], "mapped", [118]], [[120038, 120038], "mapped", [119]], [[120039, 120039], "mapped", [120]], [[120040, 120040], "mapped", [121]], [[120041, 120041], "mapped", [122]], [[120042, 120042], "mapped", [97]], [[120043, 120043], "mapped", [98]], [[120044, 120044], "mapped", [99]], [[120045, 120045], "mapped", [100]], [[120046, 120046], "mapped", [101]], [[120047, 120047], "mapped", [102]], [[120048, 120048], "mapped", [103]], [[120049, 120049], "mapped", [104]], [[120050, 120050], "mapped", [105]], [[120051, 120051], "mapped", [106]], [[120052, 120052], "mapped", [107]], [[120053, 120053], "mapped", [108]], [[120054, 120054], "mapped", [109]], [[120055, 120055], "mapped", [110]], [[120056, 120056], "mapped", [111]], [[120057, 120057], "mapped", [112]], [[120058, 120058], "mapped", [113]], [[120059, 120059], "mapped", [114]], [[120060, 120060], "mapped", [115]], [[120061, 120061], "mapped", [116]], [[120062, 120062], "mapped", [117]], [[120063, 120063], "mapped", [118]], [[120064, 120064], "mapped", [119]], [[120065, 120065], "mapped", [120]], [[120066, 120066], "mapped", [121]], [[120067, 120067], "mapped", [122]], [[120068, 120068], "mapped", [97]], [[120069, 120069], "mapped", [98]], [[120070, 120070], "disallowed"], [[120071, 120071], "mapped", [100]], [[120072, 120072], "mapped", [101]], [[120073, 120073], "mapped", [102]], [[120074, 120074], "mapped", [103]], [[120075, 120076], "disallowed"], [[120077, 120077], "mapped", [106]], [[120078, 120078], "mapped", [107]], [[120079, 120079], "mapped", [108]], [[120080, 120080], "mapped", [109]], [[120081, 120081], "mapped", [110]], [[120082, 120082], "mapped", [111]], [[120083, 120083], "mapped", [112]], [[120084, 120084], "mapped", [113]], [[120085, 120085], "disallowed"], [[120086, 120086], "mapped", [115]], [[120087, 120087], "mapped", [116]], [[120088, 120088], "mapped", [117]], [[120089, 120089], "mapped", [118]], [[120090, 120090], "mapped", [119]], [[120091, 120091], "mapped", [120]], [[120092, 120092], "mapped", [121]], [[120093, 120093], "disallowed"], [[120094, 120094], "mapped", [97]], [[120095, 120095], "mapped", [98]], [[120096, 120096], "mapped", [99]], [[120097, 120097], "mapped", [100]], [[120098, 120098], "mapped", [101]], [[120099, 120099], "mapped", [102]], [[120100, 120100], "mapped", [103]], [[120101, 120101], "mapped", [104]], [[120102, 120102], "mapped", [105]], [[120103, 120103], "mapped", [106]], [[120104, 120104], "mapped", [107]], [[120105, 120105], "mapped", [108]], [[120106, 120106], "mapped", [109]], [[120107, 120107], "mapped", [110]], [[120108, 120108], "mapped", [111]], [[120109, 120109], "mapped", [112]], [[120110, 120110], "mapped", [113]], [[120111, 120111], "mapped", [114]], [[120112, 120112], "mapped", [115]], [[120113, 120113], "mapped", [116]], [[120114, 120114], "mapped", [117]], [[120115, 120115], "mapped", [118]], [[120116, 120116], "mapped", [119]], [[120117, 120117], "mapped", [120]], [[120118, 120118], "mapped", [121]], [[120119, 120119], "mapped", [122]], [[120120, 120120], "mapped", [97]], [[120121, 120121], "mapped", [98]], [[120122, 120122], "disallowed"], [[120123, 120123], "mapped", [100]], [[120124, 120124], "mapped", [101]], [[120125, 120125], "mapped", [102]], [[120126, 120126], "mapped", [103]], [[120127, 120127], "disallowed"], [[120128, 120128], "mapped", [105]], [[120129, 120129], "mapped", [106]], [[120130, 120130], "mapped", [107]], [[120131, 120131], "mapped", [108]], [[120132, 120132], "mapped", [109]], [[120133, 120133], "disallowed"], [[120134, 120134], "mapped", [111]], [[120135, 120137], "disallowed"], [[120138, 120138], "mapped", [115]], [[120139, 120139], "mapped", [116]], [[120140, 120140], "mapped", [117]], [[120141, 120141], "mapped", [118]], [[120142, 120142], "mapped", [119]], [[120143, 120143], "mapped", [120]], [[120144, 120144], "mapped", [121]], [[120145, 120145], "disallowed"], [[120146, 120146], "mapped", [97]], [[120147, 120147], "mapped", [98]], [[120148, 120148], "mapped", [99]], [[120149, 120149], "mapped", [100]], [[120150, 120150], "mapped", [101]], [[120151, 120151], "mapped", [102]], [[120152, 120152], "mapped", [103]], [[120153, 120153], "mapped", [104]], [[120154, 120154], "mapped", [105]], [[120155, 120155], "mapped", [106]], [[120156, 120156], "mapped", [107]], [[120157, 120157], "mapped", [108]], [[120158, 120158], "mapped", [109]], [[120159, 120159], "mapped", [110]], [[120160, 120160], "mapped", [111]], [[120161, 120161], "mapped", [112]], [[120162, 120162], "mapped", [113]], [[120163, 120163], "mapped", [114]], [[120164, 120164], "mapped", [115]], [[120165, 120165], "mapped", [116]], [[120166, 120166], "mapped", [117]], [[120167, 120167], "mapped", [118]], [[120168, 120168], "mapped", [119]], [[120169, 120169], "mapped", [120]], [[120170, 120170], "mapped", [121]], [[120171, 120171], "mapped", [122]], [[120172, 120172], "mapped", [97]], [[120173, 120173], "mapped", [98]], [[120174, 120174], "mapped", [99]], [[120175, 120175], "mapped", [100]], [[120176, 120176], "mapped", [101]], [[120177, 120177], "mapped", [102]], [[120178, 120178], "mapped", [103]], [[120179, 120179], "mapped", [104]], [[120180, 120180], "mapped", [105]], [[120181, 120181], "mapped", [106]], [[120182, 120182], "mapped", [107]], [[120183, 120183], "mapped", [108]], [[120184, 120184], "mapped", [109]], [[120185, 120185], "mapped", [110]], [[120186, 120186], "mapped", [111]], [[120187, 120187], "mapped", [112]], [[120188, 120188], "mapped", [113]], [[120189, 120189], "mapped", [114]], [[120190, 120190], "mapped", [115]], [[120191, 120191], "mapped", [116]], [[120192, 120192], "mapped", [117]], [[120193, 120193], "mapped", [118]], [[120194, 120194], "mapped", [119]], [[120195, 120195], "mapped", [120]], [[120196, 120196], "mapped", [121]], [[120197, 120197], "mapped", [122]], [[120198, 120198], "mapped", [97]], [[120199, 120199], "mapped", [98]], [[120200, 120200], "mapped", [99]], [[120201, 120201], "mapped", [100]], [[120202, 120202], "mapped", [101]], [[120203, 120203], "mapped", [102]], [[120204, 120204], "mapped", [103]], [[120205, 120205], "mapped", [104]], [[120206, 120206], "mapped", [105]], [[120207, 120207], "mapped", [106]], [[120208, 120208], "mapped", [107]], [[120209, 120209], "mapped", [108]], [[120210, 120210], "mapped", [109]], [[120211, 120211], "mapped", [110]], [[120212, 120212], "mapped", [111]], [[120213, 120213], "mapped", [112]], [[120214, 120214], "mapped", [113]], [[120215, 120215], "mapped", [114]], [[120216, 120216], "mapped", [115]], [[120217, 120217], "mapped", [116]], [[120218, 120218], "mapped", [117]], [[120219, 120219], "mapped", [118]], [[120220, 120220], "mapped", [119]], [[120221, 120221], "mapped", [120]], [[120222, 120222], "mapped", [121]], [[120223, 120223], "mapped", [122]], [[120224, 120224], "mapped", [97]], [[120225, 120225], "mapped", [98]], [[120226, 120226], "mapped", [99]], [[120227, 120227], "mapped", [100]], [[120228, 120228], "mapped", [101]], [[120229, 120229], "mapped", [102]], [[120230, 120230], "mapped", [103]], [[120231, 120231], "mapped", [104]], [[120232, 120232], "mapped", [105]], [[120233, 120233], "mapped", [106]], [[120234, 120234], "mapped", [107]], [[120235, 120235], "mapped", [108]], [[120236, 120236], "mapped", [109]], [[120237, 120237], "mapped", [110]], [[120238, 120238], "mapped", [111]], [[120239, 120239], "mapped", [112]], [[120240, 120240], "mapped", [113]], [[120241, 120241], "mapped", [114]], [[120242, 120242], "mapped", [115]], [[120243, 120243], "mapped", [116]], [[120244, 120244], "mapped", [117]], [[120245, 120245], "mapped", [118]], [[120246, 120246], "mapped", [119]], [[120247, 120247], "mapped", [120]], [[120248, 120248], "mapped", [121]], [[120249, 120249], "mapped", [122]], [[120250, 120250], "mapped", [97]], [[120251, 120251], "mapped", [98]], [[120252, 120252], "mapped", [99]], [[120253, 120253], "mapped", [100]], [[120254, 120254], "mapped", [101]], [[120255, 120255], "mapped", [102]], [[120256, 120256], "mapped", [103]], [[120257, 120257], "mapped", [104]], [[120258, 120258], "mapped", [105]], [[120259, 120259], "mapped", [106]], [[120260, 120260], "mapped", [107]], [[120261, 120261], "mapped", [108]], [[120262, 120262], "mapped", [109]], [[120263, 120263], "mapped", [110]], [[120264, 120264], "mapped", [111]], [[120265, 120265], "mapped", [112]], [[120266, 120266], "mapped", [113]], [[120267, 120267], "mapped", [114]], [[120268, 120268], "mapped", [115]], [[120269, 120269], "mapped", [116]], [[120270, 120270], "mapped", [117]], [[120271, 120271], "mapped", [118]], [[120272, 120272], "mapped", [119]], [[120273, 120273], "mapped", [120]], [[120274, 120274], "mapped", [121]], [[120275, 120275], "mapped", [122]], [[120276, 120276], "mapped", [97]], [[120277, 120277], "mapped", [98]], [[120278, 120278], "mapped", [99]], [[120279, 120279], "mapped", [100]], [[120280, 120280], "mapped", [101]], [[120281, 120281], "mapped", [102]], [[120282, 120282], "mapped", [103]], [[120283, 120283], "mapped", [104]], [[120284, 120284], "mapped", [105]], [[120285, 120285], "mapped", [106]], [[120286, 120286], "mapped", [107]], [[120287, 120287], "mapped", [108]], [[120288, 120288], "mapped", [109]], [[120289, 120289], "mapped", [110]], [[120290, 120290], "mapped", [111]], [[120291, 120291], "mapped", [112]], [[120292, 120292], "mapped", [113]], [[120293, 120293], "mapped", [114]], [[120294, 120294], "mapped", [115]], [[120295, 120295], "mapped", [116]], [[120296, 120296], "mapped", [117]], [[120297, 120297], "mapped", [118]], [[120298, 120298], "mapped", [119]], [[120299, 120299], "mapped", [120]], [[120300, 120300], "mapped", [121]], [[120301, 120301], "mapped", [122]], [[120302, 120302], "mapped", [97]], [[120303, 120303], "mapped", [98]], [[120304, 120304], "mapped", [99]], [[120305, 120305], "mapped", [100]], [[120306, 120306], "mapped", [101]], [[120307, 120307], "mapped", [102]], [[120308, 120308], "mapped", [103]], [[120309, 120309], "mapped", [104]], [[120310, 120310], "mapped", [105]], [[120311, 120311], "mapped", [106]], [[120312, 120312], "mapped", [107]], [[120313, 120313], "mapped", [108]], [[120314, 120314], "mapped", [109]], [[120315, 120315], "mapped", [110]], [[120316, 120316], "mapped", [111]], [[120317, 120317], "mapped", [112]], [[120318, 120318], "mapped", [113]], [[120319, 120319], "mapped", [114]], [[120320, 120320], "mapped", [115]], [[120321, 120321], "mapped", [116]], [[120322, 120322], "mapped", [117]], [[120323, 120323], "mapped", [118]], [[120324, 120324], "mapped", [119]], [[120325, 120325], "mapped", [120]], [[120326, 120326], "mapped", [121]], [[120327, 120327], "mapped", [122]], [[120328, 120328], "mapped", [97]], [[120329, 120329], "mapped", [98]], [[120330, 120330], "mapped", [99]], [[120331, 120331], "mapped", [100]], [[120332, 120332], "mapped", [101]], [[120333, 120333], "mapped", [102]], [[120334, 120334], "mapped", [103]], [[120335, 120335], "mapped", [104]], [[120336, 120336], "mapped", [105]], [[120337, 120337], "mapped", [106]], [[120338, 120338], "mapped", [107]], [[120339, 120339], "mapped", [108]], [[120340, 120340], "mapped", [109]], [[120341, 120341], "mapped", [110]], [[120342, 120342], "mapped", [111]], [[120343, 120343], "mapped", [112]], [[120344, 120344], "mapped", [113]], [[120345, 120345], "mapped", [114]], [[120346, 120346], "mapped", [115]], [[120347, 120347], "mapped", [116]], [[120348, 120348], "mapped", [117]], [[120349, 120349], "mapped", [118]], [[120350, 120350], "mapped", [119]], [[120351, 120351], "mapped", [120]], [[120352, 120352], "mapped", [121]], [[120353, 120353], "mapped", [122]], [[120354, 120354], "mapped", [97]], [[120355, 120355], "mapped", [98]], [[120356, 120356], "mapped", [99]], [[120357, 120357], "mapped", [100]], [[120358, 120358], "mapped", [101]], [[120359, 120359], "mapped", [102]], [[120360, 120360], "mapped", [103]], [[120361, 120361], "mapped", [104]], [[120362, 120362], "mapped", [105]], [[120363, 120363], "mapped", [106]], [[120364, 120364], "mapped", [107]], [[120365, 120365], "mapped", [108]], [[120366, 120366], "mapped", [109]], [[120367, 120367], "mapped", [110]], [[120368, 120368], "mapped", [111]], [[120369, 120369], "mapped", [112]], [[120370, 120370], "mapped", [113]], [[120371, 120371], "mapped", [114]], [[120372, 120372], "mapped", [115]], [[120373, 120373], "mapped", [116]], [[120374, 120374], "mapped", [117]], [[120375, 120375], "mapped", [118]], [[120376, 120376], "mapped", [119]], [[120377, 120377], "mapped", [120]], [[120378, 120378], "mapped", [121]], [[120379, 120379], "mapped", [122]], [[120380, 120380], "mapped", [97]], [[120381, 120381], "mapped", [98]], [[120382, 120382], "mapped", [99]], [[120383, 120383], "mapped", [100]], [[120384, 120384], "mapped", [101]], [[120385, 120385], "mapped", [102]], [[120386, 120386], "mapped", [103]], [[120387, 120387], "mapped", [104]], [[120388, 120388], "mapped", [105]], [[120389, 120389], "mapped", [106]], [[120390, 120390], "mapped", [107]], [[120391, 120391], "mapped", [108]], [[120392, 120392], "mapped", [109]], [[120393, 120393], "mapped", [110]], [[120394, 120394], "mapped", [111]], [[120395, 120395], "mapped", [112]], [[120396, 120396], "mapped", [113]], [[120397, 120397], "mapped", [114]], [[120398, 120398], "mapped", [115]], [[120399, 120399], "mapped", [116]], [[120400, 120400], "mapped", [117]], [[120401, 120401], "mapped", [118]], [[120402, 120402], "mapped", [119]], [[120403, 120403], "mapped", [120]], [[120404, 120404], "mapped", [121]], [[120405, 120405], "mapped", [122]], [[120406, 120406], "mapped", [97]], [[120407, 120407], "mapped", [98]], [[120408, 120408], "mapped", [99]], [[120409, 120409], "mapped", [100]], [[120410, 120410], "mapped", [101]], [[120411, 120411], "mapped", [102]], [[120412, 120412], "mapped", [103]], [[120413, 120413], "mapped", [104]], [[120414, 120414], "mapped", [105]], [[120415, 120415], "mapped", [106]], [[120416, 120416], "mapped", [107]], [[120417, 120417], "mapped", [108]], [[120418, 120418], "mapped", [109]], [[120419, 120419], "mapped", [110]], [[120420, 120420], "mapped", [111]], [[120421, 120421], "mapped", [112]], [[120422, 120422], "mapped", [113]], [[120423, 120423], "mapped", [114]], [[120424, 120424], "mapped", [115]], [[120425, 120425], "mapped", [116]], [[120426, 120426], "mapped", [117]], [[120427, 120427], "mapped", [118]], [[120428, 120428], "mapped", [119]], [[120429, 120429], "mapped", [120]], [[120430, 120430], "mapped", [121]], [[120431, 120431], "mapped", [122]], [[120432, 120432], "mapped", [97]], [[120433, 120433], "mapped", [98]], [[120434, 120434], "mapped", [99]], [[120435, 120435], "mapped", [100]], [[120436, 120436], "mapped", [101]], [[120437, 120437], "mapped", [102]], [[120438, 120438], "mapped", [103]], [[120439, 120439], "mapped", [104]], [[120440, 120440], "mapped", [105]], [[120441, 120441], "mapped", [106]], [[120442, 120442], "mapped", [107]], [[120443, 120443], "mapped", [108]], [[120444, 120444], "mapped", [109]], [[120445, 120445], "mapped", [110]], [[120446, 120446], "mapped", [111]], [[120447, 120447], "mapped", [112]], [[120448, 120448], "mapped", [113]], [[120449, 120449], "mapped", [114]], [[120450, 120450], "mapped", [115]], [[120451, 120451], "mapped", [116]], [[120452, 120452], "mapped", [117]], [[120453, 120453], "mapped", [118]], [[120454, 120454], "mapped", [119]], [[120455, 120455], "mapped", [120]], [[120456, 120456], "mapped", [121]], [[120457, 120457], "mapped", [122]], [[120458, 120458], "mapped", [97]], [[120459, 120459], "mapped", [98]], [[120460, 120460], "mapped", [99]], [[120461, 120461], "mapped", [100]], [[120462, 120462], "mapped", [101]], [[120463, 120463], "mapped", [102]], [[120464, 120464], "mapped", [103]], [[120465, 120465], "mapped", [104]], [[120466, 120466], "mapped", [105]], [[120467, 120467], "mapped", [106]], [[120468, 120468], "mapped", [107]], [[120469, 120469], "mapped", [108]], [[120470, 120470], "mapped", [109]], [[120471, 120471], "mapped", [110]], [[120472, 120472], "mapped", [111]], [[120473, 120473], "mapped", [112]], [[120474, 120474], "mapped", [113]], [[120475, 120475], "mapped", [114]], [[120476, 120476], "mapped", [115]], [[120477, 120477], "mapped", [116]], [[120478, 120478], "mapped", [117]], [[120479, 120479], "mapped", [118]], [[120480, 120480], "mapped", [119]], [[120481, 120481], "mapped", [120]], [[120482, 120482], "mapped", [121]], [[120483, 120483], "mapped", [122]], [[120484, 120484], "mapped", [305]], [[120485, 120485], "mapped", [567]], [[120486, 120487], "disallowed"], [[120488, 120488], "mapped", [945]], [[120489, 120489], "mapped", [946]], [[120490, 120490], "mapped", [947]], [[120491, 120491], "mapped", [948]], [[120492, 120492], "mapped", [949]], [[120493, 120493], "mapped", [950]], [[120494, 120494], "mapped", [951]], [[120495, 120495], "mapped", [952]], [[120496, 120496], "mapped", [953]], [[120497, 120497], "mapped", [954]], [[120498, 120498], "mapped", [955]], [[120499, 120499], "mapped", [956]], [[120500, 120500], "mapped", [957]], [[120501, 120501], "mapped", [958]], [[120502, 120502], "mapped", [959]], [[120503, 120503], "mapped", [960]], [[120504, 120504], "mapped", [961]], [[120505, 120505], "mapped", [952]], [[120506, 120506], "mapped", [963]], [[120507, 120507], "mapped", [964]], [[120508, 120508], "mapped", [965]], [[120509, 120509], "mapped", [966]], [[120510, 120510], "mapped", [967]], [[120511, 120511], "mapped", [968]], [[120512, 120512], "mapped", [969]], [[120513, 120513], "mapped", [8711]], [[120514, 120514], "mapped", [945]], [[120515, 120515], "mapped", [946]], [[120516, 120516], "mapped", [947]], [[120517, 120517], "mapped", [948]], [[120518, 120518], "mapped", [949]], [[120519, 120519], "mapped", [950]], [[120520, 120520], "mapped", [951]], [[120521, 120521], "mapped", [952]], [[120522, 120522], "mapped", [953]], [[120523, 120523], "mapped", [954]], [[120524, 120524], "mapped", [955]], [[120525, 120525], "mapped", [956]], [[120526, 120526], "mapped", [957]], [[120527, 120527], "mapped", [958]], [[120528, 120528], "mapped", [959]], [[120529, 120529], "mapped", [960]], [[120530, 120530], "mapped", [961]], [[120531, 120532], "mapped", [963]], [[120533, 120533], "mapped", [964]], [[120534, 120534], "mapped", [965]], [[120535, 120535], "mapped", [966]], [[120536, 120536], "mapped", [967]], [[120537, 120537], "mapped", [968]], [[120538, 120538], "mapped", [969]], [[120539, 120539], "mapped", [8706]], [[120540, 120540], "mapped", [949]], [[120541, 120541], "mapped", [952]], [[120542, 120542], "mapped", [954]], [[120543, 120543], "mapped", [966]], [[120544, 120544], "mapped", [961]], [[120545, 120545], "mapped", [960]], [[120546, 120546], "mapped", [945]], [[120547, 120547], "mapped", [946]], [[120548, 120548], "mapped", [947]], [[120549, 120549], "mapped", [948]], [[120550, 120550], "mapped", [949]], [[120551, 120551], "mapped", [950]], [[120552, 120552], "mapped", [951]], [[120553, 120553], "mapped", [952]], [[120554, 120554], "mapped", [953]], [[120555, 120555], "mapped", [954]], [[120556, 120556], "mapped", [955]], [[120557, 120557], "mapped", [956]], [[120558, 120558], "mapped", [957]], [[120559, 120559], "mapped", [958]], [[120560, 120560], "mapped", [959]], [[120561, 120561], "mapped", [960]], [[120562, 120562], "mapped", [961]], [[120563, 120563], "mapped", [952]], [[120564, 120564], "mapped", [963]], [[120565, 120565], "mapped", [964]], [[120566, 120566], "mapped", [965]], [[120567, 120567], "mapped", [966]], [[120568, 120568], "mapped", [967]], [[120569, 120569], "mapped", [968]], [[120570, 120570], "mapped", [969]], [[120571, 120571], "mapped", [8711]], [[120572, 120572], "mapped", [945]], [[120573, 120573], "mapped", [946]], [[120574, 120574], "mapped", [947]], [[120575, 120575], "mapped", [948]], [[120576, 120576], "mapped", [949]], [[120577, 120577], "mapped", [950]], [[120578, 120578], "mapped", [951]], [[120579, 120579], "mapped", [952]], [[120580, 120580], "mapped", [953]], [[120581, 120581], "mapped", [954]], [[120582, 120582], "mapped", [955]], [[120583, 120583], "mapped", [956]], [[120584, 120584], "mapped", [957]], [[120585, 120585], "mapped", [958]], [[120586, 120586], "mapped", [959]], [[120587, 120587], "mapped", [960]], [[120588, 120588], "mapped", [961]], [[120589, 120590], "mapped", [963]], [[120591, 120591], "mapped", [964]], [[120592, 120592], "mapped", [965]], [[120593, 120593], "mapped", [966]], [[120594, 120594], "mapped", [967]], [[120595, 120595], "mapped", [968]], [[120596, 120596], "mapped", [969]], [[120597, 120597], "mapped", [8706]], [[120598, 120598], "mapped", [949]], [[120599, 120599], "mapped", [952]], [[120600, 120600], "mapped", [954]], [[120601, 120601], "mapped", [966]], [[120602, 120602], "mapped", [961]], [[120603, 120603], "mapped", [960]], [[120604, 120604], "mapped", [945]], [[120605, 120605], "mapped", [946]], [[120606, 120606], "mapped", [947]], [[120607, 120607], "mapped", [948]], [[120608, 120608], "mapped", [949]], [[120609, 120609], "mapped", [950]], [[120610, 120610], "mapped", [951]], [[120611, 120611], "mapped", [952]], [[120612, 120612], "mapped", [953]], [[120613, 120613], "mapped", [954]], [[120614, 120614], "mapped", [955]], [[120615, 120615], "mapped", [956]], [[120616, 120616], "mapped", [957]], [[120617, 120617], "mapped", [958]], [[120618, 120618], "mapped", [959]], [[120619, 120619], "mapped", [960]], [[120620, 120620], "mapped", [961]], [[120621, 120621], "mapped", [952]], [[120622, 120622], "mapped", [963]], [[120623, 120623], "mapped", [964]], [[120624, 120624], "mapped", [965]], [[120625, 120625], "mapped", [966]], [[120626, 120626], "mapped", [967]], [[120627, 120627], "mapped", [968]], [[120628, 120628], "mapped", [969]], [[120629, 120629], "mapped", [8711]], [[120630, 120630], "mapped", [945]], [[120631, 120631], "mapped", [946]], [[120632, 120632], "mapped", [947]], [[120633, 120633], "mapped", [948]], [[120634, 120634], "mapped", [949]], [[120635, 120635], "mapped", [950]], [[120636, 120636], "mapped", [951]], [[120637, 120637], "mapped", [952]], [[120638, 120638], "mapped", [953]], [[120639, 120639], "mapped", [954]], [[120640, 120640], "mapped", [955]], [[120641, 120641], "mapped", [956]], [[120642, 120642], "mapped", [957]], [[120643, 120643], "mapped", [958]], [[120644, 120644], "mapped", [959]], [[120645, 120645], "mapped", [960]], [[120646, 120646], "mapped", [961]], [[120647, 120648], "mapped", [963]], [[120649, 120649], "mapped", [964]], [[120650, 120650], "mapped", [965]], [[120651, 120651], "mapped", [966]], [[120652, 120652], "mapped", [967]], [[120653, 120653], "mapped", [968]], [[120654, 120654], "mapped", [969]], [[120655, 120655], "mapped", [8706]], [[120656, 120656], "mapped", [949]], [[120657, 120657], "mapped", [952]], [[120658, 120658], "mapped", [954]], [[120659, 120659], "mapped", [966]], [[120660, 120660], "mapped", [961]], [[120661, 120661], "mapped", [960]], [[120662, 120662], "mapped", [945]], [[120663, 120663], "mapped", [946]], [[120664, 120664], "mapped", [947]], [[120665, 120665], "mapped", [948]], [[120666, 120666], "mapped", [949]], [[120667, 120667], "mapped", [950]], [[120668, 120668], "mapped", [951]], [[120669, 120669], "mapped", [952]], [[120670, 120670], "mapped", [953]], [[120671, 120671], "mapped", [954]], [[120672, 120672], "mapped", [955]], [[120673, 120673], "mapped", [956]], [[120674, 120674], "mapped", [957]], [[120675, 120675], "mapped", [958]], [[120676, 120676], "mapped", [959]], [[120677, 120677], "mapped", [960]], [[120678, 120678], "mapped", [961]], [[120679, 120679], "mapped", [952]], [[120680, 120680], "mapped", [963]], [[120681, 120681], "mapped", [964]], [[120682, 120682], "mapped", [965]], [[120683, 120683], "mapped", [966]], [[120684, 120684], "mapped", [967]], [[120685, 120685], "mapped", [968]], [[120686, 120686], "mapped", [969]], [[120687, 120687], "mapped", [8711]], [[120688, 120688], "mapped", [945]], [[120689, 120689], "mapped", [946]], [[120690, 120690], "mapped", [947]], [[120691, 120691], "mapped", [948]], [[120692, 120692], "mapped", [949]], [[120693, 120693], "mapped", [950]], [[120694, 120694], "mapped", [951]], [[120695, 120695], "mapped", [952]], [[120696, 120696], "mapped", [953]], [[120697, 120697], "mapped", [954]], [[120698, 120698], "mapped", [955]], [[120699, 120699], "mapped", [956]], [[120700, 120700], "mapped", [957]], [[120701, 120701], "mapped", [958]], [[120702, 120702], "mapped", [959]], [[120703, 120703], "mapped", [960]], [[120704, 120704], "mapped", [961]], [[120705, 120706], "mapped", [963]], [[120707, 120707], "mapped", [964]], [[120708, 120708], "mapped", [965]], [[120709, 120709], "mapped", [966]], [[120710, 120710], "mapped", [967]], [[120711, 120711], "mapped", [968]], [[120712, 120712], "mapped", [969]], [[120713, 120713], "mapped", [8706]], [[120714, 120714], "mapped", [949]], [[120715, 120715], "mapped", [952]], [[120716, 120716], "mapped", [954]], [[120717, 120717], "mapped", [966]], [[120718, 120718], "mapped", [961]], [[120719, 120719], "mapped", [960]], [[120720, 120720], "mapped", [945]], [[120721, 120721], "mapped", [946]], [[120722, 120722], "mapped", [947]], [[120723, 120723], "mapped", [948]], [[120724, 120724], "mapped", [949]], [[120725, 120725], "mapped", [950]], [[120726, 120726], "mapped", [951]], [[120727, 120727], "mapped", [952]], [[120728, 120728], "mapped", [953]], [[120729, 120729], "mapped", [954]], [[120730, 120730], "mapped", [955]], [[120731, 120731], "mapped", [956]], [[120732, 120732], "mapped", [957]], [[120733, 120733], "mapped", [958]], [[120734, 120734], "mapped", [959]], [[120735, 120735], "mapped", [960]], [[120736, 120736], "mapped", [961]], [[120737, 120737], "mapped", [952]], [[120738, 120738], "mapped", [963]], [[120739, 120739], "mapped", [964]], [[120740, 120740], "mapped", [965]], [[120741, 120741], "mapped", [966]], [[120742, 120742], "mapped", [967]], [[120743, 120743], "mapped", [968]], [[120744, 120744], "mapped", [969]], [[120745, 120745], "mapped", [8711]], [[120746, 120746], "mapped", [945]], [[120747, 120747], "mapped", [946]], [[120748, 120748], "mapped", [947]], [[120749, 120749], "mapped", [948]], [[120750, 120750], "mapped", [949]], [[120751, 120751], "mapped", [950]], [[120752, 120752], "mapped", [951]], [[120753, 120753], "mapped", [952]], [[120754, 120754], "mapped", [953]], [[120755, 120755], "mapped", [954]], [[120756, 120756], "mapped", [955]], [[120757, 120757], "mapped", [956]], [[120758, 120758], "mapped", [957]], [[120759, 120759], "mapped", [958]], [[120760, 120760], "mapped", [959]], [[120761, 120761], "mapped", [960]], [[120762, 120762], "mapped", [961]], [[120763, 120764], "mapped", [963]], [[120765, 120765], "mapped", [964]], [[120766, 120766], "mapped", [965]], [[120767, 120767], "mapped", [966]], [[120768, 120768], "mapped", [967]], [[120769, 120769], "mapped", [968]], [[120770, 120770], "mapped", [969]], [[120771, 120771], "mapped", [8706]], [[120772, 120772], "mapped", [949]], [[120773, 120773], "mapped", [952]], [[120774, 120774], "mapped", [954]], [[120775, 120775], "mapped", [966]], [[120776, 120776], "mapped", [961]], [[120777, 120777], "mapped", [960]], [[120778, 120779], "mapped", [989]], [[120780, 120781], "disallowed"], [[120782, 120782], "mapped", [48]], [[120783, 120783], "mapped", [49]], [[120784, 120784], "mapped", [50]], [[120785, 120785], "mapped", [51]], [[120786, 120786], "mapped", [52]], [[120787, 120787], "mapped", [53]], [[120788, 120788], "mapped", [54]], [[120789, 120789], "mapped", [55]], [[120790, 120790], "mapped", [56]], [[120791, 120791], "mapped", [57]], [[120792, 120792], "mapped", [48]], [[120793, 120793], "mapped", [49]], [[120794, 120794], "mapped", [50]], [[120795, 120795], "mapped", [51]], [[120796, 120796], "mapped", [52]], [[120797, 120797], "mapped", [53]], [[120798, 120798], "mapped", [54]], [[120799, 120799], "mapped", [55]], [[120800, 120800], "mapped", [56]], [[120801, 120801], "mapped", [57]], [[120802, 120802], "mapped", [48]], [[120803, 120803], "mapped", [49]], [[120804, 120804], "mapped", [50]], [[120805, 120805], "mapped", [51]], [[120806, 120806], "mapped", [52]], [[120807, 120807], "mapped", [53]], [[120808, 120808], "mapped", [54]], [[120809, 120809], "mapped", [55]], [[120810, 120810], "mapped", [56]], [[120811, 120811], "mapped", [57]], [[120812, 120812], "mapped", [48]], [[120813, 120813], "mapped", [49]], [[120814, 120814], "mapped", [50]], [[120815, 120815], "mapped", [51]], [[120816, 120816], "mapped", [52]], [[120817, 120817], "mapped", [53]], [[120818, 120818], "mapped", [54]], [[120819, 120819], "mapped", [55]], [[120820, 120820], "mapped", [56]], [[120821, 120821], "mapped", [57]], [[120822, 120822], "mapped", [48]], [[120823, 120823], "mapped", [49]], [[120824, 120824], "mapped", [50]], [[120825, 120825], "mapped", [51]], [[120826, 120826], "mapped", [52]], [[120827, 120827], "mapped", [53]], [[120828, 120828], "mapped", [54]], [[120829, 120829], "mapped", [55]], [[120830, 120830], "mapped", [56]], [[120831, 120831], "mapped", [57]], [[120832, 121343], "valid", [], "NV8"], [[121344, 121398], "valid"], [[121399, 121402], "valid", [], "NV8"], [[121403, 121452], "valid"], [[121453, 121460], "valid", [], "NV8"], [[121461, 121461], "valid"], [[121462, 121475], "valid", [], "NV8"], [[121476, 121476], "valid"], [[121477, 121483], "valid", [], "NV8"], [[121484, 121498], "disallowed"], [[121499, 121503], "valid"], [[121504, 121504], "disallowed"], [[121505, 121519], "valid"], [[121520, 124927], "disallowed"], [[124928, 125124], "valid"], [[125125, 125126], "disallowed"], [[125127, 125135], "valid", [], "NV8"], [[125136, 125142], "valid"], [[125143, 126463], "disallowed"], [[126464, 126464], "mapped", [1575]], [[126465, 126465], "mapped", [1576]], [[126466, 126466], "mapped", [1580]], [[126467, 126467], "mapped", [1583]], [[126468, 126468], "disallowed"], [[126469, 126469], "mapped", [1608]], [[126470, 126470], "mapped", [1586]], [[126471, 126471], "mapped", [1581]], [[126472, 126472], "mapped", [1591]], [[126473, 126473], "mapped", [1610]], [[126474, 126474], "mapped", [1603]], [[126475, 126475], "mapped", [1604]], [[126476, 126476], "mapped", [1605]], [[126477, 126477], "mapped", [1606]], [[126478, 126478], "mapped", [1587]], [[126479, 126479], "mapped", [1593]], [[126480, 126480], "mapped", [1601]], [[126481, 126481], "mapped", [1589]], [[126482, 126482], "mapped", [1602]], [[126483, 126483], "mapped", [1585]], [[126484, 126484], "mapped", [1588]], [[126485, 126485], "mapped", [1578]], [[126486, 126486], "mapped", [1579]], [[126487, 126487], "mapped", [1582]], [[126488, 126488], "mapped", [1584]], [[126489, 126489], "mapped", [1590]], [[126490, 126490], "mapped", [1592]], [[126491, 126491], "mapped", [1594]], [[126492, 126492], "mapped", [1646]], [[126493, 126493], "mapped", [1722]], [[126494, 126494], "mapped", [1697]], [[126495, 126495], "mapped", [1647]], [[126496, 126496], "disallowed"], [[126497, 126497], "mapped", [1576]], [[126498, 126498], "mapped", [1580]], [[126499, 126499], "disallowed"], [[126500, 126500], "mapped", [1607]], [[126501, 126502], "disallowed"], [[126503, 126503], "mapped", [1581]], [[126504, 126504], "disallowed"], [[126505, 126505], "mapped", [1610]], [[126506, 126506], "mapped", [1603]], [[126507, 126507], "mapped", [1604]], [[126508, 126508], "mapped", [1605]], [[126509, 126509], "mapped", [1606]], [[126510, 126510], "mapped", [1587]], [[126511, 126511], "mapped", [1593]], [[126512, 126512], "mapped", [1601]], [[126513, 126513], "mapped", [1589]], [[126514, 126514], "mapped", [1602]], [[126515, 126515], "disallowed"], [[126516, 126516], "mapped", [1588]], [[126517, 126517], "mapped", [1578]], [[126518, 126518], "mapped", [1579]], [[126519, 126519], "mapped", [1582]], [[126520, 126520], "disallowed"], [[126521, 126521], "mapped", [1590]], [[126522, 126522], "disallowed"], [[126523, 126523], "mapped", [1594]], [[126524, 126529], "disallowed"], [[126530, 126530], "mapped", [1580]], [[126531, 126534], "disallowed"], [[126535, 126535], "mapped", [1581]], [[126536, 126536], "disallowed"], [[126537, 126537], "mapped", [1610]], [[126538, 126538], "disallowed"], [[126539, 126539], "mapped", [1604]], [[126540, 126540], "disallowed"], [[126541, 126541], "mapped", [1606]], [[126542, 126542], "mapped", [1587]], [[126543, 126543], "mapped", [1593]], [[126544, 126544], "disallowed"], [[126545, 126545], "mapped", [1589]], [[126546, 126546], "mapped", [1602]], [[126547, 126547], "disallowed"], [[126548, 126548], "mapped", [1588]], [[126549, 126550], "disallowed"], [[126551, 126551], "mapped", [1582]], [[126552, 126552], "disallowed"], [[126553, 126553], "mapped", [1590]], [[126554, 126554], "disallowed"], [[126555, 126555], "mapped", [1594]], [[126556, 126556], "disallowed"], [[126557, 126557], "mapped", [1722]], [[126558, 126558], "disallowed"], [[126559, 126559], "mapped", [1647]], [[126560, 126560], "disallowed"], [[126561, 126561], "mapped", [1576]], [[126562, 126562], "mapped", [1580]], [[126563, 126563], "disallowed"], [[126564, 126564], "mapped", [1607]], [[126565, 126566], "disallowed"], [[126567, 126567], "mapped", [1581]], [[126568, 126568], "mapped", [1591]], [[126569, 126569], "mapped", [1610]], [[126570, 126570], "mapped", [1603]], [[126571, 126571], "disallowed"], [[126572, 126572], "mapped", [1605]], [[126573, 126573], "mapped", [1606]], [[126574, 126574], "mapped", [1587]], [[126575, 126575], "mapped", [1593]], [[126576, 126576], "mapped", [1601]], [[126577, 126577], "mapped", [1589]], [[126578, 126578], "mapped", [1602]], [[126579, 126579], "disallowed"], [[126580, 126580], "mapped", [1588]], [[126581, 126581], "mapped", [1578]], [[126582, 126582], "mapped", [1579]], [[126583, 126583], "mapped", [1582]], [[126584, 126584], "disallowed"], [[126585, 126585], "mapped", [1590]], [[126586, 126586], "mapped", [1592]], [[126587, 126587], "mapped", [1594]], [[126588, 126588], "mapped", [1646]], [[126589, 126589], "disallowed"], [[126590, 126590], "mapped", [1697]], [[126591, 126591], "disallowed"], [[126592, 126592], "mapped", [1575]], [[126593, 126593], "mapped", [1576]], [[126594, 126594], "mapped", [1580]], [[126595, 126595], "mapped", [1583]], [[126596, 126596], "mapped", [1607]], [[126597, 126597], "mapped", [1608]], [[126598, 126598], "mapped", [1586]], [[126599, 126599], "mapped", [1581]], [[126600, 126600], "mapped", [1591]], [[126601, 126601], "mapped", [1610]], [[126602, 126602], "disallowed"], [[126603, 126603], "mapped", [1604]], [[126604, 126604], "mapped", [1605]], [[126605, 126605], "mapped", [1606]], [[126606, 126606], "mapped", [1587]], [[126607, 126607], "mapped", [1593]], [[126608, 126608], "mapped", [1601]], [[126609, 126609], "mapped", [1589]], [[126610, 126610], "mapped", [1602]], [[126611, 126611], "mapped", [1585]], [[126612, 126612], "mapped", [1588]], [[126613, 126613], "mapped", [1578]], [[126614, 126614], "mapped", [1579]], [[126615, 126615], "mapped", [1582]], [[126616, 126616], "mapped", [1584]], [[126617, 126617], "mapped", [1590]], [[126618, 126618], "mapped", [1592]], [[126619, 126619], "mapped", [1594]], [[126620, 126624], "disallowed"], [[126625, 126625], "mapped", [1576]], [[126626, 126626], "mapped", [1580]], [[126627, 126627], "mapped", [1583]], [[126628, 126628], "disallowed"], [[126629, 126629], "mapped", [1608]], [[126630, 126630], "mapped", [1586]], [[126631, 126631], "mapped", [1581]], [[126632, 126632], "mapped", [1591]], [[126633, 126633], "mapped", [1610]], [[126634, 126634], "disallowed"], [[126635, 126635], "mapped", [1604]], [[126636, 126636], "mapped", [1605]], [[126637, 126637], "mapped", [1606]], [[126638, 126638], "mapped", [1587]], [[126639, 126639], "mapped", [1593]], [[126640, 126640], "mapped", [1601]], [[126641, 126641], "mapped", [1589]], [[126642, 126642], "mapped", [1602]], [[126643, 126643], "mapped", [1585]], [[126644, 126644], "mapped", [1588]], [[126645, 126645], "mapped", [1578]], [[126646, 126646], "mapped", [1579]], [[126647, 126647], "mapped", [1582]], [[126648, 126648], "mapped", [1584]], [[126649, 126649], "mapped", [1590]], [[126650, 126650], "mapped", [1592]], [[126651, 126651], "mapped", [1594]], [[126652, 126703], "disallowed"], [[126704, 126705], "valid", [], "NV8"], [[126706, 126975], "disallowed"], [[126976, 127019], "valid", [], "NV8"], [[127020, 127023], "disallowed"], [[127024, 127123], "valid", [], "NV8"], [[127124, 127135], "disallowed"], [[127136, 127150], "valid", [], "NV8"], [[127151, 127152], "disallowed"], [[127153, 127166], "valid", [], "NV8"], [[127167, 127167], "valid", [], "NV8"], [[127168, 127168], "disallowed"], [[127169, 127183], "valid", [], "NV8"], [[127184, 127184], "disallowed"], [[127185, 127199], "valid", [], "NV8"], [[127200, 127221], "valid", [], "NV8"], [[127222, 127231], "disallowed"], [[127232, 127232], "disallowed"], [[127233, 127233], "disallowed_STD3_mapped", [48, 44]], [[127234, 127234], "disallowed_STD3_mapped", [49, 44]], [[127235, 127235], "disallowed_STD3_mapped", [50, 44]], [[127236, 127236], "disallowed_STD3_mapped", [51, 44]], [[127237, 127237], "disallowed_STD3_mapped", [52, 44]], [[127238, 127238], "disallowed_STD3_mapped", [53, 44]], [[127239, 127239], "disallowed_STD3_mapped", [54, 44]], [[127240, 127240], "disallowed_STD3_mapped", [55, 44]], [[127241, 127241], "disallowed_STD3_mapped", [56, 44]], [[127242, 127242], "disallowed_STD3_mapped", [57, 44]], [[127243, 127244], "valid", [], "NV8"], [[127245, 127247], "disallowed"], [[127248, 127248], "disallowed_STD3_mapped", [40, 97, 41]], [[127249, 127249], "disallowed_STD3_mapped", [40, 98, 41]], [[127250, 127250], "disallowed_STD3_mapped", [40, 99, 41]], [[127251, 127251], "disallowed_STD3_mapped", [40, 100, 41]], [[127252, 127252], "disallowed_STD3_mapped", [40, 101, 41]], [[127253, 127253], "disallowed_STD3_mapped", [40, 102, 41]], [[127254, 127254], "disallowed_STD3_mapped", [40, 103, 41]], [[127255, 127255], "disallowed_STD3_mapped", [40, 104, 41]], [[127256, 127256], "disallowed_STD3_mapped", [40, 105, 41]], [[127257, 127257], "disallowed_STD3_mapped", [40, 106, 41]], [[127258, 127258], "disallowed_STD3_mapped", [40, 107, 41]], [[127259, 127259], "disallowed_STD3_mapped", [40, 108, 41]], [[127260, 127260], "disallowed_STD3_mapped", [40, 109, 41]], [[127261, 127261], "disallowed_STD3_mapped", [40, 110, 41]], [[127262, 127262], "disallowed_STD3_mapped", [40, 111, 41]], [[127263, 127263], "disallowed_STD3_mapped", [40, 112, 41]], [[127264, 127264], "disallowed_STD3_mapped", [40, 113, 41]], [[127265, 127265], "disallowed_STD3_mapped", [40, 114, 41]], [[127266, 127266], "disallowed_STD3_mapped", [40, 115, 41]], [[127267, 127267], "disallowed_STD3_mapped", [40, 116, 41]], [[127268, 127268], "disallowed_STD3_mapped", [40, 117, 41]], [[127269, 127269], "disallowed_STD3_mapped", [40, 118, 41]], [[127270, 127270], "disallowed_STD3_mapped", [40, 119, 41]], [[127271, 127271], "disallowed_STD3_mapped", [40, 120, 41]], [[127272, 127272], "disallowed_STD3_mapped", [40, 121, 41]], [[127273, 127273], "disallowed_STD3_mapped", [40, 122, 41]], [[127274, 127274], "mapped", [12308, 115, 12309]], [[127275, 127275], "mapped", [99]], [[127276, 127276], "mapped", [114]], [[127277, 127277], "mapped", [99, 100]], [[127278, 127278], "mapped", [119, 122]], [[127279, 127279], "disallowed"], [[127280, 127280], "mapped", [97]], [[127281, 127281], "mapped", [98]], [[127282, 127282], "mapped", [99]], [[127283, 127283], "mapped", [100]], [[127284, 127284], "mapped", [101]], [[127285, 127285], "mapped", [102]], [[127286, 127286], "mapped", [103]], [[127287, 127287], "mapped", [104]], [[127288, 127288], "mapped", [105]], [[127289, 127289], "mapped", [106]], [[127290, 127290], "mapped", [107]], [[127291, 127291], "mapped", [108]], [[127292, 127292], "mapped", [109]], [[127293, 127293], "mapped", [110]], [[127294, 127294], "mapped", [111]], [[127295, 127295], "mapped", [112]], [[127296, 127296], "mapped", [113]], [[127297, 127297], "mapped", [114]], [[127298, 127298], "mapped", [115]], [[127299, 127299], "mapped", [116]], [[127300, 127300], "mapped", [117]], [[127301, 127301], "mapped", [118]], [[127302, 127302], "mapped", [119]], [[127303, 127303], "mapped", [120]], [[127304, 127304], "mapped", [121]], [[127305, 127305], "mapped", [122]], [[127306, 127306], "mapped", [104, 118]], [[127307, 127307], "mapped", [109, 118]], [[127308, 127308], "mapped", [115, 100]], [[127309, 127309], "mapped", [115, 115]], [[127310, 127310], "mapped", [112, 112, 118]], [[127311, 127311], "mapped", [119, 99]], [[127312, 127318], "valid", [], "NV8"], [[127319, 127319], "valid", [], "NV8"], [[127320, 127326], "valid", [], "NV8"], [[127327, 127327], "valid", [], "NV8"], [[127328, 127337], "valid", [], "NV8"], [[127338, 127338], "mapped", [109, 99]], [[127339, 127339], "mapped", [109, 100]], [[127340, 127343], "disallowed"], [[127344, 127352], "valid", [], "NV8"], [[127353, 127353], "valid", [], "NV8"], [[127354, 127354], "valid", [], "NV8"], [[127355, 127356], "valid", [], "NV8"], [[127357, 127358], "valid", [], "NV8"], [[127359, 127359], "valid", [], "NV8"], [[127360, 127369], "valid", [], "NV8"], [[127370, 127373], "valid", [], "NV8"], [[127374, 127375], "valid", [], "NV8"], [[127376, 127376], "mapped", [100, 106]], [[127377, 127386], "valid", [], "NV8"], [[127387, 127461], "disallowed"], [[127462, 127487], "valid", [], "NV8"], [[127488, 127488], "mapped", [12411, 12363]], [[127489, 127489], "mapped", [12467, 12467]], [[127490, 127490], "mapped", [12469]], [[127491, 127503], "disallowed"], [[127504, 127504], "mapped", [25163]], [[127505, 127505], "mapped", [23383]], [[127506, 127506], "mapped", [21452]], [[127507, 127507], "mapped", [12487]], [[127508, 127508], "mapped", [20108]], [[127509, 127509], "mapped", [22810]], [[127510, 127510], "mapped", [35299]], [[127511, 127511], "mapped", [22825]], [[127512, 127512], "mapped", [20132]], [[127513, 127513], "mapped", [26144]], [[127514, 127514], "mapped", [28961]], [[127515, 127515], "mapped", [26009]], [[127516, 127516], "mapped", [21069]], [[127517, 127517], "mapped", [24460]], [[127518, 127518], "mapped", [20877]], [[127519, 127519], "mapped", [26032]], [[127520, 127520], "mapped", [21021]], [[127521, 127521], "mapped", [32066]], [[127522, 127522], "mapped", [29983]], [[127523, 127523], "mapped", [36009]], [[127524, 127524], "mapped", [22768]], [[127525, 127525], "mapped", [21561]], [[127526, 127526], "mapped", [28436]], [[127527, 127527], "mapped", [25237]], [[127528, 127528], "mapped", [25429]], [[127529, 127529], "mapped", [19968]], [[127530, 127530], "mapped", [19977]], [[127531, 127531], "mapped", [36938]], [[127532, 127532], "mapped", [24038]], [[127533, 127533], "mapped", [20013]], [[127534, 127534], "mapped", [21491]], [[127535, 127535], "mapped", [25351]], [[127536, 127536], "mapped", [36208]], [[127537, 127537], "mapped", [25171]], [[127538, 127538], "mapped", [31105]], [[127539, 127539], "mapped", [31354]], [[127540, 127540], "mapped", [21512]], [[127541, 127541], "mapped", [28288]], [[127542, 127542], "mapped", [26377]], [[127543, 127543], "mapped", [26376]], [[127544, 127544], "mapped", [30003]], [[127545, 127545], "mapped", [21106]], [[127546, 127546], "mapped", [21942]], [[127547, 127551], "disallowed"], [[127552, 127552], "mapped", [12308, 26412, 12309]], [[127553, 127553], "mapped", [12308, 19977, 12309]], [[127554, 127554], "mapped", [12308, 20108, 12309]], [[127555, 127555], "mapped", [12308, 23433, 12309]], [[127556, 127556], "mapped", [12308, 28857, 12309]], [[127557, 127557], "mapped", [12308, 25171, 12309]], [[127558, 127558], "mapped", [12308, 30423, 12309]], [[127559, 127559], "mapped", [12308, 21213, 12309]], [[127560, 127560], "mapped", [12308, 25943, 12309]], [[127561, 127567], "disallowed"], [[127568, 127568], "mapped", [24471]], [[127569, 127569], "mapped", [21487]], [[127570, 127743], "disallowed"], [[127744, 127776], "valid", [], "NV8"], [[127777, 127788], "valid", [], "NV8"], [[127789, 127791], "valid", [], "NV8"], [[127792, 127797], "valid", [], "NV8"], [[127798, 127798], "valid", [], "NV8"], [[127799, 127868], "valid", [], "NV8"], [[127869, 127869], "valid", [], "NV8"], [[127870, 127871], "valid", [], "NV8"], [[127872, 127891], "valid", [], "NV8"], [[127892, 127903], "valid", [], "NV8"], [[127904, 127940], "valid", [], "NV8"], [[127941, 127941], "valid", [], "NV8"], [[127942, 127946], "valid", [], "NV8"], [[127947, 127950], "valid", [], "NV8"], [[127951, 127955], "valid", [], "NV8"], [[127956, 127967], "valid", [], "NV8"], [[127968, 127984], "valid", [], "NV8"], [[127985, 127991], "valid", [], "NV8"], [[127992, 127999], "valid", [], "NV8"], [[128e3, 128062], "valid", [], "NV8"], [[128063, 128063], "valid", [], "NV8"], [[128064, 128064], "valid", [], "NV8"], [[128065, 128065], "valid", [], "NV8"], [[128066, 128247], "valid", [], "NV8"], [[128248, 128248], "valid", [], "NV8"], [[128249, 128252], "valid", [], "NV8"], [[128253, 128254], "valid", [], "NV8"], [[128255, 128255], "valid", [], "NV8"], [[128256, 128317], "valid", [], "NV8"], [[128318, 128319], "valid", [], "NV8"], [[128320, 128323], "valid", [], "NV8"], [[128324, 128330], "valid", [], "NV8"], [[128331, 128335], "valid", [], "NV8"], [[128336, 128359], "valid", [], "NV8"], [[128360, 128377], "valid", [], "NV8"], [[128378, 128378], "disallowed"], [[128379, 128419], "valid", [], "NV8"], [[128420, 128420], "disallowed"], [[128421, 128506], "valid", [], "NV8"], [[128507, 128511], "valid", [], "NV8"], [[128512, 128512], "valid", [], "NV8"], [[128513, 128528], "valid", [], "NV8"], [[128529, 128529], "valid", [], "NV8"], [[128530, 128532], "valid", [], "NV8"], [[128533, 128533], "valid", [], "NV8"], [[128534, 128534], "valid", [], "NV8"], [[128535, 128535], "valid", [], "NV8"], [[128536, 128536], "valid", [], "NV8"], [[128537, 128537], "valid", [], "NV8"], [[128538, 128538], "valid", [], "NV8"], [[128539, 128539], "valid", [], "NV8"], [[128540, 128542], "valid", [], "NV8"], [[128543, 128543], "valid", [], "NV8"], [[128544, 128549], "valid", [], "NV8"], [[128550, 128551], "valid", [], "NV8"], [[128552, 128555], "valid", [], "NV8"], [[128556, 128556], "valid", [], "NV8"], [[128557, 128557], "valid", [], "NV8"], [[128558, 128559], "valid", [], "NV8"], [[128560, 128563], "valid", [], "NV8"], [[128564, 128564], "valid", [], "NV8"], [[128565, 128576], "valid", [], "NV8"], [[128577, 128578], "valid", [], "NV8"], [[128579, 128580], "valid", [], "NV8"], [[128581, 128591], "valid", [], "NV8"], [[128592, 128639], "valid", [], "NV8"], [[128640, 128709], "valid", [], "NV8"], [[128710, 128719], "valid", [], "NV8"], [[128720, 128720], "valid", [], "NV8"], [[128721, 128735], "disallowed"], [[128736, 128748], "valid", [], "NV8"], [[128749, 128751], "disallowed"], [[128752, 128755], "valid", [], "NV8"], [[128756, 128767], "disallowed"], [[128768, 128883], "valid", [], "NV8"], [[128884, 128895], "disallowed"], [[128896, 128980], "valid", [], "NV8"], [[128981, 129023], "disallowed"], [[129024, 129035], "valid", [], "NV8"], [[129036, 129039], "disallowed"], [[129040, 129095], "valid", [], "NV8"], [[129096, 129103], "disallowed"], [[129104, 129113], "valid", [], "NV8"], [[129114, 129119], "disallowed"], [[129120, 129159], "valid", [], "NV8"], [[129160, 129167], "disallowed"], [[129168, 129197], "valid", [], "NV8"], [[129198, 129295], "disallowed"], [[129296, 129304], "valid", [], "NV8"], [[129305, 129407], "disallowed"], [[129408, 129412], "valid", [], "NV8"], [[129413, 129471], "disallowed"], [[129472, 129472], "valid", [], "NV8"], [[129473, 131069], "disallowed"], [[131070, 131071], "disallowed"], [[131072, 173782], "valid"], [[173783, 173823], "disallowed"], [[173824, 177972], "valid"], [[177973, 177983], "disallowed"], [[177984, 178205], "valid"], [[178206, 178207], "disallowed"], [[178208, 183969], "valid"], [[183970, 194559], "disallowed"], [[194560, 194560], "mapped", [20029]], [[194561, 194561], "mapped", [20024]], [[194562, 194562], "mapped", [20033]], [[194563, 194563], "mapped", [131362]], [[194564, 194564], "mapped", [20320]], [[194565, 194565], "mapped", [20398]], [[194566, 194566], "mapped", [20411]], [[194567, 194567], "mapped", [20482]], [[194568, 194568], "mapped", [20602]], [[194569, 194569], "mapped", [20633]], [[194570, 194570], "mapped", [20711]], [[194571, 194571], "mapped", [20687]], [[194572, 194572], "mapped", [13470]], [[194573, 194573], "mapped", [132666]], [[194574, 194574], "mapped", [20813]], [[194575, 194575], "mapped", [20820]], [[194576, 194576], "mapped", [20836]], [[194577, 194577], "mapped", [20855]], [[194578, 194578], "mapped", [132380]], [[194579, 194579], "mapped", [13497]], [[194580, 194580], "mapped", [20839]], [[194581, 194581], "mapped", [20877]], [[194582, 194582], "mapped", [132427]], [[194583, 194583], "mapped", [20887]], [[194584, 194584], "mapped", [20900]], [[194585, 194585], "mapped", [20172]], [[194586, 194586], "mapped", [20908]], [[194587, 194587], "mapped", [20917]], [[194588, 194588], "mapped", [168415]], [[194589, 194589], "mapped", [20981]], [[194590, 194590], "mapped", [20995]], [[194591, 194591], "mapped", [13535]], [[194592, 194592], "mapped", [21051]], [[194593, 194593], "mapped", [21062]], [[194594, 194594], "mapped", [21106]], [[194595, 194595], "mapped", [21111]], [[194596, 194596], "mapped", [13589]], [[194597, 194597], "mapped", [21191]], [[194598, 194598], "mapped", [21193]], [[194599, 194599], "mapped", [21220]], [[194600, 194600], "mapped", [21242]], [[194601, 194601], "mapped", [21253]], [[194602, 194602], "mapped", [21254]], [[194603, 194603], "mapped", [21271]], [[194604, 194604], "mapped", [21321]], [[194605, 194605], "mapped", [21329]], [[194606, 194606], "mapped", [21338]], [[194607, 194607], "mapped", [21363]], [[194608, 194608], "mapped", [21373]], [[194609, 194611], "mapped", [21375]], [[194612, 194612], "mapped", [133676]], [[194613, 194613], "mapped", [28784]], [[194614, 194614], "mapped", [21450]], [[194615, 194615], "mapped", [21471]], [[194616, 194616], "mapped", [133987]], [[194617, 194617], "mapped", [21483]], [[194618, 194618], "mapped", [21489]], [[194619, 194619], "mapped", [21510]], [[194620, 194620], "mapped", [21662]], [[194621, 194621], "mapped", [21560]], [[194622, 194622], "mapped", [21576]], [[194623, 194623], "mapped", [21608]], [[194624, 194624], "mapped", [21666]], [[194625, 194625], "mapped", [21750]], [[194626, 194626], "mapped", [21776]], [[194627, 194627], "mapped", [21843]], [[194628, 194628], "mapped", [21859]], [[194629, 194630], "mapped", [21892]], [[194631, 194631], "mapped", [21913]], [[194632, 194632], "mapped", [21931]], [[194633, 194633], "mapped", [21939]], [[194634, 194634], "mapped", [21954]], [[194635, 194635], "mapped", [22294]], [[194636, 194636], "mapped", [22022]], [[194637, 194637], "mapped", [22295]], [[194638, 194638], "mapped", [22097]], [[194639, 194639], "mapped", [22132]], [[194640, 194640], "mapped", [20999]], [[194641, 194641], "mapped", [22766]], [[194642, 194642], "mapped", [22478]], [[194643, 194643], "mapped", [22516]], [[194644, 194644], "mapped", [22541]], [[194645, 194645], "mapped", [22411]], [[194646, 194646], "mapped", [22578]], [[194647, 194647], "mapped", [22577]], [[194648, 194648], "mapped", [22700]], [[194649, 194649], "mapped", [136420]], [[194650, 194650], "mapped", [22770]], [[194651, 194651], "mapped", [22775]], [[194652, 194652], "mapped", [22790]], [[194653, 194653], "mapped", [22810]], [[194654, 194654], "mapped", [22818]], [[194655, 194655], "mapped", [22882]], [[194656, 194656], "mapped", [136872]], [[194657, 194657], "mapped", [136938]], [[194658, 194658], "mapped", [23020]], [[194659, 194659], "mapped", [23067]], [[194660, 194660], "mapped", [23079]], [[194661, 194661], "mapped", [23e3]], [[194662, 194662], "mapped", [23142]], [[194663, 194663], "mapped", [14062]], [[194664, 194664], "disallowed"], [[194665, 194665], "mapped", [23304]], [[194666, 194667], "mapped", [23358]], [[194668, 194668], "mapped", [137672]], [[194669, 194669], "mapped", [23491]], [[194670, 194670], "mapped", [23512]], [[194671, 194671], "mapped", [23527]], [[194672, 194672], "mapped", [23539]], [[194673, 194673], "mapped", [138008]], [[194674, 194674], "mapped", [23551]], [[194675, 194675], "mapped", [23558]], [[194676, 194676], "disallowed"], [[194677, 194677], "mapped", [23586]], [[194678, 194678], "mapped", [14209]], [[194679, 194679], "mapped", [23648]], [[194680, 194680], "mapped", [23662]], [[194681, 194681], "mapped", [23744]], [[194682, 194682], "mapped", [23693]], [[194683, 194683], "mapped", [138724]], [[194684, 194684], "mapped", [23875]], [[194685, 194685], "mapped", [138726]], [[194686, 194686], "mapped", [23918]], [[194687, 194687], "mapped", [23915]], [[194688, 194688], "mapped", [23932]], [[194689, 194689], "mapped", [24033]], [[194690, 194690], "mapped", [24034]], [[194691, 194691], "mapped", [14383]], [[194692, 194692], "mapped", [24061]], [[194693, 194693], "mapped", [24104]], [[194694, 194694], "mapped", [24125]], [[194695, 194695], "mapped", [24169]], [[194696, 194696], "mapped", [14434]], [[194697, 194697], "mapped", [139651]], [[194698, 194698], "mapped", [14460]], [[194699, 194699], "mapped", [24240]], [[194700, 194700], "mapped", [24243]], [[194701, 194701], "mapped", [24246]], [[194702, 194702], "mapped", [24266]], [[194703, 194703], "mapped", [172946]], [[194704, 194704], "mapped", [24318]], [[194705, 194706], "mapped", [140081]], [[194707, 194707], "mapped", [33281]], [[194708, 194709], "mapped", [24354]], [[194710, 194710], "mapped", [14535]], [[194711, 194711], "mapped", [144056]], [[194712, 194712], "mapped", [156122]], [[194713, 194713], "mapped", [24418]], [[194714, 194714], "mapped", [24427]], [[194715, 194715], "mapped", [14563]], [[194716, 194716], "mapped", [24474]], [[194717, 194717], "mapped", [24525]], [[194718, 194718], "mapped", [24535]], [[194719, 194719], "mapped", [24569]], [[194720, 194720], "mapped", [24705]], [[194721, 194721], "mapped", [14650]], [[194722, 194722], "mapped", [14620]], [[194723, 194723], "mapped", [24724]], [[194724, 194724], "mapped", [141012]], [[194725, 194725], "mapped", [24775]], [[194726, 194726], "mapped", [24904]], [[194727, 194727], "mapped", [24908]], [[194728, 194728], "mapped", [24910]], [[194729, 194729], "mapped", [24908]], [[194730, 194730], "mapped", [24954]], [[194731, 194731], "mapped", [24974]], [[194732, 194732], "mapped", [25010]], [[194733, 194733], "mapped", [24996]], [[194734, 194734], "mapped", [25007]], [[194735, 194735], "mapped", [25054]], [[194736, 194736], "mapped", [25074]], [[194737, 194737], "mapped", [25078]], [[194738, 194738], "mapped", [25104]], [[194739, 194739], "mapped", [25115]], [[194740, 194740], "mapped", [25181]], [[194741, 194741], "mapped", [25265]], [[194742, 194742], "mapped", [25300]], [[194743, 194743], "mapped", [25424]], [[194744, 194744], "mapped", [142092]], [[194745, 194745], "mapped", [25405]], [[194746, 194746], "mapped", [25340]], [[194747, 194747], "mapped", [25448]], [[194748, 194748], "mapped", [25475]], [[194749, 194749], "mapped", [25572]], [[194750, 194750], "mapped", [142321]], [[194751, 194751], "mapped", [25634]], [[194752, 194752], "mapped", [25541]], [[194753, 194753], "mapped", [25513]], [[194754, 194754], "mapped", [14894]], [[194755, 194755], "mapped", [25705]], [[194756, 194756], "mapped", [25726]], [[194757, 194757], "mapped", [25757]], [[194758, 194758], "mapped", [25719]], [[194759, 194759], "mapped", [14956]], [[194760, 194760], "mapped", [25935]], [[194761, 194761], "mapped", [25964]], [[194762, 194762], "mapped", [143370]], [[194763, 194763], "mapped", [26083]], [[194764, 194764], "mapped", [26360]], [[194765, 194765], "mapped", [26185]], [[194766, 194766], "mapped", [15129]], [[194767, 194767], "mapped", [26257]], [[194768, 194768], "mapped", [15112]], [[194769, 194769], "mapped", [15076]], [[194770, 194770], "mapped", [20882]], [[194771, 194771], "mapped", [20885]], [[194772, 194772], "mapped", [26368]], [[194773, 194773], "mapped", [26268]], [[194774, 194774], "mapped", [32941]], [[194775, 194775], "mapped", [17369]], [[194776, 194776], "mapped", [26391]], [[194777, 194777], "mapped", [26395]], [[194778, 194778], "mapped", [26401]], [[194779, 194779], "mapped", [26462]], [[194780, 194780], "mapped", [26451]], [[194781, 194781], "mapped", [144323]], [[194782, 194782], "mapped", [15177]], [[194783, 194783], "mapped", [26618]], [[194784, 194784], "mapped", [26501]], [[194785, 194785], "mapped", [26706]], [[194786, 194786], "mapped", [26757]], [[194787, 194787], "mapped", [144493]], [[194788, 194788], "mapped", [26766]], [[194789, 194789], "mapped", [26655]], [[194790, 194790], "mapped", [26900]], [[194791, 194791], "mapped", [15261]], [[194792, 194792], "mapped", [26946]], [[194793, 194793], "mapped", [27043]], [[194794, 194794], "mapped", [27114]], [[194795, 194795], "mapped", [27304]], [[194796, 194796], "mapped", [145059]], [[194797, 194797], "mapped", [27355]], [[194798, 194798], "mapped", [15384]], [[194799, 194799], "mapped", [27425]], [[194800, 194800], "mapped", [145575]], [[194801, 194801], "mapped", [27476]], [[194802, 194802], "mapped", [15438]], [[194803, 194803], "mapped", [27506]], [[194804, 194804], "mapped", [27551]], [[194805, 194805], "mapped", [27578]], [[194806, 194806], "mapped", [27579]], [[194807, 194807], "mapped", [146061]], [[194808, 194808], "mapped", [138507]], [[194809, 194809], "mapped", [146170]], [[194810, 194810], "mapped", [27726]], [[194811, 194811], "mapped", [146620]], [[194812, 194812], "mapped", [27839]], [[194813, 194813], "mapped", [27853]], [[194814, 194814], "mapped", [27751]], [[194815, 194815], "mapped", [27926]], [[194816, 194816], "mapped", [27966]], [[194817, 194817], "mapped", [28023]], [[194818, 194818], "mapped", [27969]], [[194819, 194819], "mapped", [28009]], [[194820, 194820], "mapped", [28024]], [[194821, 194821], "mapped", [28037]], [[194822, 194822], "mapped", [146718]], [[194823, 194823], "mapped", [27956]], [[194824, 194824], "mapped", [28207]], [[194825, 194825], "mapped", [28270]], [[194826, 194826], "mapped", [15667]], [[194827, 194827], "mapped", [28363]], [[194828, 194828], "mapped", [28359]], [[194829, 194829], "mapped", [147153]], [[194830, 194830], "mapped", [28153]], [[194831, 194831], "mapped", [28526]], [[194832, 194832], "mapped", [147294]], [[194833, 194833], "mapped", [147342]], [[194834, 194834], "mapped", [28614]], [[194835, 194835], "mapped", [28729]], [[194836, 194836], "mapped", [28702]], [[194837, 194837], "mapped", [28699]], [[194838, 194838], "mapped", [15766]], [[194839, 194839], "mapped", [28746]], [[194840, 194840], "mapped", [28797]], [[194841, 194841], "mapped", [28791]], [[194842, 194842], "mapped", [28845]], [[194843, 194843], "mapped", [132389]], [[194844, 194844], "mapped", [28997]], [[194845, 194845], "mapped", [148067]], [[194846, 194846], "mapped", [29084]], [[194847, 194847], "disallowed"], [[194848, 194848], "mapped", [29224]], [[194849, 194849], "mapped", [29237]], [[194850, 194850], "mapped", [29264]], [[194851, 194851], "mapped", [149e3]], [[194852, 194852], "mapped", [29312]], [[194853, 194853], "mapped", [29333]], [[194854, 194854], "mapped", [149301]], [[194855, 194855], "mapped", [149524]], [[194856, 194856], "mapped", [29562]], [[194857, 194857], "mapped", [29579]], [[194858, 194858], "mapped", [16044]], [[194859, 194859], "mapped", [29605]], [[194860, 194861], "mapped", [16056]], [[194862, 194862], "mapped", [29767]], [[194863, 194863], "mapped", [29788]], [[194864, 194864], "mapped", [29809]], [[194865, 194865], "mapped", [29829]], [[194866, 194866], "mapped", [29898]], [[194867, 194867], "mapped", [16155]], [[194868, 194868], "mapped", [29988]], [[194869, 194869], "mapped", [150582]], [[194870, 194870], "mapped", [30014]], [[194871, 194871], "mapped", [150674]], [[194872, 194872], "mapped", [30064]], [[194873, 194873], "mapped", [139679]], [[194874, 194874], "mapped", [30224]], [[194875, 194875], "mapped", [151457]], [[194876, 194876], "mapped", [151480]], [[194877, 194877], "mapped", [151620]], [[194878, 194878], "mapped", [16380]], [[194879, 194879], "mapped", [16392]], [[194880, 194880], "mapped", [30452]], [[194881, 194881], "mapped", [151795]], [[194882, 194882], "mapped", [151794]], [[194883, 194883], "mapped", [151833]], [[194884, 194884], "mapped", [151859]], [[194885, 194885], "mapped", [30494]], [[194886, 194887], "mapped", [30495]], [[194888, 194888], "mapped", [30538]], [[194889, 194889], "mapped", [16441]], [[194890, 194890], "mapped", [30603]], [[194891, 194891], "mapped", [16454]], [[194892, 194892], "mapped", [16534]], [[194893, 194893], "mapped", [152605]], [[194894, 194894], "mapped", [30798]], [[194895, 194895], "mapped", [30860]], [[194896, 194896], "mapped", [30924]], [[194897, 194897], "mapped", [16611]], [[194898, 194898], "mapped", [153126]], [[194899, 194899], "mapped", [31062]], [[194900, 194900], "mapped", [153242]], [[194901, 194901], "mapped", [153285]], [[194902, 194902], "mapped", [31119]], [[194903, 194903], "mapped", [31211]], [[194904, 194904], "mapped", [16687]], [[194905, 194905], "mapped", [31296]], [[194906, 194906], "mapped", [31306]], [[194907, 194907], "mapped", [31311]], [[194908, 194908], "mapped", [153980]], [[194909, 194910], "mapped", [154279]], [[194911, 194911], "disallowed"], [[194912, 194912], "mapped", [16898]], [[194913, 194913], "mapped", [154539]], [[194914, 194914], "mapped", [31686]], [[194915, 194915], "mapped", [31689]], [[194916, 194916], "mapped", [16935]], [[194917, 194917], "mapped", [154752]], [[194918, 194918], "mapped", [31954]], [[194919, 194919], "mapped", [17056]], [[194920, 194920], "mapped", [31976]], [[194921, 194921], "mapped", [31971]], [[194922, 194922], "mapped", [32e3]], [[194923, 194923], "mapped", [155526]], [[194924, 194924], "mapped", [32099]], [[194925, 194925], "mapped", [17153]], [[194926, 194926], "mapped", [32199]], [[194927, 194927], "mapped", [32258]], [[194928, 194928], "mapped", [32325]], [[194929, 194929], "mapped", [17204]], [[194930, 194930], "mapped", [156200]], [[194931, 194931], "mapped", [156231]], [[194932, 194932], "mapped", [17241]], [[194933, 194933], "mapped", [156377]], [[194934, 194934], "mapped", [32634]], [[194935, 194935], "mapped", [156478]], [[194936, 194936], "mapped", [32661]], [[194937, 194937], "mapped", [32762]], [[194938, 194938], "mapped", [32773]], [[194939, 194939], "mapped", [156890]], [[194940, 194940], "mapped", [156963]], [[194941, 194941], "mapped", [32864]], [[194942, 194942], "mapped", [157096]], [[194943, 194943], "mapped", [32880]], [[194944, 194944], "mapped", [144223]], [[194945, 194945], "mapped", [17365]], [[194946, 194946], "mapped", [32946]], [[194947, 194947], "mapped", [33027]], [[194948, 194948], "mapped", [17419]], [[194949, 194949], "mapped", [33086]], [[194950, 194950], "mapped", [23221]], [[194951, 194951], "mapped", [157607]], [[194952, 194952], "mapped", [157621]], [[194953, 194953], "mapped", [144275]], [[194954, 194954], "mapped", [144284]], [[194955, 194955], "mapped", [33281]], [[194956, 194956], "mapped", [33284]], [[194957, 194957], "mapped", [36766]], [[194958, 194958], "mapped", [17515]], [[194959, 194959], "mapped", [33425]], [[194960, 194960], "mapped", [33419]], [[194961, 194961], "mapped", [33437]], [[194962, 194962], "mapped", [21171]], [[194963, 194963], "mapped", [33457]], [[194964, 194964], "mapped", [33459]], [[194965, 194965], "mapped", [33469]], [[194966, 194966], "mapped", [33510]], [[194967, 194967], "mapped", [158524]], [[194968, 194968], "mapped", [33509]], [[194969, 194969], "mapped", [33565]], [[194970, 194970], "mapped", [33635]], [[194971, 194971], "mapped", [33709]], [[194972, 194972], "mapped", [33571]], [[194973, 194973], "mapped", [33725]], [[194974, 194974], "mapped", [33767]], [[194975, 194975], "mapped", [33879]], [[194976, 194976], "mapped", [33619]], [[194977, 194977], "mapped", [33738]], [[194978, 194978], "mapped", [33740]], [[194979, 194979], "mapped", [33756]], [[194980, 194980], "mapped", [158774]], [[194981, 194981], "mapped", [159083]], [[194982, 194982], "mapped", [158933]], [[194983, 194983], "mapped", [17707]], [[194984, 194984], "mapped", [34033]], [[194985, 194985], "mapped", [34035]], [[194986, 194986], "mapped", [34070]], [[194987, 194987], "mapped", [160714]], [[194988, 194988], "mapped", [34148]], [[194989, 194989], "mapped", [159532]], [[194990, 194990], "mapped", [17757]], [[194991, 194991], "mapped", [17761]], [[194992, 194992], "mapped", [159665]], [[194993, 194993], "mapped", [159954]], [[194994, 194994], "mapped", [17771]], [[194995, 194995], "mapped", [34384]], [[194996, 194996], "mapped", [34396]], [[194997, 194997], "mapped", [34407]], [[194998, 194998], "mapped", [34409]], [[194999, 194999], "mapped", [34473]], [[195e3, 195e3], "mapped", [34440]], [[195001, 195001], "mapped", [34574]], [[195002, 195002], "mapped", [34530]], [[195003, 195003], "mapped", [34681]], [[195004, 195004], "mapped", [34600]], [[195005, 195005], "mapped", [34667]], [[195006, 195006], "mapped", [34694]], [[195007, 195007], "disallowed"], [[195008, 195008], "mapped", [34785]], [[195009, 195009], "mapped", [34817]], [[195010, 195010], "mapped", [17913]], [[195011, 195011], "mapped", [34912]], [[195012, 195012], "mapped", [34915]], [[195013, 195013], "mapped", [161383]], [[195014, 195014], "mapped", [35031]], [[195015, 195015], "mapped", [35038]], [[195016, 195016], "mapped", [17973]], [[195017, 195017], "mapped", [35066]], [[195018, 195018], "mapped", [13499]], [[195019, 195019], "mapped", [161966]], [[195020, 195020], "mapped", [162150]], [[195021, 195021], "mapped", [18110]], [[195022, 195022], "mapped", [18119]], [[195023, 195023], "mapped", [35488]], [[195024, 195024], "mapped", [35565]], [[195025, 195025], "mapped", [35722]], [[195026, 195026], "mapped", [35925]], [[195027, 195027], "mapped", [162984]], [[195028, 195028], "mapped", [36011]], [[195029, 195029], "mapped", [36033]], [[195030, 195030], "mapped", [36123]], [[195031, 195031], "mapped", [36215]], [[195032, 195032], "mapped", [163631]], [[195033, 195033], "mapped", [133124]], [[195034, 195034], "mapped", [36299]], [[195035, 195035], "mapped", [36284]], [[195036, 195036], "mapped", [36336]], [[195037, 195037], "mapped", [133342]], [[195038, 195038], "mapped", [36564]], [[195039, 195039], "mapped", [36664]], [[195040, 195040], "mapped", [165330]], [[195041, 195041], "mapped", [165357]], [[195042, 195042], "mapped", [37012]], [[195043, 195043], "mapped", [37105]], [[195044, 195044], "mapped", [37137]], [[195045, 195045], "mapped", [165678]], [[195046, 195046], "mapped", [37147]], [[195047, 195047], "mapped", [37432]], [[195048, 195048], "mapped", [37591]], [[195049, 195049], "mapped", [37592]], [[195050, 195050], "mapped", [37500]], [[195051, 195051], "mapped", [37881]], [[195052, 195052], "mapped", [37909]], [[195053, 195053], "mapped", [166906]], [[195054, 195054], "mapped", [38283]], [[195055, 195055], "mapped", [18837]], [[195056, 195056], "mapped", [38327]], [[195057, 195057], "mapped", [167287]], [[195058, 195058], "mapped", [18918]], [[195059, 195059], "mapped", [38595]], [[195060, 195060], "mapped", [23986]], [[195061, 195061], "mapped", [38691]], [[195062, 195062], "mapped", [168261]], [[195063, 195063], "mapped", [168474]], [[195064, 195064], "mapped", [19054]], [[195065, 195065], "mapped", [19062]], [[195066, 195066], "mapped", [38880]], [[195067, 195067], "mapped", [168970]], [[195068, 195068], "mapped", [19122]], [[195069, 195069], "mapped", [169110]], [[195070, 195071], "mapped", [38923]], [[195072, 195072], "mapped", [38953]], [[195073, 195073], "mapped", [169398]], [[195074, 195074], "mapped", [39138]], [[195075, 195075], "mapped", [19251]], [[195076, 195076], "mapped", [39209]], [[195077, 195077], "mapped", [39335]], [[195078, 195078], "mapped", [39362]], [[195079, 195079], "mapped", [39422]], [[195080, 195080], "mapped", [19406]], [[195081, 195081], "mapped", [170800]], [[195082, 195082], "mapped", [39698]], [[195083, 195083], "mapped", [4e4]], [[195084, 195084], "mapped", [40189]], [[195085, 195085], "mapped", [19662]], [[195086, 195086], "mapped", [19693]], [[195087, 195087], "mapped", [40295]], [[195088, 195088], "mapped", [172238]], [[195089, 195089], "mapped", [19704]], [[195090, 195090], "mapped", [172293]], [[195091, 195091], "mapped", [172558]], [[195092, 195092], "mapped", [172689]], [[195093, 195093], "mapped", [40635]], [[195094, 195094], "mapped", [19798]], [[195095, 195095], "mapped", [40697]], [[195096, 195096], "mapped", [40702]], [[195097, 195097], "mapped", [40709]], [[195098, 195098], "mapped", [40719]], [[195099, 195099], "mapped", [40726]], [[195100, 195100], "mapped", [40763]], [[195101, 195101], "mapped", [173568]], [[195102, 196605], "disallowed"], [[196606, 196607], "disallowed"], [[196608, 262141], "disallowed"], [[262142, 262143], "disallowed"], [[262144, 327677], "disallowed"], [[327678, 327679], "disallowed"], [[327680, 393213], "disallowed"], [[393214, 393215], "disallowed"], [[393216, 458749], "disallowed"], [[458750, 458751], "disallowed"], [[458752, 524285], "disallowed"], [[524286, 524287], "disallowed"], [[524288, 589821], "disallowed"], [[589822, 589823], "disallowed"], [[589824, 655357], "disallowed"], [[655358, 655359], "disallowed"], [[655360, 720893], "disallowed"], [[720894, 720895], "disallowed"], [[720896, 786429], "disallowed"], [[786430, 786431], "disallowed"], [[786432, 851965], "disallowed"], [[851966, 851967], "disallowed"], [[851968, 917501], "disallowed"], [[917502, 917503], "disallowed"], [[917504, 917504], "disallowed"], [[917505, 917505], "disallowed"], [[917506, 917535], "disallowed"], [[917536, 917631], "disallowed"], [[917632, 917759], "disallowed"], [[917760, 917999], "ignored"], [[918e3, 983037], "disallowed"], [[983038, 983039], "disallowed"], [[983040, 1048573], "disallowed"], [[1048574, 1048575], "disallowed"], [[1048576, 1114109], "disallowed"], [[1114110, 1114111], "disallowed"]]; + } +}); + +// node_modules/tr46/index.js +var require_tr46 = __commonJS({ + "node_modules/tr46/index.js"(exports2, module2) { + "use strict"; + var punycode = require("punycode"); + var mappingTable = require_mappingTable(); + var PROCESSING_OPTIONS = { + TRANSITIONAL: 0, + NONTRANSITIONAL: 1 + }; + function normalize(str) { + return str.split("\0").map(function(s) { + return s.normalize("NFC"); + }).join("\0"); + } + function findStatus(val) { + var start = 0; + var end = mappingTable.length - 1; + while (start <= end) { + var mid = Math.floor((start + end) / 2); + var target = mappingTable[mid]; + if (target[0][0] <= val && target[0][1] >= val) { + return target; + } else if (target[0][0] > val) { + end = mid - 1; + } else { + start = mid + 1; + } + } + return null; + } + var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + function countSymbols(string) { + return string.replace(regexAstralSymbols, "_").length; + } + function mapChars(domain_name, useSTD3, processing_option) { + var hasError = false; + var processed = ""; + var len = countSymbols(domain_name); + for (var i = 0; i < len; ++i) { + var codePoint = domain_name.codePointAt(i); + var status = findStatus(codePoint); + switch (status[1]) { + case "disallowed": + hasError = true; + processed += String.fromCodePoint(codePoint); + break; + case "ignored": + break; + case "mapped": + processed += String.fromCodePoint.apply(String, status[2]); + break; + case "deviation": + if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL) { + processed += String.fromCodePoint.apply(String, status[2]); + } else { + processed += String.fromCodePoint(codePoint); + } + break; + case "valid": + processed += String.fromCodePoint(codePoint); + break; + case "disallowed_STD3_mapped": + if (useSTD3) { + hasError = true; + processed += String.fromCodePoint(codePoint); + } else { + processed += String.fromCodePoint.apply(String, status[2]); + } + break; + case "disallowed_STD3_valid": + if (useSTD3) { + hasError = true; + } + processed += String.fromCodePoint(codePoint); + break; + } + } + return { + string: processed, + error: hasError + }; + } + var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/; + function validateLabel(label, processing_option) { + if (label.substr(0, 4) === "xn--") { + label = punycode.toUnicode(label); + processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL; + } + var error = false; + if (normalize(label) !== label || label[3] === "-" && label[4] === "-" || label[0] === "-" || label[label.length - 1] === "-" || label.indexOf(".") !== -1 || label.search(combiningMarksRegex) === 0) { + error = true; + } + var len = countSymbols(label); + for (var i = 0; i < len; ++i) { + var status = findStatus(label.codePointAt(i)); + if (processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid" || processing === PROCESSING_OPTIONS.NONTRANSITIONAL && status[1] !== "valid" && status[1] !== "deviation") { + error = true; + break; + } + } + return { + label, + error + }; + } + function processing(domain_name, useSTD3, processing_option) { + var result = mapChars(domain_name, useSTD3, processing_option); + result.string = normalize(result.string); + var labels = result.string.split("."); + for (var i = 0; i < labels.length; ++i) { + try { + var validation = validateLabel(labels[i]); + labels[i] = validation.label; + result.error = result.error || validation.error; + } catch (e) { + result.error = true; + } + } + return { + string: labels.join("."), + error: result.error + }; + } + module2.exports.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) { + var result = processing(domain_name, useSTD3, processing_option); + var labels = result.string.split("."); + labels = labels.map(function(l) { + try { + return punycode.toASCII(l); + } catch (e) { + result.error = true; + return l; + } + }); + if (verifyDnsLength) { + var total = labels.slice(0, labels.length - 1).join(".").length; + if (total.length > 253 || total.length === 0) { + result.error = true; + } + for (var i = 0; i < labels.length; ++i) { + if (labels.length > 63 || labels.length === 0) { + result.error = true; + break; + } + } + } + if (result.error) + return null; + return labels.join("."); + }; + module2.exports.toUnicode = function(domain_name, useSTD3) { + var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL); + return { + domain: result.string, + error: result.error + }; + }; + module2.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS; + } +}); + +// node_modules/whatwg-url/lib/url-state-machine.js +var require_url_state_machine = __commonJS({ + "node_modules/whatwg-url/lib/url-state-machine.js"(exports2, module2) { + "use strict"; + var punycode = require("punycode"); + var tr46 = require_tr46(); + var specialSchemes = { + ftp: 21, + file: null, + gopher: 70, + http: 80, + https: 443, + ws: 80, + wss: 443 + }; + var failure = Symbol("failure"); + function countSymbols(str) { + return punycode.ucs2.decode(str).length; + } + function at(input, idx) { + const c = input[idx]; + return isNaN(c) ? void 0 : String.fromCodePoint(c); + } + function isASCIIDigit(c) { + return c >= 48 && c <= 57; + } + function isASCIIAlpha(c) { + return c >= 65 && c <= 90 || c >= 97 && c <= 122; + } + function isASCIIAlphanumeric(c) { + return isASCIIAlpha(c) || isASCIIDigit(c); + } + function isASCIIHex(c) { + return isASCIIDigit(c) || c >= 65 && c <= 70 || c >= 97 && c <= 102; + } + function isSingleDot(buffer) { + return buffer === "." || buffer.toLowerCase() === "%2e"; + } + function isDoubleDot(buffer) { + buffer = buffer.toLowerCase(); + return buffer === ".." || buffer === "%2e." || buffer === ".%2e" || buffer === "%2e%2e"; + } + function isWindowsDriveLetterCodePoints(cp1, cp2) { + return isASCIIAlpha(cp1) && (cp2 === 58 || cp2 === 124); + } + function isWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && (string[1] === ":" || string[1] === "|"); + } + function isNormalizedWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && string[1] === ":"; + } + function containsForbiddenHostCodePoint(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|%|\/|:|\?|@|\[|\\|\]/) !== -1; + } + function containsForbiddenHostCodePointExcludingPercent(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|\/|:|\?|@|\[|\\|\]/) !== -1; + } + function isSpecialScheme(scheme) { + return specialSchemes[scheme] !== void 0; + } + function isSpecial(url) { + return isSpecialScheme(url.scheme); + } + function defaultPort(scheme) { + return specialSchemes[scheme]; + } + function percentEncode(c) { + let hex = c.toString(16).toUpperCase(); + if (hex.length === 1) { + hex = "0" + hex; + } + return "%" + hex; + } + function utf8PercentEncode(c) { + const buf = new Buffer(c); + let str = ""; + for (let i = 0; i < buf.length; ++i) { + str += percentEncode(buf[i]); + } + return str; + } + function utf8PercentDecode(str) { + const input = new Buffer(str); + const output = []; + for (let i = 0; i < input.length; ++i) { + if (input[i] !== 37) { + output.push(input[i]); + } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) { + output.push(parseInt(input.slice(i + 1, i + 3).toString(), 16)); + i += 2; + } else { + output.push(input[i]); + } + } + return new Buffer(output).toString(); + } + function isC0ControlPercentEncode(c) { + return c <= 31 || c > 126; + } + var extraPathPercentEncodeSet = new Set([32, 34, 35, 60, 62, 63, 96, 123, 125]); + function isPathPercentEncode(c) { + return isC0ControlPercentEncode(c) || extraPathPercentEncodeSet.has(c); + } + var extraUserinfoPercentEncodeSet = new Set([47, 58, 59, 61, 64, 91, 92, 93, 94, 124]); + function isUserinfoPercentEncode(c) { + return isPathPercentEncode(c) || extraUserinfoPercentEncodeSet.has(c); + } + function percentEncodeChar(c, encodeSetPredicate) { + const cStr = String.fromCodePoint(c); + if (encodeSetPredicate(c)) { + return utf8PercentEncode(cStr); + } + return cStr; + } + function parseIPv4Number(input) { + let R = 10; + if (input.length >= 2 && input.charAt(0) === "0" && input.charAt(1).toLowerCase() === "x") { + input = input.substring(2); + R = 16; + } else if (input.length >= 2 && input.charAt(0) === "0") { + input = input.substring(1); + R = 8; + } + if (input === "") { + return 0; + } + const regex = R === 10 ? /[^0-9]/ : R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/; + if (regex.test(input)) { + return failure; + } + return parseInt(input, R); + } + function parseIPv4(input) { + const parts = input.split("."); + if (parts[parts.length - 1] === "") { + if (parts.length > 1) { + parts.pop(); + } + } + if (parts.length > 4) { + return input; + } + const numbers = []; + for (const part of parts) { + if (part === "") { + return input; + } + const n = parseIPv4Number(part); + if (n === failure) { + return input; + } + numbers.push(n); + } + for (let i = 0; i < numbers.length - 1; ++i) { + if (numbers[i] > 255) { + return failure; + } + } + if (numbers[numbers.length - 1] >= Math.pow(256, 5 - numbers.length)) { + return failure; + } + let ipv4 = numbers.pop(); + let counter = 0; + for (const n of numbers) { + ipv4 += n * Math.pow(256, 3 - counter); + ++counter; + } + return ipv4; + } + function serializeIPv4(address) { + let output = ""; + let n = address; + for (let i = 1; i <= 4; ++i) { + output = String(n % 256) + output; + if (i !== 4) { + output = "." + output; + } + n = Math.floor(n / 256); + } + return output; + } + function parseIPv6(input) { + const address = [0, 0, 0, 0, 0, 0, 0, 0]; + let pieceIndex = 0; + let compress = null; + let pointer = 0; + input = punycode.ucs2.decode(input); + if (input[pointer] === 58) { + if (input[pointer + 1] !== 58) { + return failure; + } + pointer += 2; + ++pieceIndex; + compress = pieceIndex; + } + while (pointer < input.length) { + if (pieceIndex === 8) { + return failure; + } + if (input[pointer] === 58) { + if (compress !== null) { + return failure; + } + ++pointer; + ++pieceIndex; + compress = pieceIndex; + continue; + } + let value = 0; + let length = 0; + while (length < 4 && isASCIIHex(input[pointer])) { + value = value * 16 + parseInt(at(input, pointer), 16); + ++pointer; + ++length; + } + if (input[pointer] === 46) { + if (length === 0) { + return failure; + } + pointer -= length; + if (pieceIndex > 6) { + return failure; + } + let numbersSeen = 0; + while (input[pointer] !== void 0) { + let ipv4Piece = null; + if (numbersSeen > 0) { + if (input[pointer] === 46 && numbersSeen < 4) { + ++pointer; + } else { + return failure; + } + } + if (!isASCIIDigit(input[pointer])) { + return failure; + } + while (isASCIIDigit(input[pointer])) { + const number = parseInt(at(input, pointer)); + if (ipv4Piece === null) { + ipv4Piece = number; + } else if (ipv4Piece === 0) { + return failure; + } else { + ipv4Piece = ipv4Piece * 10 + number; + } + if (ipv4Piece > 255) { + return failure; + } + ++pointer; + } + address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; + ++numbersSeen; + if (numbersSeen === 2 || numbersSeen === 4) { + ++pieceIndex; + } + } + if (numbersSeen !== 4) { + return failure; + } + break; + } else if (input[pointer] === 58) { + ++pointer; + if (input[pointer] === void 0) { + return failure; + } + } else if (input[pointer] !== void 0) { + return failure; + } + address[pieceIndex] = value; + ++pieceIndex; + } + if (compress !== null) { + let swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex !== 0 && swaps > 0) { + const temp = address[compress + swaps - 1]; + address[compress + swaps - 1] = address[pieceIndex]; + address[pieceIndex] = temp; + --pieceIndex; + --swaps; + } + } else if (compress === null && pieceIndex !== 8) { + return failure; + } + return address; + } + function serializeIPv6(address) { + let output = ""; + const seqResult = findLongestZeroSequence(address); + const compress = seqResult.idx; + let ignore0 = false; + for (let pieceIndex = 0; pieceIndex <= 7; ++pieceIndex) { + if (ignore0 && address[pieceIndex] === 0) { + continue; + } else if (ignore0) { + ignore0 = false; + } + if (compress === pieceIndex) { + const separator = pieceIndex === 0 ? "::" : ":"; + output += separator; + ignore0 = true; + continue; + } + output += address[pieceIndex].toString(16); + if (pieceIndex !== 7) { + output += ":"; + } + } + return output; + } + function parseHost(input, isSpecialArg) { + if (input[0] === "[") { + if (input[input.length - 1] !== "]") { + return failure; + } + return parseIPv6(input.substring(1, input.length - 1)); + } + if (!isSpecialArg) { + return parseOpaqueHost(input); + } + const domain = utf8PercentDecode(input); + const asciiDomain = tr46.toASCII(domain, false, tr46.PROCESSING_OPTIONS.NONTRANSITIONAL, false); + if (asciiDomain === null) { + return failure; + } + if (containsForbiddenHostCodePoint(asciiDomain)) { + return failure; + } + const ipv4Host = parseIPv4(asciiDomain); + if (typeof ipv4Host === "number" || ipv4Host === failure) { + return ipv4Host; + } + return asciiDomain; + } + function parseOpaqueHost(input) { + if (containsForbiddenHostCodePointExcludingPercent(input)) { + return failure; + } + let output = ""; + const decoded = punycode.ucs2.decode(input); + for (let i = 0; i < decoded.length; ++i) { + output += percentEncodeChar(decoded[i], isC0ControlPercentEncode); + } + return output; + } + function findLongestZeroSequence(arr) { + let maxIdx = null; + let maxLen = 1; + let currStart = null; + let currLen = 0; + for (let i = 0; i < arr.length; ++i) { + if (arr[i] !== 0) { + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + currStart = null; + currLen = 0; + } else { + if (currStart === null) { + currStart = i; + } + ++currLen; + } + } + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + return { + idx: maxIdx, + len: maxLen + }; + } + function serializeHost(host) { + if (typeof host === "number") { + return serializeIPv4(host); + } + if (host instanceof Array) { + return "[" + serializeIPv6(host) + "]"; + } + return host; + } + function trimControlChars(url) { + return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, ""); + } + function trimTabAndNewline(url) { + return url.replace(/\u0009|\u000A|\u000D/g, ""); + } + function shortenPath(url) { + const path = url.path; + if (path.length === 0) { + return; + } + if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) { + return; + } + path.pop(); + } + function includesCredentials(url) { + return url.username !== "" || url.password !== ""; + } + function cannotHaveAUsernamePasswordPort(url) { + return url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file"; + } + function isNormalizedWindowsDriveLetter(string) { + return /^[A-Za-z]:$/.test(string); + } + function URLStateMachine(input, base, encodingOverride, url, stateOverride) { + this.pointer = 0; + this.input = input; + this.base = base || null; + this.encodingOverride = encodingOverride || "utf-8"; + this.stateOverride = stateOverride; + this.url = url; + this.failure = false; + this.parseError = false; + if (!this.url) { + this.url = { + scheme: "", + username: "", + password: "", + host: null, + port: null, + path: [], + query: null, + fragment: null, + cannotBeABaseURL: false + }; + const res2 = trimControlChars(this.input); + if (res2 !== this.input) { + this.parseError = true; + } + this.input = res2; + } + const res = trimTabAndNewline(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + this.state = stateOverride || "scheme start"; + this.buffer = ""; + this.atFlag = false; + this.arrFlag = false; + this.passwordTokenSeenFlag = false; + this.input = punycode.ucs2.decode(this.input); + for (; this.pointer <= this.input.length; ++this.pointer) { + const c = this.input[this.pointer]; + const cStr = isNaN(c) ? void 0 : String.fromCodePoint(c); + const ret = this["parse " + this.state](c, cStr); + if (!ret) { + break; + } else if (ret === failure) { + this.failure = true; + break; + } + } + } + URLStateMachine.prototype["parse scheme start"] = function parseSchemeStart(c, cStr) { + if (isASCIIAlpha(c)) { + this.buffer += cStr.toLowerCase(); + this.state = "scheme"; + } else if (!this.stateOverride) { + this.state = "no scheme"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + return true; + }; + URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) { + if (isASCIIAlphanumeric(c) || c === 43 || c === 45 || c === 46) { + this.buffer += cStr.toLowerCase(); + } else if (c === 58) { + if (this.stateOverride) { + if (isSpecial(this.url) && !isSpecialScheme(this.buffer)) { + return false; + } + if (!isSpecial(this.url) && isSpecialScheme(this.buffer)) { + return false; + } + if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file") { + return false; + } + if (this.url.scheme === "file" && (this.url.host === "" || this.url.host === null)) { + return false; + } + } + this.url.scheme = this.buffer; + this.buffer = ""; + if (this.stateOverride) { + return false; + } + if (this.url.scheme === "file") { + if (this.input[this.pointer + 1] !== 47 || this.input[this.pointer + 2] !== 47) { + this.parseError = true; + } + this.state = "file"; + } else if (isSpecial(this.url) && this.base !== null && this.base.scheme === this.url.scheme) { + this.state = "special relative or authority"; + } else if (isSpecial(this.url)) { + this.state = "special authority slashes"; + } else if (this.input[this.pointer + 1] === 47) { + this.state = "path or authority"; + ++this.pointer; + } else { + this.url.cannotBeABaseURL = true; + this.url.path.push(""); + this.state = "cannot-be-a-base-URL path"; + } + } else if (!this.stateOverride) { + this.buffer = ""; + this.state = "no scheme"; + this.pointer = -1; + } else { + this.parseError = true; + return failure; + } + return true; + }; + URLStateMachine.prototype["parse no scheme"] = function parseNoScheme(c) { + if (this.base === null || this.base.cannotBeABaseURL && c !== 35) { + return failure; + } else if (this.base.cannotBeABaseURL && c === 35) { + this.url.scheme = this.base.scheme; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.url.cannotBeABaseURL = true; + this.state = "fragment"; + } else if (this.base.scheme === "file") { + this.state = "file"; + --this.pointer; + } else { + this.state = "relative"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special relative or authority"] = function parseSpecialRelativeOrAuthority(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "relative"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse path or authority"] = function parsePathOrAuthority(c) { + if (c === 47) { + this.state = "authority"; + } else { + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse relative"] = function parseRelative(c) { + this.url.scheme = this.base.scheme; + if (isNaN(c)) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 47) { + this.state = "relative slash"; + } else if (c === 63) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else if (isSpecial(this.url) && c === 92) { + this.parseError = true; + this.state = "relative slash"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(0, this.base.path.length - 1); + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse relative slash"] = function parseRelativeSlash(c) { + if (isSpecial(this.url) && (c === 47 || c === 92)) { + if (c === 92) { + this.parseError = true; + } + this.state = "special authority ignore slashes"; + } else if (c === 47) { + this.state = "authority"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special authority slashes"] = function parseSpecialAuthoritySlashes(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "special authority ignore slashes"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special authority ignore slashes"] = function parseSpecialAuthorityIgnoreSlashes(c) { + if (c !== 47 && c !== 92) { + this.state = "authority"; + --this.pointer; + } else { + this.parseError = true; + } + return true; + }; + URLStateMachine.prototype["parse authority"] = function parseAuthority(c, cStr) { + if (c === 64) { + this.parseError = true; + if (this.atFlag) { + this.buffer = "%40" + this.buffer; + } + this.atFlag = true; + const len = countSymbols(this.buffer); + for (let pointer = 0; pointer < len; ++pointer) { + const codePoint = this.buffer.codePointAt(pointer); + if (codePoint === 58 && !this.passwordTokenSeenFlag) { + this.passwordTokenSeenFlag = true; + continue; + } + const encodedCodePoints = percentEncodeChar(codePoint, isUserinfoPercentEncode); + if (this.passwordTokenSeenFlag) { + this.url.password += encodedCodePoints; + } else { + this.url.username += encodedCodePoints; + } + } + this.buffer = ""; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92) { + if (this.atFlag && this.buffer === "") { + this.parseError = true; + return failure; + } + this.pointer -= countSymbols(this.buffer) + 1; + this.buffer = ""; + this.state = "host"; + } else { + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse hostname"] = URLStateMachine.prototype["parse host"] = function parseHostName(c, cStr) { + if (this.stateOverride && this.url.scheme === "file") { + --this.pointer; + this.state = "file host"; + } else if (c === 58 && !this.arrFlag) { + if (this.buffer === "") { + this.parseError = true; + return failure; + } + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + this.url.host = host; + this.buffer = ""; + this.state = "port"; + if (this.stateOverride === "hostname") { + return false; + } + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92) { + --this.pointer; + if (isSpecial(this.url) && this.buffer === "") { + this.parseError = true; + return failure; + } else if (this.stateOverride && this.buffer === "" && (includesCredentials(this.url) || this.url.port !== null)) { + this.parseError = true; + return false; + } + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + this.url.host = host; + this.buffer = ""; + this.state = "path start"; + if (this.stateOverride) { + return false; + } + } else { + if (c === 91) { + this.arrFlag = true; + } else if (c === 93) { + this.arrFlag = false; + } + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) { + if (isASCIIDigit(c)) { + this.buffer += cStr; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92 || this.stateOverride) { + if (this.buffer !== "") { + const port = parseInt(this.buffer); + if (port > Math.pow(2, 16) - 1) { + this.parseError = true; + return failure; + } + this.url.port = port === defaultPort(this.url.scheme) ? null : port; + this.buffer = ""; + } + if (this.stateOverride) { + return false; + } + this.state = "path start"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + return true; + }; + var fileOtherwiseCodePoints = new Set([47, 92, 63, 35]); + URLStateMachine.prototype["parse file"] = function parseFile(c) { + this.url.scheme = "file"; + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file slash"; + } else if (this.base !== null && this.base.scheme === "file") { + if (isNaN(c)) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 63) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else { + if (this.input.length - this.pointer - 1 === 0 || !isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) || this.input.length - this.pointer - 1 >= 2 && !fileOtherwiseCodePoints.has(this.input[this.pointer + 2])) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + shortenPath(this.url); + } else { + this.parseError = true; + } + this.state = "path"; + --this.pointer; + } + } else { + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) { + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file host"; + } else { + if (this.base !== null && this.base.scheme === "file") { + if (isNormalizedWindowsDriveLetterString(this.base.path[0])) { + this.url.path.push(this.base.path[0]); + } else { + this.url.host = this.base.host; + } + } + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse file host"] = function parseFileHost(c, cStr) { + if (isNaN(c) || c === 47 || c === 92 || c === 63 || c === 35) { + --this.pointer; + if (!this.stateOverride && isWindowsDriveLetterString(this.buffer)) { + this.parseError = true; + this.state = "path"; + } else if (this.buffer === "") { + this.url.host = ""; + if (this.stateOverride) { + return false; + } + this.state = "path start"; + } else { + let host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + if (host === "localhost") { + host = ""; + } + this.url.host = host; + if (this.stateOverride) { + return false; + } + this.buffer = ""; + this.state = "path start"; + } + } else { + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse path start"] = function parsePathStart(c) { + if (isSpecial(this.url)) { + if (c === 92) { + this.parseError = true; + } + this.state = "path"; + if (c !== 47 && c !== 92) { + --this.pointer; + } + } else if (!this.stateOverride && c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (!this.stateOverride && c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (c !== void 0) { + this.state = "path"; + if (c !== 47) { + --this.pointer; + } + } + return true; + }; + URLStateMachine.prototype["parse path"] = function parsePath(c) { + if (isNaN(c) || c === 47 || isSpecial(this.url) && c === 92 || !this.stateOverride && (c === 63 || c === 35)) { + if (isSpecial(this.url) && c === 92) { + this.parseError = true; + } + if (isDoubleDot(this.buffer)) { + shortenPath(this.url); + if (c !== 47 && !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } + } else if (isSingleDot(this.buffer) && c !== 47 && !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } else if (!isSingleDot(this.buffer)) { + if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) { + if (this.url.host !== "" && this.url.host !== null) { + this.parseError = true; + this.url.host = ""; + } + this.buffer = this.buffer[0] + ":"; + } + this.url.path.push(this.buffer); + } + this.buffer = ""; + if (this.url.scheme === "file" && (c === void 0 || c === 63 || c === 35)) { + while (this.url.path.length > 1 && this.url.path[0] === "") { + this.parseError = true; + this.url.path.shift(); + } + } + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.buffer += percentEncodeChar(c, isPathPercentEncode); + } + return true; + }; + URLStateMachine.prototype["parse cannot-be-a-base-URL path"] = function parseCannotBeABaseURLPath(c) { + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else { + if (!isNaN(c) && c !== 37) { + this.parseError = true; + } + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + if (!isNaN(c)) { + this.url.path[0] = this.url.path[0] + percentEncodeChar(c, isC0ControlPercentEncode); + } + } + return true; + }; + URLStateMachine.prototype["parse query"] = function parseQuery(c, cStr) { + if (isNaN(c) || !this.stateOverride && c === 35) { + if (!isSpecial(this.url) || this.url.scheme === "ws" || this.url.scheme === "wss") { + this.encodingOverride = "utf-8"; + } + const buffer = new Buffer(this.buffer); + for (let i = 0; i < buffer.length; ++i) { + if (buffer[i] < 33 || buffer[i] > 126 || buffer[i] === 34 || buffer[i] === 35 || buffer[i] === 60 || buffer[i] === 62) { + this.url.query += percentEncode(buffer[i]); + } else { + this.url.query += String.fromCodePoint(buffer[i]); + } + } + this.buffer = ""; + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse fragment"] = function parseFragment(c) { + if (isNaN(c)) { + } else if (c === 0) { + this.parseError = true; + } else { + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.url.fragment += percentEncodeChar(c, isC0ControlPercentEncode); + } + return true; + }; + function serializeURL(url, excludeFragment) { + let output = url.scheme + ":"; + if (url.host !== null) { + output += "//"; + if (url.username !== "" || url.password !== "") { + output += url.username; + if (url.password !== "") { + output += ":" + url.password; + } + output += "@"; + } + output += serializeHost(url.host); + if (url.port !== null) { + output += ":" + url.port; + } + } else if (url.host === null && url.scheme === "file") { + output += "//"; + } + if (url.cannotBeABaseURL) { + output += url.path[0]; + } else { + for (const string of url.path) { + output += "/" + string; + } + } + if (url.query !== null) { + output += "?" + url.query; + } + if (!excludeFragment && url.fragment !== null) { + output += "#" + url.fragment; + } + return output; + } + function serializeOrigin(tuple) { + let result = tuple.scheme + "://"; + result += serializeHost(tuple.host); + if (tuple.port !== null) { + result += ":" + tuple.port; + } + return result; + } + module2.exports.serializeURL = serializeURL; + module2.exports.serializeURLOrigin = function(url) { + switch (url.scheme) { + case "blob": + try { + return module2.exports.serializeURLOrigin(module2.exports.parseURL(url.path[0])); + } catch (e) { + return "null"; + } + case "ftp": + case "gopher": + case "http": + case "https": + case "ws": + case "wss": + return serializeOrigin({ + scheme: url.scheme, + host: url.host, + port: url.port + }); + case "file": + return "file://"; + default: + return "null"; + } + }; + module2.exports.basicURLParse = function(input, options) { + if (options === void 0) { + options = {}; + } + const usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride); + if (usm.failure) { + return "failure"; + } + return usm.url; + }; + module2.exports.setTheUsername = function(url, username) { + url.username = ""; + const decoded = punycode.ucs2.decode(username); + for (let i = 0; i < decoded.length; ++i) { + url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } + }; + module2.exports.setThePassword = function(url, password) { + url.password = ""; + const decoded = punycode.ucs2.decode(password); + for (let i = 0; i < decoded.length; ++i) { + url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } + }; + module2.exports.serializeHost = serializeHost; + module2.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort; + module2.exports.serializeInteger = function(integer) { + return String(integer); + }; + module2.exports.parseURL = function(input, options) { + if (options === void 0) { + options = {}; + } + return module2.exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride }); + }; + } +}); + +// node_modules/whatwg-url/lib/URL-impl.js +var require_URL_impl = __commonJS({ + "node_modules/whatwg-url/lib/URL-impl.js"(exports2) { + "use strict"; + var usm = require_url_state_machine(); + exports2.implementation = class URLImpl { + constructor(constructorArgs) { + const url = constructorArgs[0]; + const base = constructorArgs[1]; + let parsedBase = null; + if (base !== void 0) { + parsedBase = usm.basicURLParse(base); + if (parsedBase === "failure") { + throw new TypeError("Invalid base URL"); + } + } + const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase }); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + this._url = parsedURL; + } + get href() { + return usm.serializeURL(this._url); + } + set href(v) { + const parsedURL = usm.basicURLParse(v); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + this._url = parsedURL; + } + get origin() { + return usm.serializeURLOrigin(this._url); + } + get protocol() { + return this._url.scheme + ":"; + } + set protocol(v) { + usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" }); + } + get username() { + return this._url.username; + } + set username(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + usm.setTheUsername(this._url, v); + } + get password() { + return this._url.password; + } + set password(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + usm.setThePassword(this._url, v); + } + get host() { + const url = this._url; + if (url.host === null) { + return ""; + } + if (url.port === null) { + return usm.serializeHost(url.host); + } + return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port); + } + set host(v) { + if (this._url.cannotBeABaseURL) { + return; + } + usm.basicURLParse(v, { url: this._url, stateOverride: "host" }); + } + get hostname() { + if (this._url.host === null) { + return ""; + } + return usm.serializeHost(this._url.host); + } + set hostname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" }); + } + get port() { + if (this._url.port === null) { + return ""; + } + return usm.serializeInteger(this._url.port); + } + set port(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + if (v === "") { + this._url.port = null; + } else { + usm.basicURLParse(v, { url: this._url, stateOverride: "port" }); + } + } + get pathname() { + if (this._url.cannotBeABaseURL) { + return this._url.path[0]; + } + if (this._url.path.length === 0) { + return ""; + } + return "/" + this._url.path.join("/"); + } + set pathname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + this._url.path = []; + usm.basicURLParse(v, { url: this._url, stateOverride: "path start" }); + } + get search() { + if (this._url.query === null || this._url.query === "") { + return ""; + } + return "?" + this._url.query; + } + set search(v) { + const url = this._url; + if (v === "") { + url.query = null; + return; + } + const input = v[0] === "?" ? v.substring(1) : v; + url.query = ""; + usm.basicURLParse(input, { url, stateOverride: "query" }); + } + get hash() { + if (this._url.fragment === null || this._url.fragment === "") { + return ""; + } + return "#" + this._url.fragment; + } + set hash(v) { + if (v === "") { + this._url.fragment = null; + return; + } + const input = v[0] === "#" ? v.substring(1) : v; + this._url.fragment = ""; + usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" }); + } + toJSON() { + return this.href; + } + }; + } +}); + +// node_modules/whatwg-url/lib/URL.js +var require_URL = __commonJS({ + "node_modules/whatwg-url/lib/URL.js"(exports2, module2) { + "use strict"; + var conversions = require_lib(); + var utils = require_utils(); + var Impl = require_URL_impl(); + var impl = utils.implSymbol; + function URL(url) { + if (!this || this[impl] || !(this instanceof URL)) { + throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function."); + } + if (arguments.length < 1) { + throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present."); + } + const args = []; + for (let i = 0; i < arguments.length && i < 2; ++i) { + args[i] = arguments[i]; + } + args[0] = conversions["USVString"](args[0]); + if (args[1] !== void 0) { + args[1] = conversions["USVString"](args[1]); + } + module2.exports.setup(this, args); + } + URL.prototype.toJSON = function toJSON() { + if (!this || !module2.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + const args = []; + for (let i = 0; i < arguments.length && i < 0; ++i) { + args[i] = arguments[i]; + } + return this[impl].toJSON.apply(this[impl], args); + }; + Object.defineProperty(URL.prototype, "href", { + get() { + return this[impl].href; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].href = V; + }, + enumerable: true, + configurable: true + }); + URL.prototype.toString = function() { + if (!this || !module2.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + return this.href; + }; + Object.defineProperty(URL.prototype, "origin", { + get() { + return this[impl].origin; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "protocol", { + get() { + return this[impl].protocol; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].protocol = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "username", { + get() { + return this[impl].username; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].username = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "password", { + get() { + return this[impl].password; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].password = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "host", { + get() { + return this[impl].host; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].host = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "hostname", { + get() { + return this[impl].hostname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hostname = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "port", { + get() { + return this[impl].port; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].port = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "pathname", { + get() { + return this[impl].pathname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].pathname = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "search", { + get() { + return this[impl].search; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].search = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL.prototype, "hash", { + get() { + return this[impl].hash; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hash = V; + }, + enumerable: true, + configurable: true + }); + module2.exports = { + is(obj) { + return !!obj && obj[impl] instanceof Impl.implementation; + }, + create(constructorArgs, privateData) { + let obj = Object.create(URL.prototype); + this.setup(obj, constructorArgs, privateData); + return obj; + }, + setup(obj, constructorArgs, privateData) { + if (!privateData) + privateData = {}; + privateData.wrapper = obj; + obj[impl] = new Impl.implementation(constructorArgs, privateData); + obj[impl][utils.wrapperSymbol] = obj; + }, + interface: URL, + expose: { + Window: { URL }, + Worker: { URL } + } + }; + } +}); + +// node_modules/whatwg-url/lib/public-api.js +var require_public_api = __commonJS({ + "node_modules/whatwg-url/lib/public-api.js"(exports2) { + "use strict"; + exports2.URL = require_URL().interface; + exports2.serializeURL = require_url_state_machine().serializeURL; + exports2.serializeURLOrigin = require_url_state_machine().serializeURLOrigin; + exports2.basicURLParse = require_url_state_machine().basicURLParse; + exports2.setTheUsername = require_url_state_machine().setTheUsername; + exports2.setThePassword = require_url_state_machine().setThePassword; + exports2.serializeHost = require_url_state_machine().serializeHost; + exports2.serializeInteger = require_url_state_machine().serializeInteger; + exports2.parseURL = require_url_state_machine().parseURL; + } +}); + +// node_modules/node-fetch/lib/index.js +var require_lib2 = __commonJS({ + "node_modules/node-fetch/lib/index.js"(exports2, module2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + function _interopDefault(ex) { + return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex; + } + var Stream = _interopDefault(require("stream")); + var http = _interopDefault(require("http")); + var Url = _interopDefault(require("url")); + var whatwgUrl = _interopDefault(require_public_api()); + var https = _interopDefault(require("https")); + var zlib = _interopDefault(require("zlib")); + var Readable = Stream.Readable; + var BUFFER = Symbol("buffer"); + var TYPE = Symbol("type"); + var Blob = class { + constructor() { + this[TYPE] = ""; + const blobParts = arguments[0]; + const options = arguments[1]; + const buffers = []; + let size = 0; + if (blobParts) { + const a = blobParts; + const length = Number(a.length); + for (let i = 0; i < length; i++) { + const element = a[i]; + let buffer; + if (element instanceof Buffer) { + buffer = element; + } else if (ArrayBuffer.isView(element)) { + buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength); + } else if (element instanceof ArrayBuffer) { + buffer = Buffer.from(element); + } else if (element instanceof Blob) { + buffer = element[BUFFER]; + } else { + buffer = Buffer.from(typeof element === "string" ? element : String(element)); + } + size += buffer.length; + buffers.push(buffer); + } + } + this[BUFFER] = Buffer.concat(buffers); + let type = options && options.type !== void 0 && String(options.type).toLowerCase(); + if (type && !/[^\u0020-\u007E]/.test(type)) { + this[TYPE] = type; + } + } + get size() { + return this[BUFFER].length; + } + get type() { + return this[TYPE]; + } + text() { + return Promise.resolve(this[BUFFER].toString()); + } + arrayBuffer() { + const buf = this[BUFFER]; + const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + return Promise.resolve(ab); + } + stream() { + const readable = new Readable(); + readable._read = function() { + }; + readable.push(this[BUFFER]); + readable.push(null); + return readable; + } + toString() { + return "[object Blob]"; + } + slice() { + const size = this.size; + const start = arguments[0]; + const end = arguments[1]; + let relativeStart, relativeEnd; + if (start === void 0) { + relativeStart = 0; + } else if (start < 0) { + relativeStart = Math.max(size + start, 0); + } else { + relativeStart = Math.min(start, size); + } + if (end === void 0) { + relativeEnd = size; + } else if (end < 0) { + relativeEnd = Math.max(size + end, 0); + } else { + relativeEnd = Math.min(end, size); + } + const span = Math.max(relativeEnd - relativeStart, 0); + const buffer = this[BUFFER]; + const slicedBuffer = buffer.slice(relativeStart, relativeStart + span); + const blob = new Blob([], { type: arguments[2] }); + blob[BUFFER] = slicedBuffer; + return blob; + } + }; + Object.defineProperties(Blob.prototype, { + size: { enumerable: true }, + type: { enumerable: true }, + slice: { enumerable: true } + }); + Object.defineProperty(Blob.prototype, Symbol.toStringTag, { + value: "Blob", + writable: false, + enumerable: false, + configurable: true + }); + function FetchError(message, type, systemError) { + Error.call(this, message); + this.message = message; + this.type = type; + if (systemError) { + this.code = this.errno = systemError.code; + } + Error.captureStackTrace(this, this.constructor); + } + FetchError.prototype = Object.create(Error.prototype); + FetchError.prototype.constructor = FetchError; + FetchError.prototype.name = "FetchError"; + var convert; + try { + convert = require("encoding").convert; + } catch (e) { + } + var INTERNALS = Symbol("Body internals"); + var PassThrough = Stream.PassThrough; + function Body(body) { + var _this = this; + var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref$size = _ref.size; + let size = _ref$size === void 0 ? 0 : _ref$size; + var _ref$timeout = _ref.timeout; + let timeout = _ref$timeout === void 0 ? 0 : _ref$timeout; + if (body == null) { + body = null; + } else if (isURLSearchParams(body)) { + body = Buffer.from(body.toString()); + } else if (isBlob(body)) + ; + else if (Buffer.isBuffer(body)) + ; + else if (Object.prototype.toString.call(body) === "[object ArrayBuffer]") { + body = Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof Stream) + ; + else { + body = Buffer.from(String(body)); + } + this[INTERNALS] = { + body, + disturbed: false, + error: null + }; + this.size = size; + this.timeout = timeout; + if (body instanceof Stream) { + body.on("error", function(err) { + const error = err.name === "AbortError" ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, "system", err); + _this[INTERNALS].error = error; + }); + } + } + Body.prototype = { + get body() { + return this[INTERNALS].body; + }, + get bodyUsed() { + return this[INTERNALS].disturbed; + }, + arrayBuffer() { + return consumeBody.call(this).then(function(buf) { + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + }); + }, + blob() { + let ct = this.headers && this.headers.get("content-type") || ""; + return consumeBody.call(this).then(function(buf) { + return Object.assign(new Blob([], { + type: ct.toLowerCase() + }), { + [BUFFER]: buf + }); + }); + }, + json() { + var _this2 = this; + return consumeBody.call(this).then(function(buffer) { + try { + return JSON.parse(buffer.toString()); + } catch (err) { + return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, "invalid-json")); + } + }); + }, + text() { + return consumeBody.call(this).then(function(buffer) { + return buffer.toString(); + }); + }, + buffer() { + return consumeBody.call(this); + }, + textConverted() { + var _this3 = this; + return consumeBody.call(this).then(function(buffer) { + return convertBody(buffer, _this3.headers); + }); + } + }; + Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true } + }); + Body.mixIn = function(proto) { + for (const name of Object.getOwnPropertyNames(Body.prototype)) { + if (!(name in proto)) { + const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); + Object.defineProperty(proto, name, desc); + } + } + }; + function consumeBody() { + var _this4 = this; + if (this[INTERNALS].disturbed) { + return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); + } + this[INTERNALS].disturbed = true; + if (this[INTERNALS].error) { + return Body.Promise.reject(this[INTERNALS].error); + } + let body = this.body; + if (body === null) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + if (isBlob(body)) { + body = body.stream(); + } + if (Buffer.isBuffer(body)) { + return Body.Promise.resolve(body); + } + if (!(body instanceof Stream)) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + let accum = []; + let accumBytes = 0; + let abort = false; + return new Body.Promise(function(resolve, reject) { + let resTimeout; + if (_this4.timeout) { + resTimeout = setTimeout(function() { + abort = true; + reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, "body-timeout")); + }, _this4.timeout); + } + body.on("error", function(err) { + if (err.name === "AbortError") { + abort = true; + reject(err); + } else { + reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, "system", err)); + } + }); + body.on("data", function(chunk) { + if (abort || chunk === null) { + return; + } + if (_this4.size && accumBytes + chunk.length > _this4.size) { + abort = true; + reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, "max-size")); + return; + } + accumBytes += chunk.length; + accum.push(chunk); + }); + body.on("end", function() { + if (abort) { + return; + } + clearTimeout(resTimeout); + try { + resolve(Buffer.concat(accum, accumBytes)); + } catch (err) { + reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err)); + } + }); + }); + } + function convertBody(buffer, headers) { + if (typeof convert !== "function") { + throw new Error("The package `encoding` must be installed to use the textConverted() function"); + } + const ct = headers.get("content-type"); + let charset = "utf-8"; + let res, str; + if (ct) { + res = /charset=([^;]*)/i.exec(ct); + } + str = buffer.slice(0, 1024).toString(); + if (!res && str) { + res = / 0 && arguments[0] !== void 0 ? arguments[0] : void 0; + this[MAP] = Object.create(null); + if (init instanceof Headers) { + const rawHeaders = init.raw(); + const headerNames = Object.keys(rawHeaders); + for (const headerName of headerNames) { + for (const value of rawHeaders[headerName]) { + this.append(headerName, value); + } + } + return; + } + if (init == null) + ; + else if (typeof init === "object") { + const method = init[Symbol.iterator]; + if (method != null) { + if (typeof method !== "function") { + throw new TypeError("Header pairs must be iterable"); + } + const pairs = []; + for (const pair of init) { + if (typeof pair !== "object" || typeof pair[Symbol.iterator] !== "function") { + throw new TypeError("Each header pair must be iterable"); + } + pairs.push(Array.from(pair)); + } + for (const pair of pairs) { + if (pair.length !== 2) { + throw new TypeError("Each header pair must be a name/value tuple"); + } + this.append(pair[0], pair[1]); + } + } else { + for (const key of Object.keys(init)) { + const value = init[key]; + this.append(key, value); + } + } + } else { + throw new TypeError("Provided initializer must be an object"); + } + } + get(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key === void 0) { + return null; + } + return this[MAP][key].join(", "); + } + forEach(callback) { + let thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0; + let pairs = getHeaders(this); + let i = 0; + while (i < pairs.length) { + var _pairs$i = pairs[i]; + const name = _pairs$i[0], value = _pairs$i[1]; + callback.call(thisArg, value, name, this); + pairs = getHeaders(this); + i++; + } + } + set(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + this[MAP][key !== void 0 ? key : name] = [value]; + } + append(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + if (key !== void 0) { + this[MAP][key].push(value); + } else { + this[MAP][name] = [value]; + } + } + has(name) { + name = `${name}`; + validateName(name); + return find(this[MAP], name) !== void 0; + } + delete(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key !== void 0) { + delete this[MAP][key]; + } + } + raw() { + return this[MAP]; + } + keys() { + return createHeadersIterator(this, "key"); + } + values() { + return createHeadersIterator(this, "value"); + } + [Symbol.iterator]() { + return createHeadersIterator(this, "key+value"); + } + }; + Headers.prototype.entries = Headers.prototype[Symbol.iterator]; + Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + value: "Headers", + writable: false, + enumerable: false, + configurable: true + }); + Object.defineProperties(Headers.prototype, { + get: { enumerable: true }, + forEach: { enumerable: true }, + set: { enumerable: true }, + append: { enumerable: true }, + has: { enumerable: true }, + delete: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true } + }); + function getHeaders(headers) { + let kind = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "key+value"; + const keys = Object.keys(headers[MAP]).sort(); + return keys.map(kind === "key" ? function(k) { + return k.toLowerCase(); + } : kind === "value" ? function(k) { + return headers[MAP][k].join(", "); + } : function(k) { + return [k.toLowerCase(), headers[MAP][k].join(", ")]; + }); + } + var INTERNAL = Symbol("internal"); + function createHeadersIterator(target, kind) { + const iterator = Object.create(HeadersIteratorPrototype); + iterator[INTERNAL] = { + target, + kind, + index: 0 + }; + return iterator; + } + var HeadersIteratorPrototype = Object.setPrototypeOf({ + next() { + if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { + throw new TypeError("Value of `this` is not a HeadersIterator"); + } + var _INTERNAL = this[INTERNAL]; + const target = _INTERNAL.target, kind = _INTERNAL.kind, index = _INTERNAL.index; + const values = getHeaders(target, kind); + const len = values.length; + if (index >= len) { + return { + value: void 0, + done: true + }; + } + this[INTERNAL].index = index + 1; + return { + value: values[index], + done: false + }; + } + }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); + Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { + value: "HeadersIterator", + writable: false, + enumerable: false, + configurable: true + }); + function exportNodeCompatibleHeaders(headers) { + const obj = Object.assign({ __proto__: null }, headers[MAP]); + const hostHeaderKey = find(headers[MAP], "Host"); + if (hostHeaderKey !== void 0) { + obj[hostHeaderKey] = obj[hostHeaderKey][0]; + } + return obj; + } + function createHeadersLenient(obj) { + const headers = new Headers(); + for (const name of Object.keys(obj)) { + if (invalidTokenRegex.test(name)) { + continue; + } + if (Array.isArray(obj[name])) { + for (const val of obj[name]) { + if (invalidHeaderCharRegex.test(val)) { + continue; + } + if (headers[MAP][name] === void 0) { + headers[MAP][name] = [val]; + } else { + headers[MAP][name].push(val); + } + } + } else if (!invalidHeaderCharRegex.test(obj[name])) { + headers[MAP][name] = [obj[name]]; + } + } + return headers; + } + var INTERNALS$1 = Symbol("Response internals"); + var STATUS_CODES = http.STATUS_CODES; + var Response = class { + constructor() { + let body = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + Body.call(this, body, opts); + const status = opts.status || 200; + const headers = new Headers(opts.headers); + if (body != null && !headers.has("Content-Type")) { + const contentType = extractContentType(body); + if (contentType) { + headers.append("Content-Type", contentType); + } + } + this[INTERNALS$1] = { + url: opts.url, + status, + statusText: opts.statusText || STATUS_CODES[status], + headers, + counter: opts.counter + }; + } + get url() { + return this[INTERNALS$1].url || ""; + } + get status() { + return this[INTERNALS$1].status; + } + get ok() { + return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; + } + get redirected() { + return this[INTERNALS$1].counter > 0; + } + get statusText() { + return this[INTERNALS$1].statusText; + } + get headers() { + return this[INTERNALS$1].headers; + } + clone() { + return new Response(clone(this), { + url: this.url, + status: this.status, + statusText: this.statusText, + headers: this.headers, + ok: this.ok, + redirected: this.redirected + }); + } + }; + Body.mixIn(Response.prototype); + Object.defineProperties(Response.prototype, { + url: { enumerable: true }, + status: { enumerable: true }, + ok: { enumerable: true }, + redirected: { enumerable: true }, + statusText: { enumerable: true }, + headers: { enumerable: true }, + clone: { enumerable: true } + }); + Object.defineProperty(Response.prototype, Symbol.toStringTag, { + value: "Response", + writable: false, + enumerable: false, + configurable: true + }); + var INTERNALS$2 = Symbol("Request internals"); + var URL = Url.URL || whatwgUrl.URL; + var parse_url = Url.parse; + var format_url = Url.format; + function parseURL(urlStr) { + if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(urlStr)) { + urlStr = new URL(urlStr).toString(); + } + return parse_url(urlStr); + } + var streamDestructionSupported = "destroy" in Stream.Readable.prototype; + function isRequest(input) { + return typeof input === "object" && typeof input[INTERNALS$2] === "object"; + } + function isAbortSignal(signal) { + const proto = signal && typeof signal === "object" && Object.getPrototypeOf(signal); + return !!(proto && proto.constructor.name === "AbortSignal"); + } + var Request = class { + constructor(input) { + let init = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + let parsedURL; + if (!isRequest(input)) { + if (input && input.href) { + parsedURL = parseURL(input.href); + } else { + parsedURL = parseURL(`${input}`); + } + input = {}; + } else { + parsedURL = parseURL(input.url); + } + let method = init.method || input.method || "GET"; + method = method.toUpperCase(); + if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body"); + } + let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; + Body.call(this, inputBody, { + timeout: init.timeout || input.timeout || 0, + size: init.size || input.size || 0 + }); + const headers = new Headers(init.headers || input.headers || {}); + if (inputBody != null && !headers.has("Content-Type")) { + const contentType = extractContentType(inputBody); + if (contentType) { + headers.append("Content-Type", contentType); + } + } + let signal = isRequest(input) ? input.signal : null; + if ("signal" in init) + signal = init.signal; + if (signal != null && !isAbortSignal(signal)) { + throw new TypeError("Expected signal to be an instanceof AbortSignal"); + } + this[INTERNALS$2] = { + method, + redirect: init.redirect || input.redirect || "follow", + headers, + parsedURL, + signal + }; + this.follow = init.follow !== void 0 ? init.follow : input.follow !== void 0 ? input.follow : 20; + this.compress = init.compress !== void 0 ? init.compress : input.compress !== void 0 ? input.compress : true; + this.counter = init.counter || input.counter || 0; + this.agent = init.agent || input.agent; + } + get method() { + return this[INTERNALS$2].method; + } + get url() { + return format_url(this[INTERNALS$2].parsedURL); + } + get headers() { + return this[INTERNALS$2].headers; + } + get redirect() { + return this[INTERNALS$2].redirect; + } + get signal() { + return this[INTERNALS$2].signal; + } + clone() { + return new Request(this); + } + }; + Body.mixIn(Request.prototype); + Object.defineProperty(Request.prototype, Symbol.toStringTag, { + value: "Request", + writable: false, + enumerable: false, + configurable: true + }); + Object.defineProperties(Request.prototype, { + method: { enumerable: true }, + url: { enumerable: true }, + headers: { enumerable: true }, + redirect: { enumerable: true }, + clone: { enumerable: true }, + signal: { enumerable: true } + }); + function getNodeRequestOptions(request) { + const parsedURL = request[INTERNALS$2].parsedURL; + const headers = new Headers(request[INTERNALS$2].headers); + if (!headers.has("Accept")) { + headers.set("Accept", "*/*"); + } + if (!parsedURL.protocol || !parsedURL.hostname) { + throw new TypeError("Only absolute URLs are supported"); + } + if (!/^https?:$/.test(parsedURL.protocol)) { + throw new TypeError("Only HTTP(S) protocols are supported"); + } + if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) { + throw new Error("Cancellation of streamed requests with AbortSignal is not supported in node < 8"); + } + let contentLengthValue = null; + if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { + contentLengthValue = "0"; + } + if (request.body != null) { + const totalBytes = getTotalBytes(request); + if (typeof totalBytes === "number") { + contentLengthValue = String(totalBytes); + } + } + if (contentLengthValue) { + headers.set("Content-Length", contentLengthValue); + } + if (!headers.has("User-Agent")) { + headers.set("User-Agent", "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)"); + } + if (request.compress && !headers.has("Accept-Encoding")) { + headers.set("Accept-Encoding", "gzip,deflate"); + } + let agent = request.agent; + if (typeof agent === "function") { + agent = agent(parsedURL); + } + if (!headers.has("Connection") && !agent) { + headers.set("Connection", "close"); + } + return Object.assign({}, parsedURL, { + method: request.method, + headers: exportNodeCompatibleHeaders(headers), + agent + }); + } + function AbortError(message) { + Error.call(this, message); + this.type = "aborted"; + this.message = message; + Error.captureStackTrace(this, this.constructor); + } + AbortError.prototype = Object.create(Error.prototype); + AbortError.prototype.constructor = AbortError; + AbortError.prototype.name = "AbortError"; + var URL$1 = Url.URL || whatwgUrl.URL; + var PassThrough$1 = Stream.PassThrough; + var isDomainOrSubdomain = function isDomainOrSubdomain2(destination, original) { + const orig = new URL$1(original).hostname; + const dest = new URL$1(destination).hostname; + return orig === dest || orig[orig.length - dest.length - 1] === "." && orig.endsWith(dest); + }; + function fetch(url, opts) { + if (!fetch.Promise) { + throw new Error("native promise missing, set fetch.Promise to your favorite alternative"); + } + Body.Promise = fetch.Promise; + return new fetch.Promise(function(resolve, reject) { + const request = new Request(url, opts); + const options = getNodeRequestOptions(request); + const send = (options.protocol === "https:" ? https : http).request; + const signal = request.signal; + let response = null; + const abort = function abort2() { + let error = new AbortError("The user aborted a request."); + reject(error); + if (request.body && request.body instanceof Stream.Readable) { + request.body.destroy(error); + } + if (!response || !response.body) + return; + response.body.emit("error", error); + }; + if (signal && signal.aborted) { + abort(); + return; + } + const abortAndFinalize = function abortAndFinalize2() { + abort(); + finalize(); + }; + const req = send(options); + let reqTimeout; + if (signal) { + signal.addEventListener("abort", abortAndFinalize); + } + function finalize() { + req.abort(); + if (signal) + signal.removeEventListener("abort", abortAndFinalize); + clearTimeout(reqTimeout); + } + if (request.timeout) { + req.once("socket", function(socket) { + reqTimeout = setTimeout(function() { + reject(new FetchError(`network timeout at: ${request.url}`, "request-timeout")); + finalize(); + }, request.timeout); + }); + } + req.on("error", function(err) { + reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err)); + finalize(); + }); + req.on("response", function(res) { + clearTimeout(reqTimeout); + const headers = createHeadersLenient(res.headers); + if (fetch.isRedirect(res.statusCode)) { + const location = headers.get("Location"); + let locationURL = null; + try { + locationURL = location === null ? null : new URL$1(location, request.url).toString(); + } catch (err) { + if (request.redirect !== "manual") { + reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect")); + finalize(); + return; + } + } + switch (request.redirect) { + case "error": + reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect")); + finalize(); + return; + case "manual": + if (locationURL !== null) { + try { + headers.set("Location", locationURL); + } catch (err) { + reject(err); + } + } + break; + case "follow": + if (locationURL === null) { + break; + } + if (request.counter >= request.follow) { + reject(new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect")); + finalize(); + return; + } + const requestOpts = { + headers: new Headers(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout, + size: request.size + }; + if (!isDomainOrSubdomain(request.url, locationURL)) { + for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) { + requestOpts.headers.delete(name); + } + } + if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { + reject(new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect")); + finalize(); + return; + } + if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === "POST") { + requestOpts.method = "GET"; + requestOpts.body = void 0; + requestOpts.headers.delete("content-length"); + } + resolve(fetch(new Request(locationURL, requestOpts))); + finalize(); + return; + } + } + res.once("end", function() { + if (signal) + signal.removeEventListener("abort", abortAndFinalize); + }); + let body = res.pipe(new PassThrough$1()); + const response_options = { + url: request.url, + status: res.statusCode, + statusText: res.statusMessage, + headers, + size: request.size, + timeout: request.timeout, + counter: request.counter + }; + const codings = headers.get("Content-Encoding"); + if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) { + response = new Response(body, response_options); + resolve(response); + return; + } + const zlibOptions = { + flush: zlib.Z_SYNC_FLUSH, + finishFlush: zlib.Z_SYNC_FLUSH + }; + if (codings == "gzip" || codings == "x-gzip") { + body = body.pipe(zlib.createGunzip(zlibOptions)); + response = new Response(body, response_options); + resolve(response); + return; + } + if (codings == "deflate" || codings == "x-deflate") { + const raw = res.pipe(new PassThrough$1()); + raw.once("data", function(chunk) { + if ((chunk[0] & 15) === 8) { + body = body.pipe(zlib.createInflate()); + } else { + body = body.pipe(zlib.createInflateRaw()); + } + response = new Response(body, response_options); + resolve(response); + }); + return; + } + if (codings == "br" && typeof zlib.createBrotliDecompress === "function") { + body = body.pipe(zlib.createBrotliDecompress()); + response = new Response(body, response_options); + resolve(response); + return; + } + response = new Response(body, response_options); + resolve(response); + }); + writeToStream(req, request); + }); + } + fetch.isRedirect = function(code) { + return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; + }; + fetch.Promise = global.Promise; + module2.exports = exports2 = fetch; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.default = exports2; + exports2.Headers = Headers; + exports2.Request = Request; + exports2.Response = Response; + exports2.FetchError = FetchError; + } +}); + +// node_modules/apollo-server-env/dist/polyfills/fetch.js +var require_fetch = __commonJS({ + "node_modules/apollo-server-env/dist/polyfills/fetch.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Headers = exports2.Response = exports2.Request = exports2.fetch = void 0; + var node_fetch_1 = require_lib2(); + Object.defineProperty(exports2, "fetch", { enumerable: true, get: function() { + return __importDefault(node_fetch_1).default; + } }); + Object.defineProperty(exports2, "Request", { enumerable: true, get: function() { + return node_fetch_1.Request; + } }); + Object.defineProperty(exports2, "Response", { enumerable: true, get: function() { + return node_fetch_1.Response; + } }); + Object.defineProperty(exports2, "Headers", { enumerable: true, get: function() { + return node_fetch_1.Headers; + } }); + } +}); + +// node_modules/apollo-server-env/dist/polyfills/url.js +var require_url = __commonJS({ + "node_modules/apollo-server-env/dist/polyfills/url.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.URLSearchParams = exports2.URL = void 0; + var url_1 = require("url"); + Object.defineProperty(exports2, "URL", { enumerable: true, get: function() { + return url_1.URL; + } }); + Object.defineProperty(exports2, "URLSearchParams", { enumerable: true, get: function() { + return url_1.URLSearchParams; + } }); + } +}); + +// node_modules/apollo-server-env/dist/index.js +var require_dist = __commonJS({ + "node_modules/apollo-server-env/dist/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) + __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + __exportStar(require_fetch(), exports2); + __exportStar(require_url(), exports2); + } +}); + +// node_modules/apollo-server-core/dist/graphqlOptions.js +var require_graphqlOptions = __commonJS({ + "node_modules/apollo-server-core/dist/graphqlOptions.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.resolveGraphqlOptions = void 0; + async function resolveGraphqlOptions(options, ...args) { + if (typeof options === "function") { + return await options(...args); + } else { + return options; + } + } + exports2.resolveGraphqlOptions = resolveGraphqlOptions; + } +}); + +// node_modules/graphql/version.js +var require_version = __commonJS({ + "node_modules/graphql/version.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.versionInfo = exports2.version = void 0; + var version = "15.8.0"; + exports2.version = version; + var versionInfo = Object.freeze({ + major: 15, + minor: 8, + patch: 0, + preReleaseTag: null + }); + exports2.versionInfo = versionInfo; + } +}); + +// node_modules/graphql/jsutils/isPromise.js +var require_isPromise = __commonJS({ + "node_modules/graphql/jsutils/isPromise.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = isPromise; + function isPromise(value) { + return typeof (value === null || value === void 0 ? void 0 : value.then) === "function"; + } + } +}); + +// node_modules/graphql/jsutils/isObjectLike.js +var require_isObjectLike = __commonJS({ + "node_modules/graphql/jsutils/isObjectLike.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = isObjectLike; + function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function _typeof2(obj2) { + return typeof obj2; + }; + } else { + _typeof = function _typeof2(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + function isObjectLike(value) { + return _typeof(value) == "object" && value !== null; + } + } +}); + +// node_modules/graphql/polyfills/symbols.js +var require_symbols = __commonJS({ + "node_modules/graphql/polyfills/symbols.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.SYMBOL_TO_STRING_TAG = exports2.SYMBOL_ASYNC_ITERATOR = exports2.SYMBOL_ITERATOR = void 0; + var SYMBOL_ITERATOR = typeof Symbol === "function" && Symbol.iterator != null ? Symbol.iterator : "@@iterator"; + exports2.SYMBOL_ITERATOR = SYMBOL_ITERATOR; + var SYMBOL_ASYNC_ITERATOR = typeof Symbol === "function" && Symbol.asyncIterator != null ? Symbol.asyncIterator : "@@asyncIterator"; + exports2.SYMBOL_ASYNC_ITERATOR = SYMBOL_ASYNC_ITERATOR; + var SYMBOL_TO_STRING_TAG = typeof Symbol === "function" && Symbol.toStringTag != null ? Symbol.toStringTag : "@@toStringTag"; + exports2.SYMBOL_TO_STRING_TAG = SYMBOL_TO_STRING_TAG; + } +}); + +// node_modules/graphql/language/location.js +var require_location = __commonJS({ + "node_modules/graphql/language/location.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.getLocation = getLocation; + function getLocation(source, position) { + var lineRegexp = /\r\n|[\n\r]/g; + var line = 1; + var column = position + 1; + var match; + while ((match = lineRegexp.exec(source.body)) && match.index < position) { + line += 1; + column = position + 1 - (match.index + match[0].length); + } + return { + line, + column + }; + } + } +}); + +// node_modules/graphql/language/printLocation.js +var require_printLocation = __commonJS({ + "node_modules/graphql/language/printLocation.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.printLocation = printLocation; + exports2.printSourceLocation = printSourceLocation; + var _location = require_location(); + function printLocation(location) { + return printSourceLocation(location.source, (0, _location.getLocation)(location.source, location.start)); + } + function printSourceLocation(source, sourceLocation) { + var firstLineColumnOffset = source.locationOffset.column - 1; + var body = whitespace(firstLineColumnOffset) + source.body; + var lineIndex = sourceLocation.line - 1; + var lineOffset = source.locationOffset.line - 1; + var lineNum = sourceLocation.line + lineOffset; + var columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0; + var columnNum = sourceLocation.column + columnOffset; + var locationStr = "".concat(source.name, ":").concat(lineNum, ":").concat(columnNum, "\n"); + var lines = body.split(/\r\n|[\n\r]/g); + var locationLine = lines[lineIndex]; + if (locationLine.length > 120) { + var subLineIndex = Math.floor(columnNum / 80); + var subLineColumnNum = columnNum % 80; + var subLines = []; + for (var i = 0; i < locationLine.length; i += 80) { + subLines.push(locationLine.slice(i, i + 80)); + } + return locationStr + printPrefixedLines([["".concat(lineNum), subLines[0]]].concat(subLines.slice(1, subLineIndex + 1).map(function(subLine) { + return ["", subLine]; + }), [[" ", whitespace(subLineColumnNum - 1) + "^"], ["", subLines[subLineIndex + 1]]])); + } + return locationStr + printPrefixedLines([ + ["".concat(lineNum - 1), lines[lineIndex - 1]], + ["".concat(lineNum), locationLine], + ["", whitespace(columnNum - 1) + "^"], + ["".concat(lineNum + 1), lines[lineIndex + 1]] + ]); + } + function printPrefixedLines(lines) { + var existingLines = lines.filter(function(_ref) { + var _ = _ref[0], line = _ref[1]; + return line !== void 0; + }); + var padLen = Math.max.apply(Math, existingLines.map(function(_ref2) { + var prefix = _ref2[0]; + return prefix.length; + })); + return existingLines.map(function(_ref3) { + var prefix = _ref3[0], line = _ref3[1]; + return leftPad(padLen, prefix) + (line ? " | " + line : " |"); + }).join("\n"); + } + function whitespace(len) { + return Array(len + 1).join(" "); + } + function leftPad(len, str) { + return whitespace(len - str.length) + str; + } + } +}); + +// node_modules/graphql/error/GraphQLError.js +var require_GraphQLError = __commonJS({ + "node_modules/graphql/error/GraphQLError.js"(exports2) { + "use strict"; + function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function _typeof2(obj2) { + return typeof obj2; + }; + } else { + _typeof = function _typeof2(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.printError = printError; + exports2.GraphQLError = void 0; + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _symbols = require_symbols(); + var _location = require_location(); + var _printLocation = require_printLocation(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); + if (superClass) + _setPrototypeOf(subClass, superClass); + } + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), result; + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + return _possibleConstructorReturn(this, result); + }; + } + function _possibleConstructorReturn(self2, call) { + if (call && (_typeof(call) === "object" || typeof call === "function")) { + return call; + } + return _assertThisInitialized(self2); + } + function _assertThisInitialized(self2) { + if (self2 === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return self2; + } + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : void 0; + _wrapNativeSuper = function _wrapNativeSuper2(Class2) { + if (Class2 === null || !_isNativeFunction(Class2)) + return Class2; + if (typeof Class2 !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + if (typeof _cache !== "undefined") { + if (_cache.has(Class2)) + return _cache.get(Class2); + _cache.set(Class2, Wrapper); + } + function Wrapper() { + return _construct(Class2, arguments, _getPrototypeOf(this).constructor); + } + Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); + return _setPrototypeOf(Wrapper, Class2); + }; + return _wrapNativeSuper(Class); + } + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct2(Parent2, args2, Class2) { + var a = [null]; + a.push.apply(a, args2); + var Constructor = Function.bind.apply(Parent2, a); + var instance = new Constructor(); + if (Class2) + _setPrototypeOf(instance, Class2.prototype); + return instance; + }; + } + return _construct.apply(null, arguments); + } + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) + return false; + if (Reflect.construct.sham) + return false; + if (typeof Proxy === "function") + return true; + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function() { + })); + return true; + } catch (e) { + return false; + } + } + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) { + o2.__proto__ = p2; + return o2; + }; + return _setPrototypeOf(o, p); + } + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) { + return o2.__proto__ || Object.getPrototypeOf(o2); + }; + return _getPrototypeOf(o); + } + var GraphQLError = /* @__PURE__ */ function(_Error) { + _inherits(GraphQLError2, _Error); + var _super = _createSuper(GraphQLError2); + function GraphQLError2(message, nodes, source, positions, path, originalError, extensions) { + var _nodeLocations, _nodeLocations2, _nodeLocations3; + var _this; + _classCallCheck(this, GraphQLError2); + _this = _super.call(this, message); + _this.name = "GraphQLError"; + _this.originalError = originalError !== null && originalError !== void 0 ? originalError : void 0; + _this.nodes = undefinedIfEmpty(Array.isArray(nodes) ? nodes : nodes ? [nodes] : void 0); + var nodeLocations = []; + for (var _i2 = 0, _ref3 = (_this$nodes = _this.nodes) !== null && _this$nodes !== void 0 ? _this$nodes : []; _i2 < _ref3.length; _i2++) { + var _this$nodes; + var _ref4 = _ref3[_i2]; + var loc = _ref4.loc; + if (loc != null) { + nodeLocations.push(loc); + } + } + nodeLocations = undefinedIfEmpty(nodeLocations); + _this.source = source !== null && source !== void 0 ? source : (_nodeLocations = nodeLocations) === null || _nodeLocations === void 0 ? void 0 : _nodeLocations[0].source; + _this.positions = positions !== null && positions !== void 0 ? positions : (_nodeLocations2 = nodeLocations) === null || _nodeLocations2 === void 0 ? void 0 : _nodeLocations2.map(function(loc2) { + return loc2.start; + }); + _this.locations = positions && source ? positions.map(function(pos) { + return (0, _location.getLocation)(source, pos); + }) : (_nodeLocations3 = nodeLocations) === null || _nodeLocations3 === void 0 ? void 0 : _nodeLocations3.map(function(loc2) { + return (0, _location.getLocation)(loc2.source, loc2.start); + }); + _this.path = path !== null && path !== void 0 ? path : void 0; + var originalExtensions = originalError === null || originalError === void 0 ? void 0 : originalError.extensions; + if (extensions == null && (0, _isObjectLike.default)(originalExtensions)) { + _this.extensions = _objectSpread({}, originalExtensions); + } else { + _this.extensions = extensions !== null && extensions !== void 0 ? extensions : {}; + } + Object.defineProperties(_assertThisInitialized(_this), { + message: { + enumerable: true + }, + locations: { + enumerable: _this.locations != null + }, + path: { + enumerable: _this.path != null + }, + extensions: { + enumerable: _this.extensions != null && Object.keys(_this.extensions).length > 0 + }, + name: { + enumerable: false + }, + nodes: { + enumerable: false + }, + source: { + enumerable: false + }, + positions: { + enumerable: false + }, + originalError: { + enumerable: false + } + }); + if (originalError !== null && originalError !== void 0 && originalError.stack) { + Object.defineProperty(_assertThisInitialized(_this), "stack", { + value: originalError.stack, + writable: true, + configurable: true + }); + return _possibleConstructorReturn(_this); + } + if (Error.captureStackTrace) { + Error.captureStackTrace(_assertThisInitialized(_this), GraphQLError2); + } else { + Object.defineProperty(_assertThisInitialized(_this), "stack", { + value: Error().stack, + writable: true, + configurable: true + }); + } + return _this; + } + _createClass(GraphQLError2, [{ + key: "toString", + value: function toString() { + return printError(this); + } + }, { + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "Object"; + } + }]); + return GraphQLError2; + }(/* @__PURE__ */ _wrapNativeSuper(Error)); + exports2.GraphQLError = GraphQLError; + function undefinedIfEmpty(array) { + return array === void 0 || array.length === 0 ? void 0 : array; + } + function printError(error) { + var output = error.message; + if (error.nodes) { + for (var _i4 = 0, _error$nodes2 = error.nodes; _i4 < _error$nodes2.length; _i4++) { + var node = _error$nodes2[_i4]; + if (node.loc) { + output += "\n\n" + (0, _printLocation.printLocation)(node.loc); + } + } + } else if (error.source && error.locations) { + for (var _i6 = 0, _error$locations2 = error.locations; _i6 < _error$locations2.length; _i6++) { + var location = _error$locations2[_i6]; + output += "\n\n" + (0, _printLocation.printSourceLocation)(error.source, location); + } + } + return output; + } + } +}); + +// node_modules/graphql/error/syntaxError.js +var require_syntaxError = __commonJS({ + "node_modules/graphql/error/syntaxError.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.syntaxError = syntaxError; + var _GraphQLError = require_GraphQLError(); + function syntaxError(source, position, description) { + return new _GraphQLError.GraphQLError("Syntax Error: ".concat(description), void 0, source, [position]); + } + } +}); + +// node_modules/graphql/language/kinds.js +var require_kinds = __commonJS({ + "node_modules/graphql/language/kinds.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.Kind = void 0; + var Kind = Object.freeze({ + NAME: "Name", + DOCUMENT: "Document", + OPERATION_DEFINITION: "OperationDefinition", + VARIABLE_DEFINITION: "VariableDefinition", + SELECTION_SET: "SelectionSet", + FIELD: "Field", + ARGUMENT: "Argument", + FRAGMENT_SPREAD: "FragmentSpread", + INLINE_FRAGMENT: "InlineFragment", + FRAGMENT_DEFINITION: "FragmentDefinition", + VARIABLE: "Variable", + INT: "IntValue", + FLOAT: "FloatValue", + STRING: "StringValue", + BOOLEAN: "BooleanValue", + NULL: "NullValue", + ENUM: "EnumValue", + LIST: "ListValue", + OBJECT: "ObjectValue", + OBJECT_FIELD: "ObjectField", + DIRECTIVE: "Directive", + NAMED_TYPE: "NamedType", + LIST_TYPE: "ListType", + NON_NULL_TYPE: "NonNullType", + SCHEMA_DEFINITION: "SchemaDefinition", + OPERATION_TYPE_DEFINITION: "OperationTypeDefinition", + SCALAR_TYPE_DEFINITION: "ScalarTypeDefinition", + OBJECT_TYPE_DEFINITION: "ObjectTypeDefinition", + FIELD_DEFINITION: "FieldDefinition", + INPUT_VALUE_DEFINITION: "InputValueDefinition", + INTERFACE_TYPE_DEFINITION: "InterfaceTypeDefinition", + UNION_TYPE_DEFINITION: "UnionTypeDefinition", + ENUM_TYPE_DEFINITION: "EnumTypeDefinition", + ENUM_VALUE_DEFINITION: "EnumValueDefinition", + INPUT_OBJECT_TYPE_DEFINITION: "InputObjectTypeDefinition", + DIRECTIVE_DEFINITION: "DirectiveDefinition", + SCHEMA_EXTENSION: "SchemaExtension", + SCALAR_TYPE_EXTENSION: "ScalarTypeExtension", + OBJECT_TYPE_EXTENSION: "ObjectTypeExtension", + INTERFACE_TYPE_EXTENSION: "InterfaceTypeExtension", + UNION_TYPE_EXTENSION: "UnionTypeExtension", + ENUM_TYPE_EXTENSION: "EnumTypeExtension", + INPUT_OBJECT_TYPE_EXTENSION: "InputObjectTypeExtension" + }); + exports2.Kind = Kind; + } +}); + +// node_modules/graphql/jsutils/invariant.js +var require_invariant = __commonJS({ + "node_modules/graphql/jsutils/invariant.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = invariant; + function invariant(condition, message) { + var booleanCondition = Boolean(condition); + if (!booleanCondition) { + throw new Error(message != null ? message : "Unexpected invariant triggered."); + } + } + } +}); + +// node_modules/graphql/jsutils/nodejsCustomInspectSymbol.js +var require_nodejsCustomInspectSymbol = __commonJS({ + "node_modules/graphql/jsutils/nodejsCustomInspectSymbol.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var nodejsCustomInspectSymbol = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : void 0; + var _default = nodejsCustomInspectSymbol; + exports2.default = _default; + } +}); + +// node_modules/graphql/jsutils/defineInspect.js +var require_defineInspect = __commonJS({ + "node_modules/graphql/jsutils/defineInspect.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = defineInspect; + var _invariant = _interopRequireDefault(require_invariant()); + var _nodejsCustomInspectSymbol = _interopRequireDefault(require_nodejsCustomInspectSymbol()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function defineInspect(classObject) { + var fn = classObject.prototype.toJSON; + typeof fn === "function" || (0, _invariant.default)(0); + classObject.prototype.inspect = fn; + if (_nodejsCustomInspectSymbol.default) { + classObject.prototype[_nodejsCustomInspectSymbol.default] = fn; + } + } + } +}); + +// node_modules/graphql/language/ast.js +var require_ast = __commonJS({ + "node_modules/graphql/language/ast.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isNode = isNode; + exports2.Token = exports2.Location = void 0; + var _defineInspect = _interopRequireDefault(require_defineInspect()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var Location = /* @__PURE__ */ function() { + function Location2(startToken, endToken, source) { + this.start = startToken.start; + this.end = endToken.end; + this.startToken = startToken; + this.endToken = endToken; + this.source = source; + } + var _proto = Location2.prototype; + _proto.toJSON = function toJSON() { + return { + start: this.start, + end: this.end + }; + }; + return Location2; + }(); + exports2.Location = Location; + (0, _defineInspect.default)(Location); + var Token = /* @__PURE__ */ function() { + function Token2(kind, start, end, line, column, prev, value) { + this.kind = kind; + this.start = start; + this.end = end; + this.line = line; + this.column = column; + this.value = value; + this.prev = prev; + this.next = null; + } + var _proto2 = Token2.prototype; + _proto2.toJSON = function toJSON() { + return { + kind: this.kind, + value: this.value, + line: this.line, + column: this.column + }; + }; + return Token2; + }(); + exports2.Token = Token; + (0, _defineInspect.default)(Token); + function isNode(maybeNode) { + return maybeNode != null && typeof maybeNode.kind === "string"; + } + } +}); + +// node_modules/graphql/language/tokenKind.js +var require_tokenKind = __commonJS({ + "node_modules/graphql/language/tokenKind.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.TokenKind = void 0; + var TokenKind = Object.freeze({ + SOF: "", + EOF: "", + BANG: "!", + DOLLAR: "$", + AMP: "&", + PAREN_L: "(", + PAREN_R: ")", + SPREAD: "...", + COLON: ":", + EQUALS: "=", + AT: "@", + BRACKET_L: "[", + BRACKET_R: "]", + BRACE_L: "{", + PIPE: "|", + BRACE_R: "}", + NAME: "Name", + INT: "Int", + FLOAT: "Float", + STRING: "String", + BLOCK_STRING: "BlockString", + COMMENT: "Comment" + }); + exports2.TokenKind = TokenKind; + } +}); + +// node_modules/graphql/jsutils/inspect.js +var require_inspect = __commonJS({ + "node_modules/graphql/jsutils/inspect.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = inspect; + var _nodejsCustomInspectSymbol = _interopRequireDefault(require_nodejsCustomInspectSymbol()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function _typeof2(obj2) { + return typeof obj2; + }; + } else { + _typeof = function _typeof2(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + var MAX_ARRAY_LENGTH = 10; + var MAX_RECURSIVE_DEPTH = 2; + function inspect(value) { + return formatValue(value, []); + } + function formatValue(value, seenValues) { + switch (_typeof(value)) { + case "string": + return JSON.stringify(value); + case "function": + return value.name ? "[function ".concat(value.name, "]") : "[function]"; + case "object": + if (value === null) { + return "null"; + } + return formatObjectValue(value, seenValues); + default: + return String(value); + } + } + function formatObjectValue(value, previouslySeenValues) { + if (previouslySeenValues.indexOf(value) !== -1) { + return "[Circular]"; + } + var seenValues = [].concat(previouslySeenValues, [value]); + var customInspectFn = getCustomFn(value); + if (customInspectFn !== void 0) { + var customValue = customInspectFn.call(value); + if (customValue !== value) { + return typeof customValue === "string" ? customValue : formatValue(customValue, seenValues); + } + } else if (Array.isArray(value)) { + return formatArray(value, seenValues); + } + return formatObject(value, seenValues); + } + function formatObject(object, seenValues) { + var keys = Object.keys(object); + if (keys.length === 0) { + return "{}"; + } + if (seenValues.length > MAX_RECURSIVE_DEPTH) { + return "[" + getObjectTag(object) + "]"; + } + var properties = keys.map(function(key) { + var value = formatValue(object[key], seenValues); + return key + ": " + value; + }); + return "{ " + properties.join(", ") + " }"; + } + function formatArray(array, seenValues) { + if (array.length === 0) { + return "[]"; + } + if (seenValues.length > MAX_RECURSIVE_DEPTH) { + return "[Array]"; + } + var len = Math.min(MAX_ARRAY_LENGTH, array.length); + var remaining = array.length - len; + var items = []; + for (var i = 0; i < len; ++i) { + items.push(formatValue(array[i], seenValues)); + } + if (remaining === 1) { + items.push("... 1 more item"); + } else if (remaining > 1) { + items.push("... ".concat(remaining, " more items")); + } + return "[" + items.join(", ") + "]"; + } + function getCustomFn(object) { + var customInspectFn = object[String(_nodejsCustomInspectSymbol.default)]; + if (typeof customInspectFn === "function") { + return customInspectFn; + } + if (typeof object.inspect === "function") { + return object.inspect; + } + } + function getObjectTag(object) { + var tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, ""); + if (tag === "Object" && typeof object.constructor === "function") { + var name = object.constructor.name; + if (typeof name === "string" && name !== "") { + return name; + } + } + return tag; + } + } +}); + +// node_modules/graphql/jsutils/devAssert.js +var require_devAssert = __commonJS({ + "node_modules/graphql/jsutils/devAssert.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = devAssert; + function devAssert(condition, message) { + var booleanCondition = Boolean(condition); + if (!booleanCondition) { + throw new Error(message); + } + } + } +}); + +// node_modules/graphql/jsutils/instanceOf.js +var require_instanceOf = __commonJS({ + "node_modules/graphql/jsutils/instanceOf.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _inspect = _interopRequireDefault(require_inspect()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function _typeof2(obj2) { + return typeof obj2; + }; + } else { + _typeof = function _typeof2(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + var _default = process.env.NODE_ENV === "production" ? function instanceOf(value, constructor) { + return value instanceof constructor; + } : function instanceOf(value, constructor) { + if (value instanceof constructor) { + return true; + } + if (_typeof(value) === "object" && value !== null) { + var _value$constructor; + var className = constructor.prototype[Symbol.toStringTag]; + var valueClassName = Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name; + if (className === valueClassName) { + var stringifiedValue = (0, _inspect.default)(value); + throw new Error("Cannot use ".concat(className, ' "').concat(stringifiedValue, '" from another module or realm.\n\nEnsure that there is only one instance of "graphql" in the node_modules\ndirectory. If different versions of "graphql" are the dependencies of other\nrelied on modules, use "resolutions" to ensure only one version is installed.\n\nhttps://yarnpkg.com/en/docs/selective-version-resolutions\n\nDuplicate "graphql" modules cannot be used at the same time since different\nversions may have different capabilities and behavior. The data from one\nversion used in the function from another could produce confusing and\nspurious results.')); + } + } + return false; + }; + exports2.default = _default; + } +}); + +// node_modules/graphql/language/source.js +var require_source = __commonJS({ + "node_modules/graphql/language/source.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isSource = isSource; + exports2.Source = void 0; + var _symbols = require_symbols(); + var _inspect = _interopRequireDefault(require_inspect()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _instanceOf = _interopRequireDefault(require_instanceOf()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + var Source = /* @__PURE__ */ function() { + function Source2(body) { + var name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "GraphQL request"; + var locationOffset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { + line: 1, + column: 1 + }; + typeof body === "string" || (0, _devAssert.default)(0, "Body must be a string. Received: ".concat((0, _inspect.default)(body), ".")); + this.body = body; + this.name = name; + this.locationOffset = locationOffset; + this.locationOffset.line > 0 || (0, _devAssert.default)(0, "line in locationOffset is 1-indexed and must be positive."); + this.locationOffset.column > 0 || (0, _devAssert.default)(0, "column in locationOffset is 1-indexed and must be positive."); + } + _createClass(Source2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "Source"; + } + }]); + return Source2; + }(); + exports2.Source = Source; + function isSource(source) { + return (0, _instanceOf.default)(source, Source); + } + } +}); + +// node_modules/graphql/language/directiveLocation.js +var require_directiveLocation = __commonJS({ + "node_modules/graphql/language/directiveLocation.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.DirectiveLocation = void 0; + var DirectiveLocation = Object.freeze({ + QUERY: "QUERY", + MUTATION: "MUTATION", + SUBSCRIPTION: "SUBSCRIPTION", + FIELD: "FIELD", + FRAGMENT_DEFINITION: "FRAGMENT_DEFINITION", + FRAGMENT_SPREAD: "FRAGMENT_SPREAD", + INLINE_FRAGMENT: "INLINE_FRAGMENT", + VARIABLE_DEFINITION: "VARIABLE_DEFINITION", + SCHEMA: "SCHEMA", + SCALAR: "SCALAR", + OBJECT: "OBJECT", + FIELD_DEFINITION: "FIELD_DEFINITION", + ARGUMENT_DEFINITION: "ARGUMENT_DEFINITION", + INTERFACE: "INTERFACE", + UNION: "UNION", + ENUM: "ENUM", + ENUM_VALUE: "ENUM_VALUE", + INPUT_OBJECT: "INPUT_OBJECT", + INPUT_FIELD_DEFINITION: "INPUT_FIELD_DEFINITION" + }); + exports2.DirectiveLocation = DirectiveLocation; + } +}); + +// node_modules/graphql/language/blockString.js +var require_blockString = __commonJS({ + "node_modules/graphql/language/blockString.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.dedentBlockStringValue = dedentBlockStringValue; + exports2.getBlockStringIndentation = getBlockStringIndentation; + exports2.printBlockString = printBlockString; + function dedentBlockStringValue(rawString) { + var lines = rawString.split(/\r\n|[\n\r]/g); + var commonIndent = getBlockStringIndentation(rawString); + if (commonIndent !== 0) { + for (var i = 1; i < lines.length; i++) { + lines[i] = lines[i].slice(commonIndent); + } + } + var startLine = 0; + while (startLine < lines.length && isBlank(lines[startLine])) { + ++startLine; + } + var endLine = lines.length; + while (endLine > startLine && isBlank(lines[endLine - 1])) { + --endLine; + } + return lines.slice(startLine, endLine).join("\n"); + } + function isBlank(str) { + for (var i = 0; i < str.length; ++i) { + if (str[i] !== " " && str[i] !== " ") { + return false; + } + } + return true; + } + function getBlockStringIndentation(value) { + var _commonIndent; + var isFirstLine = true; + var isEmptyLine = true; + var indent = 0; + var commonIndent = null; + for (var i = 0; i < value.length; ++i) { + switch (value.charCodeAt(i)) { + case 13: + if (value.charCodeAt(i + 1) === 10) { + ++i; + } + case 10: + isFirstLine = false; + isEmptyLine = true; + indent = 0; + break; + case 9: + case 32: + ++indent; + break; + default: + if (isEmptyLine && !isFirstLine && (commonIndent === null || indent < commonIndent)) { + commonIndent = indent; + } + isEmptyLine = false; + } + } + return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0 ? _commonIndent : 0; + } + function printBlockString(value) { + var indentation = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ""; + var preferMultipleLines = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false; + var isSingleLine = value.indexOf("\n") === -1; + var hasLeadingSpace = value[0] === " " || value[0] === " "; + var hasTrailingQuote = value[value.length - 1] === '"'; + var hasTrailingSlash = value[value.length - 1] === "\\"; + var printAsMultipleLines = !isSingleLine || hasTrailingQuote || hasTrailingSlash || preferMultipleLines; + var result = ""; + if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) { + result += "\n" + indentation; + } + result += indentation ? value.replace(/\n/g, "\n" + indentation) : value; + if (printAsMultipleLines) { + result += "\n"; + } + return '"""' + result.replace(/"""/g, '\\"""') + '"""'; + } + } +}); + +// node_modules/graphql/language/lexer.js +var require_lexer = __commonJS({ + "node_modules/graphql/language/lexer.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isPunctuatorTokenKind = isPunctuatorTokenKind; + exports2.Lexer = void 0; + var _syntaxError = require_syntaxError(); + var _ast = require_ast(); + var _tokenKind = require_tokenKind(); + var _blockString = require_blockString(); + var Lexer = /* @__PURE__ */ function() { + function Lexer2(source) { + var startOfFileToken = new _ast.Token(_tokenKind.TokenKind.SOF, 0, 0, 0, 0, null); + this.source = source; + this.lastToken = startOfFileToken; + this.token = startOfFileToken; + this.line = 1; + this.lineStart = 0; + } + var _proto = Lexer2.prototype; + _proto.advance = function advance() { + this.lastToken = this.token; + var token = this.token = this.lookahead(); + return token; + }; + _proto.lookahead = function lookahead() { + var token = this.token; + if (token.kind !== _tokenKind.TokenKind.EOF) { + do { + var _token$next; + token = (_token$next = token.next) !== null && _token$next !== void 0 ? _token$next : token.next = readToken(this, token); + } while (token.kind === _tokenKind.TokenKind.COMMENT); + } + return token; + }; + return Lexer2; + }(); + exports2.Lexer = Lexer; + function isPunctuatorTokenKind(kind) { + return kind === _tokenKind.TokenKind.BANG || kind === _tokenKind.TokenKind.DOLLAR || kind === _tokenKind.TokenKind.AMP || kind === _tokenKind.TokenKind.PAREN_L || kind === _tokenKind.TokenKind.PAREN_R || kind === _tokenKind.TokenKind.SPREAD || kind === _tokenKind.TokenKind.COLON || kind === _tokenKind.TokenKind.EQUALS || kind === _tokenKind.TokenKind.AT || kind === _tokenKind.TokenKind.BRACKET_L || kind === _tokenKind.TokenKind.BRACKET_R || kind === _tokenKind.TokenKind.BRACE_L || kind === _tokenKind.TokenKind.PIPE || kind === _tokenKind.TokenKind.BRACE_R; + } + function printCharCode(code) { + return isNaN(code) ? _tokenKind.TokenKind.EOF : code < 127 ? JSON.stringify(String.fromCharCode(code)) : '"\\u'.concat(("00" + code.toString(16).toUpperCase()).slice(-4), '"'); + } + function readToken(lexer, prev) { + var source = lexer.source; + var body = source.body; + var bodyLength = body.length; + var pos = prev.end; + while (pos < bodyLength) { + var code = body.charCodeAt(pos); + var _line = lexer.line; + var _col = 1 + pos - lexer.lineStart; + switch (code) { + case 65279: + case 9: + case 32: + case 44: + ++pos; + continue; + case 10: + ++pos; + ++lexer.line; + lexer.lineStart = pos; + continue; + case 13: + if (body.charCodeAt(pos + 1) === 10) { + pos += 2; + } else { + ++pos; + } + ++lexer.line; + lexer.lineStart = pos; + continue; + case 33: + return new _ast.Token(_tokenKind.TokenKind.BANG, pos, pos + 1, _line, _col, prev); + case 35: + return readComment(source, pos, _line, _col, prev); + case 36: + return new _ast.Token(_tokenKind.TokenKind.DOLLAR, pos, pos + 1, _line, _col, prev); + case 38: + return new _ast.Token(_tokenKind.TokenKind.AMP, pos, pos + 1, _line, _col, prev); + case 40: + return new _ast.Token(_tokenKind.TokenKind.PAREN_L, pos, pos + 1, _line, _col, prev); + case 41: + return new _ast.Token(_tokenKind.TokenKind.PAREN_R, pos, pos + 1, _line, _col, prev); + case 46: + if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) { + return new _ast.Token(_tokenKind.TokenKind.SPREAD, pos, pos + 3, _line, _col, prev); + } + break; + case 58: + return new _ast.Token(_tokenKind.TokenKind.COLON, pos, pos + 1, _line, _col, prev); + case 61: + return new _ast.Token(_tokenKind.TokenKind.EQUALS, pos, pos + 1, _line, _col, prev); + case 64: + return new _ast.Token(_tokenKind.TokenKind.AT, pos, pos + 1, _line, _col, prev); + case 91: + return new _ast.Token(_tokenKind.TokenKind.BRACKET_L, pos, pos + 1, _line, _col, prev); + case 93: + return new _ast.Token(_tokenKind.TokenKind.BRACKET_R, pos, pos + 1, _line, _col, prev); + case 123: + return new _ast.Token(_tokenKind.TokenKind.BRACE_L, pos, pos + 1, _line, _col, prev); + case 124: + return new _ast.Token(_tokenKind.TokenKind.PIPE, pos, pos + 1, _line, _col, prev); + case 125: + return new _ast.Token(_tokenKind.TokenKind.BRACE_R, pos, pos + 1, _line, _col, prev); + case 34: + if (body.charCodeAt(pos + 1) === 34 && body.charCodeAt(pos + 2) === 34) { + return readBlockString(source, pos, _line, _col, prev, lexer); + } + return readString(source, pos, _line, _col, prev); + case 45: + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + return readNumber(source, pos, code, _line, _col, prev); + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 95: + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + return readName(source, pos, _line, _col, prev); + } + throw (0, _syntaxError.syntaxError)(source, pos, unexpectedCharacterMessage(code)); + } + var line = lexer.line; + var col = 1 + pos - lexer.lineStart; + return new _ast.Token(_tokenKind.TokenKind.EOF, bodyLength, bodyLength, line, col, prev); + } + function unexpectedCharacterMessage(code) { + if (code < 32 && code !== 9 && code !== 10 && code !== 13) { + return "Cannot contain the invalid character ".concat(printCharCode(code), "."); + } + if (code === 39) { + return `Unexpected single quote character ('), did you mean to use a double quote (")?`; + } + return "Cannot parse the unexpected character ".concat(printCharCode(code), "."); + } + function readComment(source, start, line, col, prev) { + var body = source.body; + var code; + var position = start; + do { + code = body.charCodeAt(++position); + } while (!isNaN(code) && (code > 31 || code === 9)); + return new _ast.Token(_tokenKind.TokenKind.COMMENT, start, position, line, col, prev, body.slice(start + 1, position)); + } + function readNumber(source, start, firstCode, line, col, prev) { + var body = source.body; + var code = firstCode; + var position = start; + var isFloat = false; + if (code === 45) { + code = body.charCodeAt(++position); + } + if (code === 48) { + code = body.charCodeAt(++position); + if (code >= 48 && code <= 57) { + throw (0, _syntaxError.syntaxError)(source, position, "Invalid number, unexpected digit after 0: ".concat(printCharCode(code), ".")); + } + } else { + position = readDigits(source, position, code); + code = body.charCodeAt(position); + } + if (code === 46) { + isFloat = true; + code = body.charCodeAt(++position); + position = readDigits(source, position, code); + code = body.charCodeAt(position); + } + if (code === 69 || code === 101) { + isFloat = true; + code = body.charCodeAt(++position); + if (code === 43 || code === 45) { + code = body.charCodeAt(++position); + } + position = readDigits(source, position, code); + code = body.charCodeAt(position); + } + if (code === 46 || isNameStart(code)) { + throw (0, _syntaxError.syntaxError)(source, position, "Invalid number, expected digit but got: ".concat(printCharCode(code), ".")); + } + return new _ast.Token(isFloat ? _tokenKind.TokenKind.FLOAT : _tokenKind.TokenKind.INT, start, position, line, col, prev, body.slice(start, position)); + } + function readDigits(source, start, firstCode) { + var body = source.body; + var position = start; + var code = firstCode; + if (code >= 48 && code <= 57) { + do { + code = body.charCodeAt(++position); + } while (code >= 48 && code <= 57); + return position; + } + throw (0, _syntaxError.syntaxError)(source, position, "Invalid number, expected digit but got: ".concat(printCharCode(code), ".")); + } + function readString(source, start, line, col, prev) { + var body = source.body; + var position = start + 1; + var chunkStart = position; + var code = 0; + var value = ""; + while (position < body.length && !isNaN(code = body.charCodeAt(position)) && code !== 10 && code !== 13) { + if (code === 34) { + value += body.slice(chunkStart, position); + return new _ast.Token(_tokenKind.TokenKind.STRING, start, position + 1, line, col, prev, value); + } + if (code < 32 && code !== 9) { + throw (0, _syntaxError.syntaxError)(source, position, "Invalid character within String: ".concat(printCharCode(code), ".")); + } + ++position; + if (code === 92) { + value += body.slice(chunkStart, position - 1); + code = body.charCodeAt(position); + switch (code) { + case 34: + value += '"'; + break; + case 47: + value += "/"; + break; + case 92: + value += "\\"; + break; + case 98: + value += "\b"; + break; + case 102: + value += "\f"; + break; + case 110: + value += "\n"; + break; + case 114: + value += "\r"; + break; + case 116: + value += " "; + break; + case 117: { + var charCode = uniCharCode(body.charCodeAt(position + 1), body.charCodeAt(position + 2), body.charCodeAt(position + 3), body.charCodeAt(position + 4)); + if (charCode < 0) { + var invalidSequence = body.slice(position + 1, position + 5); + throw (0, _syntaxError.syntaxError)(source, position, "Invalid character escape sequence: \\u".concat(invalidSequence, ".")); + } + value += String.fromCharCode(charCode); + position += 4; + break; + } + default: + throw (0, _syntaxError.syntaxError)(source, position, "Invalid character escape sequence: \\".concat(String.fromCharCode(code), ".")); + } + ++position; + chunkStart = position; + } + } + throw (0, _syntaxError.syntaxError)(source, position, "Unterminated string."); + } + function readBlockString(source, start, line, col, prev, lexer) { + var body = source.body; + var position = start + 3; + var chunkStart = position; + var code = 0; + var rawValue = ""; + while (position < body.length && !isNaN(code = body.charCodeAt(position))) { + if (code === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) { + rawValue += body.slice(chunkStart, position); + return new _ast.Token(_tokenKind.TokenKind.BLOCK_STRING, start, position + 3, line, col, prev, (0, _blockString.dedentBlockStringValue)(rawValue)); + } + if (code < 32 && code !== 9 && code !== 10 && code !== 13) { + throw (0, _syntaxError.syntaxError)(source, position, "Invalid character within String: ".concat(printCharCode(code), ".")); + } + if (code === 10) { + ++position; + ++lexer.line; + lexer.lineStart = position; + } else if (code === 13) { + if (body.charCodeAt(position + 1) === 10) { + position += 2; + } else { + ++position; + } + ++lexer.line; + lexer.lineStart = position; + } else if (code === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) { + rawValue += body.slice(chunkStart, position) + '"""'; + position += 4; + chunkStart = position; + } else { + ++position; + } + } + throw (0, _syntaxError.syntaxError)(source, position, "Unterminated string."); + } + function uniCharCode(a, b, c, d) { + return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d); + } + function char2hex(a) { + return a >= 48 && a <= 57 ? a - 48 : a >= 65 && a <= 70 ? a - 55 : a >= 97 && a <= 102 ? a - 87 : -1; + } + function readName(source, start, line, col, prev) { + var body = source.body; + var bodyLength = body.length; + var position = start + 1; + var code = 0; + while (position !== bodyLength && !isNaN(code = body.charCodeAt(position)) && (code === 95 || code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122)) { + ++position; + } + return new _ast.Token(_tokenKind.TokenKind.NAME, start, position, line, col, prev, body.slice(start, position)); + } + function isNameStart(code) { + return code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122; + } + } +}); + +// node_modules/graphql/language/parser.js +var require_parser = __commonJS({ + "node_modules/graphql/language/parser.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.parse = parse; + exports2.parseValue = parseValue; + exports2.parseType = parseType; + exports2.Parser = void 0; + var _syntaxError = require_syntaxError(); + var _kinds = require_kinds(); + var _ast = require_ast(); + var _tokenKind = require_tokenKind(); + var _source = require_source(); + var _directiveLocation = require_directiveLocation(); + var _lexer = require_lexer(); + function parse(source, options) { + var parser = new Parser(source, options); + return parser.parseDocument(); + } + function parseValue(source, options) { + var parser = new Parser(source, options); + parser.expectToken(_tokenKind.TokenKind.SOF); + var value = parser.parseValueLiteral(false); + parser.expectToken(_tokenKind.TokenKind.EOF); + return value; + } + function parseType(source, options) { + var parser = new Parser(source, options); + parser.expectToken(_tokenKind.TokenKind.SOF); + var type = parser.parseTypeReference(); + parser.expectToken(_tokenKind.TokenKind.EOF); + return type; + } + var Parser = /* @__PURE__ */ function() { + function Parser2(source, options) { + var sourceObj = (0, _source.isSource)(source) ? source : new _source.Source(source); + this._lexer = new _lexer.Lexer(sourceObj); + this._options = options; + } + var _proto = Parser2.prototype; + _proto.parseName = function parseName() { + var token = this.expectToken(_tokenKind.TokenKind.NAME); + return { + kind: _kinds.Kind.NAME, + value: token.value, + loc: this.loc(token) + }; + }; + _proto.parseDocument = function parseDocument() { + var start = this._lexer.token; + return { + kind: _kinds.Kind.DOCUMENT, + definitions: this.many(_tokenKind.TokenKind.SOF, this.parseDefinition, _tokenKind.TokenKind.EOF), + loc: this.loc(start) + }; + }; + _proto.parseDefinition = function parseDefinition() { + if (this.peek(_tokenKind.TokenKind.NAME)) { + switch (this._lexer.token.value) { + case "query": + case "mutation": + case "subscription": + return this.parseOperationDefinition(); + case "fragment": + return this.parseFragmentDefinition(); + case "schema": + case "scalar": + case "type": + case "interface": + case "union": + case "enum": + case "input": + case "directive": + return this.parseTypeSystemDefinition(); + case "extend": + return this.parseTypeSystemExtension(); + } + } else if (this.peek(_tokenKind.TokenKind.BRACE_L)) { + return this.parseOperationDefinition(); + } else if (this.peekDescription()) { + return this.parseTypeSystemDefinition(); + } + throw this.unexpected(); + }; + _proto.parseOperationDefinition = function parseOperationDefinition() { + var start = this._lexer.token; + if (this.peek(_tokenKind.TokenKind.BRACE_L)) { + return { + kind: _kinds.Kind.OPERATION_DEFINITION, + operation: "query", + name: void 0, + variableDefinitions: [], + directives: [], + selectionSet: this.parseSelectionSet(), + loc: this.loc(start) + }; + } + var operation = this.parseOperationType(); + var name; + if (this.peek(_tokenKind.TokenKind.NAME)) { + name = this.parseName(); + } + return { + kind: _kinds.Kind.OPERATION_DEFINITION, + operation, + name, + variableDefinitions: this.parseVariableDefinitions(), + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet(), + loc: this.loc(start) + }; + }; + _proto.parseOperationType = function parseOperationType() { + var operationToken = this.expectToken(_tokenKind.TokenKind.NAME); + switch (operationToken.value) { + case "query": + return "query"; + case "mutation": + return "mutation"; + case "subscription": + return "subscription"; + } + throw this.unexpected(operationToken); + }; + _proto.parseVariableDefinitions = function parseVariableDefinitions() { + return this.optionalMany(_tokenKind.TokenKind.PAREN_L, this.parseVariableDefinition, _tokenKind.TokenKind.PAREN_R); + }; + _proto.parseVariableDefinition = function parseVariableDefinition() { + var start = this._lexer.token; + return { + kind: _kinds.Kind.VARIABLE_DEFINITION, + variable: this.parseVariable(), + type: (this.expectToken(_tokenKind.TokenKind.COLON), this.parseTypeReference()), + defaultValue: this.expectOptionalToken(_tokenKind.TokenKind.EQUALS) ? this.parseValueLiteral(true) : void 0, + directives: this.parseDirectives(true), + loc: this.loc(start) + }; + }; + _proto.parseVariable = function parseVariable() { + var start = this._lexer.token; + this.expectToken(_tokenKind.TokenKind.DOLLAR); + return { + kind: _kinds.Kind.VARIABLE, + name: this.parseName(), + loc: this.loc(start) + }; + }; + _proto.parseSelectionSet = function parseSelectionSet() { + var start = this._lexer.token; + return { + kind: _kinds.Kind.SELECTION_SET, + selections: this.many(_tokenKind.TokenKind.BRACE_L, this.parseSelection, _tokenKind.TokenKind.BRACE_R), + loc: this.loc(start) + }; + }; + _proto.parseSelection = function parseSelection() { + return this.peek(_tokenKind.TokenKind.SPREAD) ? this.parseFragment() : this.parseField(); + }; + _proto.parseField = function parseField() { + var start = this._lexer.token; + var nameOrAlias = this.parseName(); + var alias; + var name; + if (this.expectOptionalToken(_tokenKind.TokenKind.COLON)) { + alias = nameOrAlias; + name = this.parseName(); + } else { + name = nameOrAlias; + } + return { + kind: _kinds.Kind.FIELD, + alias, + name, + arguments: this.parseArguments(false), + directives: this.parseDirectives(false), + selectionSet: this.peek(_tokenKind.TokenKind.BRACE_L) ? this.parseSelectionSet() : void 0, + loc: this.loc(start) + }; + }; + _proto.parseArguments = function parseArguments(isConst) { + var item = isConst ? this.parseConstArgument : this.parseArgument; + return this.optionalMany(_tokenKind.TokenKind.PAREN_L, item, _tokenKind.TokenKind.PAREN_R); + }; + _proto.parseArgument = function parseArgument() { + var start = this._lexer.token; + var name = this.parseName(); + this.expectToken(_tokenKind.TokenKind.COLON); + return { + kind: _kinds.Kind.ARGUMENT, + name, + value: this.parseValueLiteral(false), + loc: this.loc(start) + }; + }; + _proto.parseConstArgument = function parseConstArgument() { + var start = this._lexer.token; + return { + kind: _kinds.Kind.ARGUMENT, + name: this.parseName(), + value: (this.expectToken(_tokenKind.TokenKind.COLON), this.parseValueLiteral(true)), + loc: this.loc(start) + }; + }; + _proto.parseFragment = function parseFragment() { + var start = this._lexer.token; + this.expectToken(_tokenKind.TokenKind.SPREAD); + var hasTypeCondition = this.expectOptionalKeyword("on"); + if (!hasTypeCondition && this.peek(_tokenKind.TokenKind.NAME)) { + return { + kind: _kinds.Kind.FRAGMENT_SPREAD, + name: this.parseFragmentName(), + directives: this.parseDirectives(false), + loc: this.loc(start) + }; + } + return { + kind: _kinds.Kind.INLINE_FRAGMENT, + typeCondition: hasTypeCondition ? this.parseNamedType() : void 0, + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet(), + loc: this.loc(start) + }; + }; + _proto.parseFragmentDefinition = function parseFragmentDefinition() { + var _this$_options; + var start = this._lexer.token; + this.expectKeyword("fragment"); + if (((_this$_options = this._options) === null || _this$_options === void 0 ? void 0 : _this$_options.experimentalFragmentVariables) === true) { + return { + kind: _kinds.Kind.FRAGMENT_DEFINITION, + name: this.parseFragmentName(), + variableDefinitions: this.parseVariableDefinitions(), + typeCondition: (this.expectKeyword("on"), this.parseNamedType()), + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet(), + loc: this.loc(start) + }; + } + return { + kind: _kinds.Kind.FRAGMENT_DEFINITION, + name: this.parseFragmentName(), + typeCondition: (this.expectKeyword("on"), this.parseNamedType()), + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet(), + loc: this.loc(start) + }; + }; + _proto.parseFragmentName = function parseFragmentName() { + if (this._lexer.token.value === "on") { + throw this.unexpected(); + } + return this.parseName(); + }; + _proto.parseValueLiteral = function parseValueLiteral(isConst) { + var token = this._lexer.token; + switch (token.kind) { + case _tokenKind.TokenKind.BRACKET_L: + return this.parseList(isConst); + case _tokenKind.TokenKind.BRACE_L: + return this.parseObject(isConst); + case _tokenKind.TokenKind.INT: + this._lexer.advance(); + return { + kind: _kinds.Kind.INT, + value: token.value, + loc: this.loc(token) + }; + case _tokenKind.TokenKind.FLOAT: + this._lexer.advance(); + return { + kind: _kinds.Kind.FLOAT, + value: token.value, + loc: this.loc(token) + }; + case _tokenKind.TokenKind.STRING: + case _tokenKind.TokenKind.BLOCK_STRING: + return this.parseStringLiteral(); + case _tokenKind.TokenKind.NAME: + this._lexer.advance(); + switch (token.value) { + case "true": + return { + kind: _kinds.Kind.BOOLEAN, + value: true, + loc: this.loc(token) + }; + case "false": + return { + kind: _kinds.Kind.BOOLEAN, + value: false, + loc: this.loc(token) + }; + case "null": + return { + kind: _kinds.Kind.NULL, + loc: this.loc(token) + }; + default: + return { + kind: _kinds.Kind.ENUM, + value: token.value, + loc: this.loc(token) + }; + } + case _tokenKind.TokenKind.DOLLAR: + if (!isConst) { + return this.parseVariable(); + } + break; + } + throw this.unexpected(); + }; + _proto.parseStringLiteral = function parseStringLiteral() { + var token = this._lexer.token; + this._lexer.advance(); + return { + kind: _kinds.Kind.STRING, + value: token.value, + block: token.kind === _tokenKind.TokenKind.BLOCK_STRING, + loc: this.loc(token) + }; + }; + _proto.parseList = function parseList(isConst) { + var _this = this; + var start = this._lexer.token; + var item = function item2() { + return _this.parseValueLiteral(isConst); + }; + return { + kind: _kinds.Kind.LIST, + values: this.any(_tokenKind.TokenKind.BRACKET_L, item, _tokenKind.TokenKind.BRACKET_R), + loc: this.loc(start) + }; + }; + _proto.parseObject = function parseObject(isConst) { + var _this2 = this; + var start = this._lexer.token; + var item = function item2() { + return _this2.parseObjectField(isConst); + }; + return { + kind: _kinds.Kind.OBJECT, + fields: this.any(_tokenKind.TokenKind.BRACE_L, item, _tokenKind.TokenKind.BRACE_R), + loc: this.loc(start) + }; + }; + _proto.parseObjectField = function parseObjectField(isConst) { + var start = this._lexer.token; + var name = this.parseName(); + this.expectToken(_tokenKind.TokenKind.COLON); + return { + kind: _kinds.Kind.OBJECT_FIELD, + name, + value: this.parseValueLiteral(isConst), + loc: this.loc(start) + }; + }; + _proto.parseDirectives = function parseDirectives(isConst) { + var directives = []; + while (this.peek(_tokenKind.TokenKind.AT)) { + directives.push(this.parseDirective(isConst)); + } + return directives; + }; + _proto.parseDirective = function parseDirective(isConst) { + var start = this._lexer.token; + this.expectToken(_tokenKind.TokenKind.AT); + return { + kind: _kinds.Kind.DIRECTIVE, + name: this.parseName(), + arguments: this.parseArguments(isConst), + loc: this.loc(start) + }; + }; + _proto.parseTypeReference = function parseTypeReference() { + var start = this._lexer.token; + var type; + if (this.expectOptionalToken(_tokenKind.TokenKind.BRACKET_L)) { + type = this.parseTypeReference(); + this.expectToken(_tokenKind.TokenKind.BRACKET_R); + type = { + kind: _kinds.Kind.LIST_TYPE, + type, + loc: this.loc(start) + }; + } else { + type = this.parseNamedType(); + } + if (this.expectOptionalToken(_tokenKind.TokenKind.BANG)) { + return { + kind: _kinds.Kind.NON_NULL_TYPE, + type, + loc: this.loc(start) + }; + } + return type; + }; + _proto.parseNamedType = function parseNamedType() { + var start = this._lexer.token; + return { + kind: _kinds.Kind.NAMED_TYPE, + name: this.parseName(), + loc: this.loc(start) + }; + }; + _proto.parseTypeSystemDefinition = function parseTypeSystemDefinition() { + var keywordToken = this.peekDescription() ? this._lexer.lookahead() : this._lexer.token; + if (keywordToken.kind === _tokenKind.TokenKind.NAME) { + switch (keywordToken.value) { + case "schema": + return this.parseSchemaDefinition(); + case "scalar": + return this.parseScalarTypeDefinition(); + case "type": + return this.parseObjectTypeDefinition(); + case "interface": + return this.parseInterfaceTypeDefinition(); + case "union": + return this.parseUnionTypeDefinition(); + case "enum": + return this.parseEnumTypeDefinition(); + case "input": + return this.parseInputObjectTypeDefinition(); + case "directive": + return this.parseDirectiveDefinition(); + } + } + throw this.unexpected(keywordToken); + }; + _proto.peekDescription = function peekDescription() { + return this.peek(_tokenKind.TokenKind.STRING) || this.peek(_tokenKind.TokenKind.BLOCK_STRING); + }; + _proto.parseDescription = function parseDescription() { + if (this.peekDescription()) { + return this.parseStringLiteral(); + } + }; + _proto.parseSchemaDefinition = function parseSchemaDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("schema"); + var directives = this.parseDirectives(true); + var operationTypes = this.many(_tokenKind.TokenKind.BRACE_L, this.parseOperationTypeDefinition, _tokenKind.TokenKind.BRACE_R); + return { + kind: _kinds.Kind.SCHEMA_DEFINITION, + description, + directives, + operationTypes, + loc: this.loc(start) + }; + }; + _proto.parseOperationTypeDefinition = function parseOperationTypeDefinition() { + var start = this._lexer.token; + var operation = this.parseOperationType(); + this.expectToken(_tokenKind.TokenKind.COLON); + var type = this.parseNamedType(); + return { + kind: _kinds.Kind.OPERATION_TYPE_DEFINITION, + operation, + type, + loc: this.loc(start) + }; + }; + _proto.parseScalarTypeDefinition = function parseScalarTypeDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("scalar"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + return { + kind: _kinds.Kind.SCALAR_TYPE_DEFINITION, + description, + name, + directives, + loc: this.loc(start) + }; + }; + _proto.parseObjectTypeDefinition = function parseObjectTypeDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("type"); + var name = this.parseName(); + var interfaces = this.parseImplementsInterfaces(); + var directives = this.parseDirectives(true); + var fields = this.parseFieldsDefinition(); + return { + kind: _kinds.Kind.OBJECT_TYPE_DEFINITION, + description, + name, + interfaces, + directives, + fields, + loc: this.loc(start) + }; + }; + _proto.parseImplementsInterfaces = function parseImplementsInterfaces() { + var _this$_options2; + if (!this.expectOptionalKeyword("implements")) { + return []; + } + if (((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true) { + var types = []; + this.expectOptionalToken(_tokenKind.TokenKind.AMP); + do { + types.push(this.parseNamedType()); + } while (this.expectOptionalToken(_tokenKind.TokenKind.AMP) || this.peek(_tokenKind.TokenKind.NAME)); + return types; + } + return this.delimitedMany(_tokenKind.TokenKind.AMP, this.parseNamedType); + }; + _proto.parseFieldsDefinition = function parseFieldsDefinition() { + var _this$_options3; + if (((_this$_options3 = this._options) === null || _this$_options3 === void 0 ? void 0 : _this$_options3.allowLegacySDLEmptyFields) === true && this.peek(_tokenKind.TokenKind.BRACE_L) && this._lexer.lookahead().kind === _tokenKind.TokenKind.BRACE_R) { + this._lexer.advance(); + this._lexer.advance(); + return []; + } + return this.optionalMany(_tokenKind.TokenKind.BRACE_L, this.parseFieldDefinition, _tokenKind.TokenKind.BRACE_R); + }; + _proto.parseFieldDefinition = function parseFieldDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + var name = this.parseName(); + var args = this.parseArgumentDefs(); + this.expectToken(_tokenKind.TokenKind.COLON); + var type = this.parseTypeReference(); + var directives = this.parseDirectives(true); + return { + kind: _kinds.Kind.FIELD_DEFINITION, + description, + name, + arguments: args, + type, + directives, + loc: this.loc(start) + }; + }; + _proto.parseArgumentDefs = function parseArgumentDefs() { + return this.optionalMany(_tokenKind.TokenKind.PAREN_L, this.parseInputValueDef, _tokenKind.TokenKind.PAREN_R); + }; + _proto.parseInputValueDef = function parseInputValueDef() { + var start = this._lexer.token; + var description = this.parseDescription(); + var name = this.parseName(); + this.expectToken(_tokenKind.TokenKind.COLON); + var type = this.parseTypeReference(); + var defaultValue; + if (this.expectOptionalToken(_tokenKind.TokenKind.EQUALS)) { + defaultValue = this.parseValueLiteral(true); + } + var directives = this.parseDirectives(true); + return { + kind: _kinds.Kind.INPUT_VALUE_DEFINITION, + description, + name, + type, + defaultValue, + directives, + loc: this.loc(start) + }; + }; + _proto.parseInterfaceTypeDefinition = function parseInterfaceTypeDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("interface"); + var name = this.parseName(); + var interfaces = this.parseImplementsInterfaces(); + var directives = this.parseDirectives(true); + var fields = this.parseFieldsDefinition(); + return { + kind: _kinds.Kind.INTERFACE_TYPE_DEFINITION, + description, + name, + interfaces, + directives, + fields, + loc: this.loc(start) + }; + }; + _proto.parseUnionTypeDefinition = function parseUnionTypeDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("union"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + var types = this.parseUnionMemberTypes(); + return { + kind: _kinds.Kind.UNION_TYPE_DEFINITION, + description, + name, + directives, + types, + loc: this.loc(start) + }; + }; + _proto.parseUnionMemberTypes = function parseUnionMemberTypes() { + return this.expectOptionalToken(_tokenKind.TokenKind.EQUALS) ? this.delimitedMany(_tokenKind.TokenKind.PIPE, this.parseNamedType) : []; + }; + _proto.parseEnumTypeDefinition = function parseEnumTypeDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("enum"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + var values = this.parseEnumValuesDefinition(); + return { + kind: _kinds.Kind.ENUM_TYPE_DEFINITION, + description, + name, + directives, + values, + loc: this.loc(start) + }; + }; + _proto.parseEnumValuesDefinition = function parseEnumValuesDefinition() { + return this.optionalMany(_tokenKind.TokenKind.BRACE_L, this.parseEnumValueDefinition, _tokenKind.TokenKind.BRACE_R); + }; + _proto.parseEnumValueDefinition = function parseEnumValueDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + var name = this.parseName(); + var directives = this.parseDirectives(true); + return { + kind: _kinds.Kind.ENUM_VALUE_DEFINITION, + description, + name, + directives, + loc: this.loc(start) + }; + }; + _proto.parseInputObjectTypeDefinition = function parseInputObjectTypeDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("input"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + var fields = this.parseInputFieldsDefinition(); + return { + kind: _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION, + description, + name, + directives, + fields, + loc: this.loc(start) + }; + }; + _proto.parseInputFieldsDefinition = function parseInputFieldsDefinition() { + return this.optionalMany(_tokenKind.TokenKind.BRACE_L, this.parseInputValueDef, _tokenKind.TokenKind.BRACE_R); + }; + _proto.parseTypeSystemExtension = function parseTypeSystemExtension() { + var keywordToken = this._lexer.lookahead(); + if (keywordToken.kind === _tokenKind.TokenKind.NAME) { + switch (keywordToken.value) { + case "schema": + return this.parseSchemaExtension(); + case "scalar": + return this.parseScalarTypeExtension(); + case "type": + return this.parseObjectTypeExtension(); + case "interface": + return this.parseInterfaceTypeExtension(); + case "union": + return this.parseUnionTypeExtension(); + case "enum": + return this.parseEnumTypeExtension(); + case "input": + return this.parseInputObjectTypeExtension(); + } + } + throw this.unexpected(keywordToken); + }; + _proto.parseSchemaExtension = function parseSchemaExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("schema"); + var directives = this.parseDirectives(true); + var operationTypes = this.optionalMany(_tokenKind.TokenKind.BRACE_L, this.parseOperationTypeDefinition, _tokenKind.TokenKind.BRACE_R); + if (directives.length === 0 && operationTypes.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.SCHEMA_EXTENSION, + directives, + operationTypes, + loc: this.loc(start) + }; + }; + _proto.parseScalarTypeExtension = function parseScalarTypeExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("scalar"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + if (directives.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.SCALAR_TYPE_EXTENSION, + name, + directives, + loc: this.loc(start) + }; + }; + _proto.parseObjectTypeExtension = function parseObjectTypeExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("type"); + var name = this.parseName(); + var interfaces = this.parseImplementsInterfaces(); + var directives = this.parseDirectives(true); + var fields = this.parseFieldsDefinition(); + if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.OBJECT_TYPE_EXTENSION, + name, + interfaces, + directives, + fields, + loc: this.loc(start) + }; + }; + _proto.parseInterfaceTypeExtension = function parseInterfaceTypeExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("interface"); + var name = this.parseName(); + var interfaces = this.parseImplementsInterfaces(); + var directives = this.parseDirectives(true); + var fields = this.parseFieldsDefinition(); + if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.INTERFACE_TYPE_EXTENSION, + name, + interfaces, + directives, + fields, + loc: this.loc(start) + }; + }; + _proto.parseUnionTypeExtension = function parseUnionTypeExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("union"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + var types = this.parseUnionMemberTypes(); + if (directives.length === 0 && types.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.UNION_TYPE_EXTENSION, + name, + directives, + types, + loc: this.loc(start) + }; + }; + _proto.parseEnumTypeExtension = function parseEnumTypeExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("enum"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + var values = this.parseEnumValuesDefinition(); + if (directives.length === 0 && values.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.ENUM_TYPE_EXTENSION, + name, + directives, + values, + loc: this.loc(start) + }; + }; + _proto.parseInputObjectTypeExtension = function parseInputObjectTypeExtension() { + var start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("input"); + var name = this.parseName(); + var directives = this.parseDirectives(true); + var fields = this.parseInputFieldsDefinition(); + if (directives.length === 0 && fields.length === 0) { + throw this.unexpected(); + } + return { + kind: _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION, + name, + directives, + fields, + loc: this.loc(start) + }; + }; + _proto.parseDirectiveDefinition = function parseDirectiveDefinition() { + var start = this._lexer.token; + var description = this.parseDescription(); + this.expectKeyword("directive"); + this.expectToken(_tokenKind.TokenKind.AT); + var name = this.parseName(); + var args = this.parseArgumentDefs(); + var repeatable = this.expectOptionalKeyword("repeatable"); + this.expectKeyword("on"); + var locations = this.parseDirectiveLocations(); + return { + kind: _kinds.Kind.DIRECTIVE_DEFINITION, + description, + name, + arguments: args, + repeatable, + locations, + loc: this.loc(start) + }; + }; + _proto.parseDirectiveLocations = function parseDirectiveLocations() { + return this.delimitedMany(_tokenKind.TokenKind.PIPE, this.parseDirectiveLocation); + }; + _proto.parseDirectiveLocation = function parseDirectiveLocation() { + var start = this._lexer.token; + var name = this.parseName(); + if (_directiveLocation.DirectiveLocation[name.value] !== void 0) { + return name; + } + throw this.unexpected(start); + }; + _proto.loc = function loc(startToken) { + var _this$_options4; + if (((_this$_options4 = this._options) === null || _this$_options4 === void 0 ? void 0 : _this$_options4.noLocation) !== true) { + return new _ast.Location(startToken, this._lexer.lastToken, this._lexer.source); + } + }; + _proto.peek = function peek(kind) { + return this._lexer.token.kind === kind; + }; + _proto.expectToken = function expectToken(kind) { + var token = this._lexer.token; + if (token.kind === kind) { + this._lexer.advance(); + return token; + } + throw (0, _syntaxError.syntaxError)(this._lexer.source, token.start, "Expected ".concat(getTokenKindDesc(kind), ", found ").concat(getTokenDesc(token), ".")); + }; + _proto.expectOptionalToken = function expectOptionalToken(kind) { + var token = this._lexer.token; + if (token.kind === kind) { + this._lexer.advance(); + return token; + } + return void 0; + }; + _proto.expectKeyword = function expectKeyword(value) { + var token = this._lexer.token; + if (token.kind === _tokenKind.TokenKind.NAME && token.value === value) { + this._lexer.advance(); + } else { + throw (0, _syntaxError.syntaxError)(this._lexer.source, token.start, 'Expected "'.concat(value, '", found ').concat(getTokenDesc(token), ".")); + } + }; + _proto.expectOptionalKeyword = function expectOptionalKeyword(value) { + var token = this._lexer.token; + if (token.kind === _tokenKind.TokenKind.NAME && token.value === value) { + this._lexer.advance(); + return true; + } + return false; + }; + _proto.unexpected = function unexpected(atToken) { + var token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token; + return (0, _syntaxError.syntaxError)(this._lexer.source, token.start, "Unexpected ".concat(getTokenDesc(token), ".")); + }; + _proto.any = function any(openKind, parseFn, closeKind) { + this.expectToken(openKind); + var nodes = []; + while (!this.expectOptionalToken(closeKind)) { + nodes.push(parseFn.call(this)); + } + return nodes; + }; + _proto.optionalMany = function optionalMany(openKind, parseFn, closeKind) { + if (this.expectOptionalToken(openKind)) { + var nodes = []; + do { + nodes.push(parseFn.call(this)); + } while (!this.expectOptionalToken(closeKind)); + return nodes; + } + return []; + }; + _proto.many = function many(openKind, parseFn, closeKind) { + this.expectToken(openKind); + var nodes = []; + do { + nodes.push(parseFn.call(this)); + } while (!this.expectOptionalToken(closeKind)); + return nodes; + }; + _proto.delimitedMany = function delimitedMany(delimiterKind, parseFn) { + this.expectOptionalToken(delimiterKind); + var nodes = []; + do { + nodes.push(parseFn.call(this)); + } while (this.expectOptionalToken(delimiterKind)); + return nodes; + }; + return Parser2; + }(); + exports2.Parser = Parser; + function getTokenDesc(token) { + var value = token.value; + return getTokenKindDesc(token.kind) + (value != null ? ' "'.concat(value, '"') : ""); + } + function getTokenKindDesc(kind) { + return (0, _lexer.isPunctuatorTokenKind)(kind) ? '"'.concat(kind, '"') : kind; + } + } +}); + +// node_modules/graphql/language/visitor.js +var require_visitor = __commonJS({ + "node_modules/graphql/language/visitor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.visit = visit; + exports2.visitInParallel = visitInParallel; + exports2.getVisitFn = getVisitFn; + exports2.BREAK = exports2.QueryDocumentKeys = void 0; + var _inspect = _interopRequireDefault(require_inspect()); + var _ast = require_ast(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var QueryDocumentKeys = { + Name: [], + Document: ["definitions"], + OperationDefinition: ["name", "variableDefinitions", "directives", "selectionSet"], + VariableDefinition: ["variable", "type", "defaultValue", "directives"], + Variable: ["name"], + SelectionSet: ["selections"], + Field: ["alias", "name", "arguments", "directives", "selectionSet"], + Argument: ["name", "value"], + FragmentSpread: ["name", "directives"], + InlineFragment: ["typeCondition", "directives", "selectionSet"], + FragmentDefinition: [ + "name", + "variableDefinitions", + "typeCondition", + "directives", + "selectionSet" + ], + IntValue: [], + FloatValue: [], + StringValue: [], + BooleanValue: [], + NullValue: [], + EnumValue: [], + ListValue: ["values"], + ObjectValue: ["fields"], + ObjectField: ["name", "value"], + Directive: ["name", "arguments"], + NamedType: ["name"], + ListType: ["type"], + NonNullType: ["type"], + SchemaDefinition: ["description", "directives", "operationTypes"], + OperationTypeDefinition: ["type"], + ScalarTypeDefinition: ["description", "name", "directives"], + ObjectTypeDefinition: ["description", "name", "interfaces", "directives", "fields"], + FieldDefinition: ["description", "name", "arguments", "type", "directives"], + InputValueDefinition: ["description", "name", "type", "defaultValue", "directives"], + InterfaceTypeDefinition: ["description", "name", "interfaces", "directives", "fields"], + UnionTypeDefinition: ["description", "name", "directives", "types"], + EnumTypeDefinition: ["description", "name", "directives", "values"], + EnumValueDefinition: ["description", "name", "directives"], + InputObjectTypeDefinition: ["description", "name", "directives", "fields"], + DirectiveDefinition: ["description", "name", "arguments", "locations"], + SchemaExtension: ["directives", "operationTypes"], + ScalarTypeExtension: ["name", "directives"], + ObjectTypeExtension: ["name", "interfaces", "directives", "fields"], + InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"], + UnionTypeExtension: ["name", "directives", "types"], + EnumTypeExtension: ["name", "directives", "values"], + InputObjectTypeExtension: ["name", "directives", "fields"] + }; + exports2.QueryDocumentKeys = QueryDocumentKeys; + var BREAK = Object.freeze({}); + exports2.BREAK = BREAK; + function visit(root, visitor) { + var visitorKeys = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : QueryDocumentKeys; + var stack = void 0; + var inArray = Array.isArray(root); + var keys = [root]; + var index = -1; + var edits = []; + var node = void 0; + var key = void 0; + var parent = void 0; + var path = []; + var ancestors = []; + var newRoot = root; + do { + index++; + var isLeaving = index === keys.length; + var isEdited = isLeaving && edits.length !== 0; + if (isLeaving) { + key = ancestors.length === 0 ? void 0 : path[path.length - 1]; + node = parent; + parent = ancestors.pop(); + if (isEdited) { + if (inArray) { + node = node.slice(); + } else { + var clone = {}; + for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) { + var k = _Object$keys2[_i2]; + clone[k] = node[k]; + } + node = clone; + } + var editOffset = 0; + for (var ii = 0; ii < edits.length; ii++) { + var editKey = edits[ii][0]; + var editValue = edits[ii][1]; + if (inArray) { + editKey -= editOffset; + } + if (inArray && editValue === null) { + node.splice(editKey, 1); + editOffset++; + } else { + node[editKey] = editValue; + } + } + } + index = stack.index; + keys = stack.keys; + edits = stack.edits; + inArray = stack.inArray; + stack = stack.prev; + } else { + key = parent ? inArray ? index : keys[index] : void 0; + node = parent ? parent[key] : newRoot; + if (node === null || node === void 0) { + continue; + } + if (parent) { + path.push(key); + } + } + var result = void 0; + if (!Array.isArray(node)) { + if (!(0, _ast.isNode)(node)) { + throw new Error("Invalid AST Node: ".concat((0, _inspect.default)(node), ".")); + } + var visitFn = getVisitFn(visitor, node.kind, isLeaving); + if (visitFn) { + result = visitFn.call(visitor, node, key, parent, path, ancestors); + if (result === BREAK) { + break; + } + if (result === false) { + if (!isLeaving) { + path.pop(); + continue; + } + } else if (result !== void 0) { + edits.push([key, result]); + if (!isLeaving) { + if ((0, _ast.isNode)(result)) { + node = result; + } else { + path.pop(); + continue; + } + } + } + } + } + if (result === void 0 && isEdited) { + edits.push([key, node]); + } + if (isLeaving) { + path.pop(); + } else { + var _visitorKeys$node$kin; + stack = { + inArray, + index, + keys, + edits, + prev: stack + }; + inArray = Array.isArray(node); + keys = inArray ? node : (_visitorKeys$node$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : []; + index = -1; + edits = []; + if (parent) { + ancestors.push(parent); + } + parent = node; + } + } while (stack !== void 0); + if (edits.length !== 0) { + newRoot = edits[edits.length - 1][1]; + } + return newRoot; + } + function visitInParallel(visitors) { + var skipping = new Array(visitors.length); + return { + enter: function enter(node) { + for (var i = 0; i < visitors.length; i++) { + if (skipping[i] == null) { + var fn = getVisitFn(visitors[i], node.kind, false); + if (fn) { + var result = fn.apply(visitors[i], arguments); + if (result === false) { + skipping[i] = node; + } else if (result === BREAK) { + skipping[i] = BREAK; + } else if (result !== void 0) { + return result; + } + } + } + } + }, + leave: function leave(node) { + for (var i = 0; i < visitors.length; i++) { + if (skipping[i] == null) { + var fn = getVisitFn(visitors[i], node.kind, true); + if (fn) { + var result = fn.apply(visitors[i], arguments); + if (result === BREAK) { + skipping[i] = BREAK; + } else if (result !== void 0 && result !== false) { + return result; + } + } + } else if (skipping[i] === node) { + skipping[i] = null; + } + } + } + }; + } + function getVisitFn(visitor, kind, isLeaving) { + var kindVisitor = visitor[kind]; + if (kindVisitor) { + if (!isLeaving && typeof kindVisitor === "function") { + return kindVisitor; + } + var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter; + if (typeof kindSpecificVisitor === "function") { + return kindSpecificVisitor; + } + } else { + var specificVisitor = isLeaving ? visitor.leave : visitor.enter; + if (specificVisitor) { + if (typeof specificVisitor === "function") { + return specificVisitor; + } + var specificKindVisitor = specificVisitor[kind]; + if (typeof specificKindVisitor === "function") { + return specificKindVisitor; + } + } + } + } + } +}); + +// node_modules/graphql/polyfills/find.js +var require_find = __commonJS({ + "node_modules/graphql/polyfills/find.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var find = Array.prototype.find ? function(list, predicate) { + return Array.prototype.find.call(list, predicate); + } : function(list, predicate) { + for (var _i2 = 0; _i2 < list.length; _i2++) { + var value = list[_i2]; + if (predicate(value)) { + return value; + } + } + }; + var _default = find; + exports2.default = _default; + } +}); + +// node_modules/graphql/polyfills/objectValues.js +var require_objectValues = __commonJS({ + "node_modules/graphql/polyfills/objectValues.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var objectValues = Object.values || function(obj) { + return Object.keys(obj).map(function(key) { + return obj[key]; + }); + }; + var _default = objectValues; + exports2.default = _default; + } +}); + +// node_modules/graphql/error/locatedError.js +var require_locatedError = __commonJS({ + "node_modules/graphql/error/locatedError.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.locatedError = locatedError; + var _inspect = _interopRequireDefault(require_inspect()); + var _GraphQLError = require_GraphQLError(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function locatedError(rawOriginalError, nodes, path) { + var _nodes; + var originalError = rawOriginalError instanceof Error ? rawOriginalError : new Error("Unexpected error value: " + (0, _inspect.default)(rawOriginalError)); + if (Array.isArray(originalError.path)) { + return originalError; + } + return new _GraphQLError.GraphQLError(originalError.message, (_nodes = originalError.nodes) !== null && _nodes !== void 0 ? _nodes : nodes, originalError.source, originalError.positions, path, originalError); + } + } +}); + +// node_modules/graphql/utilities/assertValidName.js +var require_assertValidName = __commonJS({ + "node_modules/graphql/utilities/assertValidName.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.assertValidName = assertValidName; + exports2.isValidNameError = isValidNameError; + var _devAssert = _interopRequireDefault(require_devAssert()); + var _GraphQLError = require_GraphQLError(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/; + function assertValidName(name) { + var error = isValidNameError(name); + if (error) { + throw error; + } + return name; + } + function isValidNameError(name) { + typeof name === "string" || (0, _devAssert.default)(0, "Expected name to be a string."); + if (name.length > 1 && name[0] === "_" && name[1] === "_") { + return new _GraphQLError.GraphQLError('Name "'.concat(name, '" must not begin with "__", which is reserved by GraphQL introspection.')); + } + if (!NAME_RX.test(name)) { + return new _GraphQLError.GraphQLError('Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "'.concat(name, '" does not.')); + } + } + } +}); + +// node_modules/graphql/polyfills/objectEntries.js +var require_objectEntries = __commonJS({ + "node_modules/graphql/polyfills/objectEntries.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var objectEntries = Object.entries || function(obj) { + return Object.keys(obj).map(function(key) { + return [key, obj[key]]; + }); + }; + var _default = objectEntries; + exports2.default = _default; + } +}); + +// node_modules/graphql/jsutils/keyMap.js +var require_keyMap = __commonJS({ + "node_modules/graphql/jsutils/keyMap.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = keyMap; + function keyMap(list, keyFn) { + return list.reduce(function(map, item) { + map[keyFn(item)] = item; + return map; + }, Object.create(null)); + } + } +}); + +// node_modules/graphql/jsutils/mapValue.js +var require_mapValue = __commonJS({ + "node_modules/graphql/jsutils/mapValue.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = mapValue; + var _objectEntries3 = _interopRequireDefault(require_objectEntries()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function mapValue(map, fn) { + var result = Object.create(null); + for (var _i2 = 0, _objectEntries2 = (0, _objectEntries3.default)(map); _i2 < _objectEntries2.length; _i2++) { + var _ref2 = _objectEntries2[_i2]; + var _key = _ref2[0]; + var _value = _ref2[1]; + result[_key] = fn(_value, _key); + } + return result; + } + } +}); + +// node_modules/graphql/jsutils/toObjMap.js +var require_toObjMap = __commonJS({ + "node_modules/graphql/jsutils/toObjMap.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = toObjMap; + var _objectEntries3 = _interopRequireDefault(require_objectEntries()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function toObjMap(obj) { + if (Object.getPrototypeOf(obj) === null) { + return obj; + } + var map = Object.create(null); + for (var _i2 = 0, _objectEntries2 = (0, _objectEntries3.default)(obj); _i2 < _objectEntries2.length; _i2++) { + var _ref2 = _objectEntries2[_i2]; + var key = _ref2[0]; + var value = _ref2[1]; + map[key] = value; + } + return map; + } + } +}); + +// node_modules/graphql/jsutils/keyValMap.js +var require_keyValMap = __commonJS({ + "node_modules/graphql/jsutils/keyValMap.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = keyValMap; + function keyValMap(list, keyFn, valFn) { + return list.reduce(function(map, item) { + map[keyFn(item)] = valFn(item); + return map; + }, Object.create(null)); + } + } +}); + +// node_modules/graphql/jsutils/didYouMean.js +var require_didYouMean = __commonJS({ + "node_modules/graphql/jsutils/didYouMean.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = didYouMean; + var MAX_SUGGESTIONS = 5; + function didYouMean(firstArg, secondArg) { + var _ref = typeof firstArg === "string" ? [firstArg, secondArg] : [void 0, firstArg], subMessage = _ref[0], suggestionsArg = _ref[1]; + var message = " Did you mean "; + if (subMessage) { + message += subMessage + " "; + } + var suggestions = suggestionsArg.map(function(x) { + return '"'.concat(x, '"'); + }); + switch (suggestions.length) { + case 0: + return ""; + case 1: + return message + suggestions[0] + "?"; + case 2: + return message + suggestions[0] + " or " + suggestions[1] + "?"; + } + var selected = suggestions.slice(0, MAX_SUGGESTIONS); + var lastItem = selected.pop(); + return message + selected.join(", ") + ", or " + lastItem + "?"; + } + } +}); + +// node_modules/graphql/jsutils/identityFunc.js +var require_identityFunc = __commonJS({ + "node_modules/graphql/jsutils/identityFunc.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = identityFunc; + function identityFunc(x) { + return x; + } + } +}); + +// node_modules/graphql/jsutils/naturalCompare.js +var require_naturalCompare = __commonJS({ + "node_modules/graphql/jsutils/naturalCompare.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = naturalCompare; + function naturalCompare(aStr, bStr) { + var aIdx = 0; + var bIdx = 0; + while (aIdx < aStr.length && bIdx < bStr.length) { + var aChar = aStr.charCodeAt(aIdx); + var bChar = bStr.charCodeAt(bIdx); + if (isDigit(aChar) && isDigit(bChar)) { + var aNum = 0; + do { + ++aIdx; + aNum = aNum * 10 + aChar - DIGIT_0; + aChar = aStr.charCodeAt(aIdx); + } while (isDigit(aChar) && aNum > 0); + var bNum = 0; + do { + ++bIdx; + bNum = bNum * 10 + bChar - DIGIT_0; + bChar = bStr.charCodeAt(bIdx); + } while (isDigit(bChar) && bNum > 0); + if (aNum < bNum) { + return -1; + } + if (aNum > bNum) { + return 1; + } + } else { + if (aChar < bChar) { + return -1; + } + if (aChar > bChar) { + return 1; + } + ++aIdx; + ++bIdx; + } + } + return aStr.length - bStr.length; + } + var DIGIT_0 = 48; + var DIGIT_9 = 57; + function isDigit(code) { + return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9; + } + } +}); + +// node_modules/graphql/jsutils/suggestionList.js +var require_suggestionList = __commonJS({ + "node_modules/graphql/jsutils/suggestionList.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = suggestionList; + var _naturalCompare = _interopRequireDefault(require_naturalCompare()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function suggestionList(input, options) { + var optionsByDistance = Object.create(null); + var lexicalDistance = new LexicalDistance(input); + var threshold = Math.floor(input.length * 0.4) + 1; + for (var _i2 = 0; _i2 < options.length; _i2++) { + var option = options[_i2]; + var distance = lexicalDistance.measure(option, threshold); + if (distance !== void 0) { + optionsByDistance[option] = distance; + } + } + return Object.keys(optionsByDistance).sort(function(a, b) { + var distanceDiff = optionsByDistance[a] - optionsByDistance[b]; + return distanceDiff !== 0 ? distanceDiff : (0, _naturalCompare.default)(a, b); + }); + } + var LexicalDistance = /* @__PURE__ */ function() { + function LexicalDistance2(input) { + this._input = input; + this._inputLowerCase = input.toLowerCase(); + this._inputArray = stringToArray(this._inputLowerCase); + this._rows = [new Array(input.length + 1).fill(0), new Array(input.length + 1).fill(0), new Array(input.length + 1).fill(0)]; + } + var _proto = LexicalDistance2.prototype; + _proto.measure = function measure(option, threshold) { + if (this._input === option) { + return 0; + } + var optionLowerCase = option.toLowerCase(); + if (this._inputLowerCase === optionLowerCase) { + return 1; + } + var a = stringToArray(optionLowerCase); + var b = this._inputArray; + if (a.length < b.length) { + var tmp = a; + a = b; + b = tmp; + } + var aLength = a.length; + var bLength = b.length; + if (aLength - bLength > threshold) { + return void 0; + } + var rows = this._rows; + for (var j = 0; j <= bLength; j++) { + rows[0][j] = j; + } + for (var i = 1; i <= aLength; i++) { + var upRow = rows[(i - 1) % 3]; + var currentRow = rows[i % 3]; + var smallestCell = currentRow[0] = i; + for (var _j = 1; _j <= bLength; _j++) { + var cost = a[i - 1] === b[_j - 1] ? 0 : 1; + var currentCell = Math.min(upRow[_j] + 1, currentRow[_j - 1] + 1, upRow[_j - 1] + cost); + if (i > 1 && _j > 1 && a[i - 1] === b[_j - 2] && a[i - 2] === b[_j - 1]) { + var doubleDiagonalCell = rows[(i - 2) % 3][_j - 2]; + currentCell = Math.min(currentCell, doubleDiagonalCell + 1); + } + if (currentCell < smallestCell) { + smallestCell = currentCell; + } + currentRow[_j] = currentCell; + } + if (smallestCell > threshold) { + return void 0; + } + } + var distance = rows[aLength % 3][bLength]; + return distance <= threshold ? distance : void 0; + }; + return LexicalDistance2; + }(); + function stringToArray(str) { + var strLength = str.length; + var array = new Array(strLength); + for (var i = 0; i < strLength; ++i) { + array[i] = str.charCodeAt(i); + } + return array; + } + } +}); + +// node_modules/graphql/language/printer.js +var require_printer = __commonJS({ + "node_modules/graphql/language/printer.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.print = print; + var _visitor = require_visitor(); + var _blockString = require_blockString(); + function print(ast) { + return (0, _visitor.visit)(ast, { + leave: printDocASTReducer + }); + } + var MAX_LINE_LENGTH = 80; + var printDocASTReducer = { + Name: function Name(node) { + return node.value; + }, + Variable: function Variable(node) { + return "$" + node.name; + }, + Document: function Document(node) { + return join2(node.definitions, "\n\n") + "\n"; + }, + OperationDefinition: function OperationDefinition(node) { + var op = node.operation; + var name = node.name; + var varDefs = wrap("(", join2(node.variableDefinitions, ", "), ")"); + var directives = join2(node.directives, " "); + var selectionSet = node.selectionSet; + return !name && !directives && !varDefs && op === "query" ? selectionSet : join2([op, join2([name, varDefs]), directives, selectionSet], " "); + }, + VariableDefinition: function VariableDefinition(_ref) { + var variable = _ref.variable, type = _ref.type, defaultValue = _ref.defaultValue, directives = _ref.directives; + return variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join2(directives, " ")); + }, + SelectionSet: function SelectionSet(_ref2) { + var selections = _ref2.selections; + return block(selections); + }, + Field: function Field(_ref3) { + var alias = _ref3.alias, name = _ref3.name, args = _ref3.arguments, directives = _ref3.directives, selectionSet = _ref3.selectionSet; + var prefix = wrap("", alias, ": ") + name; + var argsLine = prefix + wrap("(", join2(args, ", "), ")"); + if (argsLine.length > MAX_LINE_LENGTH) { + argsLine = prefix + wrap("(\n", indent(join2(args, "\n")), "\n)"); + } + return join2([argsLine, join2(directives, " "), selectionSet], " "); + }, + Argument: function Argument(_ref4) { + var name = _ref4.name, value = _ref4.value; + return name + ": " + value; + }, + FragmentSpread: function FragmentSpread(_ref5) { + var name = _ref5.name, directives = _ref5.directives; + return "..." + name + wrap(" ", join2(directives, " ")); + }, + InlineFragment: function InlineFragment(_ref6) { + var typeCondition = _ref6.typeCondition, directives = _ref6.directives, selectionSet = _ref6.selectionSet; + return join2(["...", wrap("on ", typeCondition), join2(directives, " "), selectionSet], " "); + }, + FragmentDefinition: function FragmentDefinition(_ref7) { + var name = _ref7.name, typeCondition = _ref7.typeCondition, variableDefinitions = _ref7.variableDefinitions, directives = _ref7.directives, selectionSet = _ref7.selectionSet; + return "fragment ".concat(name).concat(wrap("(", join2(variableDefinitions, ", "), ")"), " ") + "on ".concat(typeCondition, " ").concat(wrap("", join2(directives, " "), " ")) + selectionSet; + }, + IntValue: function IntValue(_ref8) { + var value = _ref8.value; + return value; + }, + FloatValue: function FloatValue(_ref9) { + var value = _ref9.value; + return value; + }, + StringValue: function StringValue(_ref10, key) { + var value = _ref10.value, isBlockString = _ref10.block; + return isBlockString ? (0, _blockString.printBlockString)(value, key === "description" ? "" : " ") : JSON.stringify(value); + }, + BooleanValue: function BooleanValue(_ref11) { + var value = _ref11.value; + return value ? "true" : "false"; + }, + NullValue: function NullValue() { + return "null"; + }, + EnumValue: function EnumValue(_ref12) { + var value = _ref12.value; + return value; + }, + ListValue: function ListValue(_ref13) { + var values = _ref13.values; + return "[" + join2(values, ", ") + "]"; + }, + ObjectValue: function ObjectValue(_ref14) { + var fields = _ref14.fields; + return "{" + join2(fields, ", ") + "}"; + }, + ObjectField: function ObjectField(_ref15) { + var name = _ref15.name, value = _ref15.value; + return name + ": " + value; + }, + Directive: function Directive(_ref16) { + var name = _ref16.name, args = _ref16.arguments; + return "@" + name + wrap("(", join2(args, ", "), ")"); + }, + NamedType: function NamedType(_ref17) { + var name = _ref17.name; + return name; + }, + ListType: function ListType(_ref18) { + var type = _ref18.type; + return "[" + type + "]"; + }, + NonNullType: function NonNullType(_ref19) { + var type = _ref19.type; + return type + "!"; + }, + SchemaDefinition: addDescription(function(_ref20) { + var directives = _ref20.directives, operationTypes = _ref20.operationTypes; + return join2(["schema", join2(directives, " "), block(operationTypes)], " "); + }), + OperationTypeDefinition: function OperationTypeDefinition(_ref21) { + var operation = _ref21.operation, type = _ref21.type; + return operation + ": " + type; + }, + ScalarTypeDefinition: addDescription(function(_ref22) { + var name = _ref22.name, directives = _ref22.directives; + return join2(["scalar", name, join2(directives, " ")], " "); + }), + ObjectTypeDefinition: addDescription(function(_ref23) { + var name = _ref23.name, interfaces = _ref23.interfaces, directives = _ref23.directives, fields = _ref23.fields; + return join2(["type", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " "); + }), + FieldDefinition: addDescription(function(_ref24) { + var name = _ref24.name, args = _ref24.arguments, type = _ref24.type, directives = _ref24.directives; + return name + (hasMultilineItems(args) ? wrap("(\n", indent(join2(args, "\n")), "\n)") : wrap("(", join2(args, ", "), ")")) + ": " + type + wrap(" ", join2(directives, " ")); + }), + InputValueDefinition: addDescription(function(_ref25) { + var name = _ref25.name, type = _ref25.type, defaultValue = _ref25.defaultValue, directives = _ref25.directives; + return join2([name + ": " + type, wrap("= ", defaultValue), join2(directives, " ")], " "); + }), + InterfaceTypeDefinition: addDescription(function(_ref26) { + var name = _ref26.name, interfaces = _ref26.interfaces, directives = _ref26.directives, fields = _ref26.fields; + return join2(["interface", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " "); + }), + UnionTypeDefinition: addDescription(function(_ref27) { + var name = _ref27.name, directives = _ref27.directives, types = _ref27.types; + return join2(["union", name, join2(directives, " "), types && types.length !== 0 ? "= " + join2(types, " | ") : ""], " "); + }), + EnumTypeDefinition: addDescription(function(_ref28) { + var name = _ref28.name, directives = _ref28.directives, values = _ref28.values; + return join2(["enum", name, join2(directives, " "), block(values)], " "); + }), + EnumValueDefinition: addDescription(function(_ref29) { + var name = _ref29.name, directives = _ref29.directives; + return join2([name, join2(directives, " ")], " "); + }), + InputObjectTypeDefinition: addDescription(function(_ref30) { + var name = _ref30.name, directives = _ref30.directives, fields = _ref30.fields; + return join2(["input", name, join2(directives, " "), block(fields)], " "); + }), + DirectiveDefinition: addDescription(function(_ref31) { + var name = _ref31.name, args = _ref31.arguments, repeatable = _ref31.repeatable, locations = _ref31.locations; + return "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join2(args, "\n")), "\n)") : wrap("(", join2(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join2(locations, " | "); + }), + SchemaExtension: function SchemaExtension(_ref32) { + var directives = _ref32.directives, operationTypes = _ref32.operationTypes; + return join2(["extend schema", join2(directives, " "), block(operationTypes)], " "); + }, + ScalarTypeExtension: function ScalarTypeExtension(_ref33) { + var name = _ref33.name, directives = _ref33.directives; + return join2(["extend scalar", name, join2(directives, " ")], " "); + }, + ObjectTypeExtension: function ObjectTypeExtension(_ref34) { + var name = _ref34.name, interfaces = _ref34.interfaces, directives = _ref34.directives, fields = _ref34.fields; + return join2(["extend type", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " "); + }, + InterfaceTypeExtension: function InterfaceTypeExtension(_ref35) { + var name = _ref35.name, interfaces = _ref35.interfaces, directives = _ref35.directives, fields = _ref35.fields; + return join2(["extend interface", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " "); + }, + UnionTypeExtension: function UnionTypeExtension(_ref36) { + var name = _ref36.name, directives = _ref36.directives, types = _ref36.types; + return join2(["extend union", name, join2(directives, " "), types && types.length !== 0 ? "= " + join2(types, " | ") : ""], " "); + }, + EnumTypeExtension: function EnumTypeExtension(_ref37) { + var name = _ref37.name, directives = _ref37.directives, values = _ref37.values; + return join2(["extend enum", name, join2(directives, " "), block(values)], " "); + }, + InputObjectTypeExtension: function InputObjectTypeExtension(_ref38) { + var name = _ref38.name, directives = _ref38.directives, fields = _ref38.fields; + return join2(["extend input", name, join2(directives, " "), block(fields)], " "); + } + }; + function addDescription(cb) { + return function(node) { + return join2([node.description, cb(node)], "\n"); + }; + } + function join2(maybeArray) { + var _maybeArray$filter$jo; + var separator = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ""; + return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter(function(x) { + return x; + }).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : ""; + } + function block(array) { + return wrap("{\n", indent(join2(array, "\n")), "\n}"); + } + function wrap(start, maybeString) { + var end = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + return maybeString != null && maybeString !== "" ? start + maybeString + end : ""; + } + function indent(str) { + return wrap(" ", str.replace(/\n/g, "\n ")); + } + function isMultiline(str) { + return str.indexOf("\n") !== -1; + } + function hasMultilineItems(maybeArray) { + return maybeArray != null && maybeArray.some(isMultiline); + } + } +}); + +// node_modules/graphql/utilities/valueFromASTUntyped.js +var require_valueFromASTUntyped = __commonJS({ + "node_modules/graphql/utilities/valueFromASTUntyped.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.valueFromASTUntyped = valueFromASTUntyped; + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _keyValMap = _interopRequireDefault(require_keyValMap()); + var _kinds = require_kinds(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function valueFromASTUntyped(valueNode, variables) { + switch (valueNode.kind) { + case _kinds.Kind.NULL: + return null; + case _kinds.Kind.INT: + return parseInt(valueNode.value, 10); + case _kinds.Kind.FLOAT: + return parseFloat(valueNode.value); + case _kinds.Kind.STRING: + case _kinds.Kind.ENUM: + case _kinds.Kind.BOOLEAN: + return valueNode.value; + case _kinds.Kind.LIST: + return valueNode.values.map(function(node) { + return valueFromASTUntyped(node, variables); + }); + case _kinds.Kind.OBJECT: + return (0, _keyValMap.default)(valueNode.fields, function(field) { + return field.name.value; + }, function(field) { + return valueFromASTUntyped(field.value, variables); + }); + case _kinds.Kind.VARIABLE: + return variables === null || variables === void 0 ? void 0 : variables[valueNode.name.value]; + } + (0, _invariant.default)(0, "Unexpected value node: " + (0, _inspect.default)(valueNode)); + } + } +}); + +// node_modules/graphql/type/definition.js +var require_definition = __commonJS({ + "node_modules/graphql/type/definition.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isType = isType; + exports2.assertType = assertType; + exports2.isScalarType = isScalarType; + exports2.assertScalarType = assertScalarType; + exports2.isObjectType = isObjectType; + exports2.assertObjectType = assertObjectType; + exports2.isInterfaceType = isInterfaceType; + exports2.assertInterfaceType = assertInterfaceType; + exports2.isUnionType = isUnionType; + exports2.assertUnionType = assertUnionType; + exports2.isEnumType = isEnumType; + exports2.assertEnumType = assertEnumType; + exports2.isInputObjectType = isInputObjectType; + exports2.assertInputObjectType = assertInputObjectType; + exports2.isListType = isListType; + exports2.assertListType = assertListType; + exports2.isNonNullType = isNonNullType; + exports2.assertNonNullType = assertNonNullType; + exports2.isInputType = isInputType; + exports2.assertInputType = assertInputType; + exports2.isOutputType = isOutputType; + exports2.assertOutputType = assertOutputType; + exports2.isLeafType = isLeafType; + exports2.assertLeafType = assertLeafType; + exports2.isCompositeType = isCompositeType; + exports2.assertCompositeType = assertCompositeType; + exports2.isAbstractType = isAbstractType; + exports2.assertAbstractType = assertAbstractType; + exports2.GraphQLList = GraphQLList; + exports2.GraphQLNonNull = GraphQLNonNull; + exports2.isWrappingType = isWrappingType; + exports2.assertWrappingType = assertWrappingType; + exports2.isNullableType = isNullableType; + exports2.assertNullableType = assertNullableType; + exports2.getNullableType = getNullableType; + exports2.isNamedType = isNamedType; + exports2.assertNamedType = assertNamedType; + exports2.getNamedType = getNamedType; + exports2.argsToArgsConfig = argsToArgsConfig; + exports2.isRequiredArgument = isRequiredArgument; + exports2.isRequiredInputField = isRequiredInputField; + exports2.GraphQLInputObjectType = exports2.GraphQLEnumType = exports2.GraphQLUnionType = exports2.GraphQLInterfaceType = exports2.GraphQLObjectType = exports2.GraphQLScalarType = void 0; + var _objectEntries = _interopRequireDefault(require_objectEntries()); + var _symbols = require_symbols(); + var _inspect = _interopRequireDefault(require_inspect()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _mapValue = _interopRequireDefault(require_mapValue()); + var _toObjMap = _interopRequireDefault(require_toObjMap()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _keyValMap = _interopRequireDefault(require_keyValMap()); + var _instanceOf = _interopRequireDefault(require_instanceOf()); + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _identityFunc = _interopRequireDefault(require_identityFunc()); + var _defineInspect = _interopRequireDefault(require_defineInspect()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _printer = require_printer(); + var _valueFromASTUntyped = require_valueFromASTUntyped(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + function isType(type) { + return isScalarType(type) || isObjectType(type) || isInterfaceType(type) || isUnionType(type) || isEnumType(type) || isInputObjectType(type) || isListType(type) || isNonNullType(type); + } + function assertType(type) { + if (!isType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL type.")); + } + return type; + } + function isScalarType(type) { + return (0, _instanceOf.default)(type, GraphQLScalarType); + } + function assertScalarType(type) { + if (!isScalarType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Scalar type.")); + } + return type; + } + function isObjectType(type) { + return (0, _instanceOf.default)(type, GraphQLObjectType); + } + function assertObjectType(type) { + if (!isObjectType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Object type.")); + } + return type; + } + function isInterfaceType(type) { + return (0, _instanceOf.default)(type, GraphQLInterfaceType); + } + function assertInterfaceType(type) { + if (!isInterfaceType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Interface type.")); + } + return type; + } + function isUnionType(type) { + return (0, _instanceOf.default)(type, GraphQLUnionType); + } + function assertUnionType(type) { + if (!isUnionType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Union type.")); + } + return type; + } + function isEnumType(type) { + return (0, _instanceOf.default)(type, GraphQLEnumType); + } + function assertEnumType(type) { + if (!isEnumType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Enum type.")); + } + return type; + } + function isInputObjectType(type) { + return (0, _instanceOf.default)(type, GraphQLInputObjectType); + } + function assertInputObjectType(type) { + if (!isInputObjectType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Input Object type.")); + } + return type; + } + function isListType(type) { + return (0, _instanceOf.default)(type, GraphQLList); + } + function assertListType(type) { + if (!isListType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL List type.")); + } + return type; + } + function isNonNullType(type) { + return (0, _instanceOf.default)(type, GraphQLNonNull); + } + function assertNonNullType(type) { + if (!isNonNullType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Non-Null type.")); + } + return type; + } + function isInputType(type) { + return isScalarType(type) || isEnumType(type) || isInputObjectType(type) || isWrappingType(type) && isInputType(type.ofType); + } + function assertInputType(type) { + if (!isInputType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL input type.")); + } + return type; + } + function isOutputType(type) { + return isScalarType(type) || isObjectType(type) || isInterfaceType(type) || isUnionType(type) || isEnumType(type) || isWrappingType(type) && isOutputType(type.ofType); + } + function assertOutputType(type) { + if (!isOutputType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL output type.")); + } + return type; + } + function isLeafType(type) { + return isScalarType(type) || isEnumType(type); + } + function assertLeafType(type) { + if (!isLeafType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL leaf type.")); + } + return type; + } + function isCompositeType(type) { + return isObjectType(type) || isInterfaceType(type) || isUnionType(type); + } + function assertCompositeType(type) { + if (!isCompositeType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL composite type.")); + } + return type; + } + function isAbstractType(type) { + return isInterfaceType(type) || isUnionType(type); + } + function assertAbstractType(type) { + if (!isAbstractType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL abstract type.")); + } + return type; + } + function GraphQLList(ofType) { + if (this instanceof GraphQLList) { + this.ofType = assertType(ofType); + } else { + return new GraphQLList(ofType); + } + } + GraphQLList.prototype.toString = function toString() { + return "[" + String(this.ofType) + "]"; + }; + GraphQLList.prototype.toJSON = function toJSON() { + return this.toString(); + }; + Object.defineProperty(GraphQLList.prototype, _symbols.SYMBOL_TO_STRING_TAG, { + get: function get() { + return "GraphQLList"; + } + }); + (0, _defineInspect.default)(GraphQLList); + function GraphQLNonNull(ofType) { + if (this instanceof GraphQLNonNull) { + this.ofType = assertNullableType(ofType); + } else { + return new GraphQLNonNull(ofType); + } + } + GraphQLNonNull.prototype.toString = function toString() { + return String(this.ofType) + "!"; + }; + GraphQLNonNull.prototype.toJSON = function toJSON() { + return this.toString(); + }; + Object.defineProperty(GraphQLNonNull.prototype, _symbols.SYMBOL_TO_STRING_TAG, { + get: function get() { + return "GraphQLNonNull"; + } + }); + (0, _defineInspect.default)(GraphQLNonNull); + function isWrappingType(type) { + return isListType(type) || isNonNullType(type); + } + function assertWrappingType(type) { + if (!isWrappingType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL wrapping type.")); + } + return type; + } + function isNullableType(type) { + return isType(type) && !isNonNullType(type); + } + function assertNullableType(type) { + if (!isNullableType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL nullable type.")); + } + return type; + } + function getNullableType(type) { + if (type) { + return isNonNullType(type) ? type.ofType : type; + } + } + function isNamedType(type) { + return isScalarType(type) || isObjectType(type) || isInterfaceType(type) || isUnionType(type) || isEnumType(type) || isInputObjectType(type); + } + function assertNamedType(type) { + if (!isNamedType(type)) { + throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL named type.")); + } + return type; + } + function getNamedType(type) { + if (type) { + var unwrappedType = type; + while (isWrappingType(unwrappedType)) { + unwrappedType = unwrappedType.ofType; + } + return unwrappedType; + } + } + function resolveThunk(thunk) { + return typeof thunk === "function" ? thunk() : thunk; + } + function undefineIfEmpty(arr) { + return arr && arr.length > 0 ? arr : void 0; + } + var GraphQLScalarType = /* @__PURE__ */ function() { + function GraphQLScalarType2(config) { + var _config$parseValue, _config$serialize, _config$parseLiteral; + var parseValue = (_config$parseValue = config.parseValue) !== null && _config$parseValue !== void 0 ? _config$parseValue : _identityFunc.default; + this.name = config.name; + this.description = config.description; + this.specifiedByUrl = config.specifiedByUrl; + this.serialize = (_config$serialize = config.serialize) !== null && _config$serialize !== void 0 ? _config$serialize : _identityFunc.default; + this.parseValue = parseValue; + this.parseLiteral = (_config$parseLiteral = config.parseLiteral) !== null && _config$parseLiteral !== void 0 ? _config$parseLiteral : function(node, variables) { + return parseValue((0, _valueFromASTUntyped.valueFromASTUntyped)(node, variables)); + }; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes); + typeof config.name === "string" || (0, _devAssert.default)(0, "Must provide name."); + config.specifiedByUrl == null || typeof config.specifiedByUrl === "string" || (0, _devAssert.default)(0, "".concat(this.name, ' must provide "specifiedByUrl" as a string, ') + "but got: ".concat((0, _inspect.default)(config.specifiedByUrl), ".")); + config.serialize == null || typeof config.serialize === "function" || (0, _devAssert.default)(0, "".concat(this.name, ' must provide "serialize" function. If this custom Scalar is also used as an input type, ensure "parseValue" and "parseLiteral" functions are also provided.')); + if (config.parseLiteral) { + typeof config.parseValue === "function" && typeof config.parseLiteral === "function" || (0, _devAssert.default)(0, "".concat(this.name, ' must provide both "parseValue" and "parseLiteral" functions.')); + } + } + var _proto = GraphQLScalarType2.prototype; + _proto.toConfig = function toConfig() { + var _this$extensionASTNod; + return { + name: this.name, + description: this.description, + specifiedByUrl: this.specifiedByUrl, + serialize: this.serialize, + parseValue: this.parseValue, + parseLiteral: this.parseLiteral, + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: (_this$extensionASTNod = this.extensionASTNodes) !== null && _this$extensionASTNod !== void 0 ? _this$extensionASTNod : [] + }; + }; + _proto.toString = function toString() { + return this.name; + }; + _proto.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLScalarType2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLScalarType"; + } + }]); + return GraphQLScalarType2; + }(); + exports2.GraphQLScalarType = GraphQLScalarType; + (0, _defineInspect.default)(GraphQLScalarType); + var GraphQLObjectType = /* @__PURE__ */ function() { + function GraphQLObjectType2(config) { + this.name = config.name; + this.description = config.description; + this.isTypeOf = config.isTypeOf; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes); + this._fields = defineFieldMap.bind(void 0, config); + this._interfaces = defineInterfaces.bind(void 0, config); + typeof config.name === "string" || (0, _devAssert.default)(0, "Must provide name."); + config.isTypeOf == null || typeof config.isTypeOf === "function" || (0, _devAssert.default)(0, "".concat(this.name, ' must provide "isTypeOf" as a function, ') + "but got: ".concat((0, _inspect.default)(config.isTypeOf), ".")); + } + var _proto2 = GraphQLObjectType2.prototype; + _proto2.getFields = function getFields() { + if (typeof this._fields === "function") { + this._fields = this._fields(); + } + return this._fields; + }; + _proto2.getInterfaces = function getInterfaces() { + if (typeof this._interfaces === "function") { + this._interfaces = this._interfaces(); + } + return this._interfaces; + }; + _proto2.toConfig = function toConfig() { + return { + name: this.name, + description: this.description, + interfaces: this.getInterfaces(), + fields: fieldsToFieldsConfig(this.getFields()), + isTypeOf: this.isTypeOf, + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: this.extensionASTNodes || [] + }; + }; + _proto2.toString = function toString() { + return this.name; + }; + _proto2.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLObjectType2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLObjectType"; + } + }]); + return GraphQLObjectType2; + }(); + exports2.GraphQLObjectType = GraphQLObjectType; + (0, _defineInspect.default)(GraphQLObjectType); + function defineInterfaces(config) { + var _resolveThunk; + var interfaces = (_resolveThunk = resolveThunk(config.interfaces)) !== null && _resolveThunk !== void 0 ? _resolveThunk : []; + Array.isArray(interfaces) || (0, _devAssert.default)(0, "".concat(config.name, " interfaces must be an Array or a function which returns an Array.")); + return interfaces; + } + function defineFieldMap(config) { + var fieldMap = resolveThunk(config.fields); + isPlainObj(fieldMap) || (0, _devAssert.default)(0, "".concat(config.name, " fields must be an object with field names as keys or a function which returns such an object.")); + return (0, _mapValue.default)(fieldMap, function(fieldConfig, fieldName) { + var _fieldConfig$args; + isPlainObj(fieldConfig) || (0, _devAssert.default)(0, "".concat(config.name, ".").concat(fieldName, " field config must be an object.")); + !("isDeprecated" in fieldConfig) || (0, _devAssert.default)(0, "".concat(config.name, ".").concat(fieldName, ' should provide "deprecationReason" instead of "isDeprecated".')); + fieldConfig.resolve == null || typeof fieldConfig.resolve === "function" || (0, _devAssert.default)(0, "".concat(config.name, ".").concat(fieldName, " field resolver must be a function if ") + "provided, but got: ".concat((0, _inspect.default)(fieldConfig.resolve), ".")); + var argsConfig = (_fieldConfig$args = fieldConfig.args) !== null && _fieldConfig$args !== void 0 ? _fieldConfig$args : {}; + isPlainObj(argsConfig) || (0, _devAssert.default)(0, "".concat(config.name, ".").concat(fieldName, " args must be an object with argument names as keys.")); + var args = (0, _objectEntries.default)(argsConfig).map(function(_ref) { + var argName = _ref[0], argConfig = _ref[1]; + return { + name: argName, + description: argConfig.description, + type: argConfig.type, + defaultValue: argConfig.defaultValue, + deprecationReason: argConfig.deprecationReason, + extensions: argConfig.extensions && (0, _toObjMap.default)(argConfig.extensions), + astNode: argConfig.astNode + }; + }); + return { + name: fieldName, + description: fieldConfig.description, + type: fieldConfig.type, + args, + resolve: fieldConfig.resolve, + subscribe: fieldConfig.subscribe, + isDeprecated: fieldConfig.deprecationReason != null, + deprecationReason: fieldConfig.deprecationReason, + extensions: fieldConfig.extensions && (0, _toObjMap.default)(fieldConfig.extensions), + astNode: fieldConfig.astNode + }; + }); + } + function isPlainObj(obj) { + return (0, _isObjectLike.default)(obj) && !Array.isArray(obj); + } + function fieldsToFieldsConfig(fields) { + return (0, _mapValue.default)(fields, function(field) { + return { + description: field.description, + type: field.type, + args: argsToArgsConfig(field.args), + resolve: field.resolve, + subscribe: field.subscribe, + deprecationReason: field.deprecationReason, + extensions: field.extensions, + astNode: field.astNode + }; + }); + } + function argsToArgsConfig(args) { + return (0, _keyValMap.default)(args, function(arg) { + return arg.name; + }, function(arg) { + return { + description: arg.description, + type: arg.type, + defaultValue: arg.defaultValue, + deprecationReason: arg.deprecationReason, + extensions: arg.extensions, + astNode: arg.astNode + }; + }); + } + function isRequiredArgument(arg) { + return isNonNullType(arg.type) && arg.defaultValue === void 0; + } + var GraphQLInterfaceType = /* @__PURE__ */ function() { + function GraphQLInterfaceType2(config) { + this.name = config.name; + this.description = config.description; + this.resolveType = config.resolveType; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes); + this._fields = defineFieldMap.bind(void 0, config); + this._interfaces = defineInterfaces.bind(void 0, config); + typeof config.name === "string" || (0, _devAssert.default)(0, "Must provide name."); + config.resolveType == null || typeof config.resolveType === "function" || (0, _devAssert.default)(0, "".concat(this.name, ' must provide "resolveType" as a function, ') + "but got: ".concat((0, _inspect.default)(config.resolveType), ".")); + } + var _proto3 = GraphQLInterfaceType2.prototype; + _proto3.getFields = function getFields() { + if (typeof this._fields === "function") { + this._fields = this._fields(); + } + return this._fields; + }; + _proto3.getInterfaces = function getInterfaces() { + if (typeof this._interfaces === "function") { + this._interfaces = this._interfaces(); + } + return this._interfaces; + }; + _proto3.toConfig = function toConfig() { + var _this$extensionASTNod2; + return { + name: this.name, + description: this.description, + interfaces: this.getInterfaces(), + fields: fieldsToFieldsConfig(this.getFields()), + resolveType: this.resolveType, + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: (_this$extensionASTNod2 = this.extensionASTNodes) !== null && _this$extensionASTNod2 !== void 0 ? _this$extensionASTNod2 : [] + }; + }; + _proto3.toString = function toString() { + return this.name; + }; + _proto3.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLInterfaceType2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLInterfaceType"; + } + }]); + return GraphQLInterfaceType2; + }(); + exports2.GraphQLInterfaceType = GraphQLInterfaceType; + (0, _defineInspect.default)(GraphQLInterfaceType); + var GraphQLUnionType = /* @__PURE__ */ function() { + function GraphQLUnionType2(config) { + this.name = config.name; + this.description = config.description; + this.resolveType = config.resolveType; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes); + this._types = defineTypes.bind(void 0, config); + typeof config.name === "string" || (0, _devAssert.default)(0, "Must provide name."); + config.resolveType == null || typeof config.resolveType === "function" || (0, _devAssert.default)(0, "".concat(this.name, ' must provide "resolveType" as a function, ') + "but got: ".concat((0, _inspect.default)(config.resolveType), ".")); + } + var _proto4 = GraphQLUnionType2.prototype; + _proto4.getTypes = function getTypes() { + if (typeof this._types === "function") { + this._types = this._types(); + } + return this._types; + }; + _proto4.toConfig = function toConfig() { + var _this$extensionASTNod3; + return { + name: this.name, + description: this.description, + types: this.getTypes(), + resolveType: this.resolveType, + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: (_this$extensionASTNod3 = this.extensionASTNodes) !== null && _this$extensionASTNod3 !== void 0 ? _this$extensionASTNod3 : [] + }; + }; + _proto4.toString = function toString() { + return this.name; + }; + _proto4.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLUnionType2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLUnionType"; + } + }]); + return GraphQLUnionType2; + }(); + exports2.GraphQLUnionType = GraphQLUnionType; + (0, _defineInspect.default)(GraphQLUnionType); + function defineTypes(config) { + var types = resolveThunk(config.types); + Array.isArray(types) || (0, _devAssert.default)(0, "Must provide Array of types or a function which returns such an array for Union ".concat(config.name, ".")); + return types; + } + var GraphQLEnumType = /* @__PURE__ */ function() { + function GraphQLEnumType2(config) { + this.name = config.name; + this.description = config.description; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes); + this._values = defineEnumValues(this.name, config.values); + this._valueLookup = new Map(this._values.map(function(enumValue) { + return [enumValue.value, enumValue]; + })); + this._nameLookup = (0, _keyMap.default)(this._values, function(value) { + return value.name; + }); + typeof config.name === "string" || (0, _devAssert.default)(0, "Must provide name."); + } + var _proto5 = GraphQLEnumType2.prototype; + _proto5.getValues = function getValues() { + return this._values; + }; + _proto5.getValue = function getValue(name) { + return this._nameLookup[name]; + }; + _proto5.serialize = function serialize(outputValue) { + var enumValue = this._valueLookup.get(outputValue); + if (enumValue === void 0) { + throw new _GraphQLError.GraphQLError('Enum "'.concat(this.name, '" cannot represent value: ').concat((0, _inspect.default)(outputValue))); + } + return enumValue.name; + }; + _proto5.parseValue = function parseValue(inputValue) { + if (typeof inputValue !== "string") { + var valueStr = (0, _inspect.default)(inputValue); + throw new _GraphQLError.GraphQLError('Enum "'.concat(this.name, '" cannot represent non-string value: ').concat(valueStr, ".") + didYouMeanEnumValue(this, valueStr)); + } + var enumValue = this.getValue(inputValue); + if (enumValue == null) { + throw new _GraphQLError.GraphQLError('Value "'.concat(inputValue, '" does not exist in "').concat(this.name, '" enum.') + didYouMeanEnumValue(this, inputValue)); + } + return enumValue.value; + }; + _proto5.parseLiteral = function parseLiteral(valueNode, _variables) { + if (valueNode.kind !== _kinds.Kind.ENUM) { + var valueStr = (0, _printer.print)(valueNode); + throw new _GraphQLError.GraphQLError('Enum "'.concat(this.name, '" cannot represent non-enum value: ').concat(valueStr, ".") + didYouMeanEnumValue(this, valueStr), valueNode); + } + var enumValue = this.getValue(valueNode.value); + if (enumValue == null) { + var _valueStr = (0, _printer.print)(valueNode); + throw new _GraphQLError.GraphQLError('Value "'.concat(_valueStr, '" does not exist in "').concat(this.name, '" enum.') + didYouMeanEnumValue(this, _valueStr), valueNode); + } + return enumValue.value; + }; + _proto5.toConfig = function toConfig() { + var _this$extensionASTNod4; + var values = (0, _keyValMap.default)(this.getValues(), function(value) { + return value.name; + }, function(value) { + return { + description: value.description, + value: value.value, + deprecationReason: value.deprecationReason, + extensions: value.extensions, + astNode: value.astNode + }; + }); + return { + name: this.name, + description: this.description, + values, + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: (_this$extensionASTNod4 = this.extensionASTNodes) !== null && _this$extensionASTNod4 !== void 0 ? _this$extensionASTNod4 : [] + }; + }; + _proto5.toString = function toString() { + return this.name; + }; + _proto5.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLEnumType2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLEnumType"; + } + }]); + return GraphQLEnumType2; + }(); + exports2.GraphQLEnumType = GraphQLEnumType; + (0, _defineInspect.default)(GraphQLEnumType); + function didYouMeanEnumValue(enumType, unknownValueStr) { + var allNames = enumType.getValues().map(function(value) { + return value.name; + }); + var suggestedValues = (0, _suggestionList.default)(unknownValueStr, allNames); + return (0, _didYouMean.default)("the enum value", suggestedValues); + } + function defineEnumValues(typeName, valueMap) { + isPlainObj(valueMap) || (0, _devAssert.default)(0, "".concat(typeName, " values must be an object with value names as keys.")); + return (0, _objectEntries.default)(valueMap).map(function(_ref2) { + var valueName = _ref2[0], valueConfig = _ref2[1]; + isPlainObj(valueConfig) || (0, _devAssert.default)(0, "".concat(typeName, ".").concat(valueName, ' must refer to an object with a "value" key ') + "representing an internal value but got: ".concat((0, _inspect.default)(valueConfig), ".")); + !("isDeprecated" in valueConfig) || (0, _devAssert.default)(0, "".concat(typeName, ".").concat(valueName, ' should provide "deprecationReason" instead of "isDeprecated".')); + return { + name: valueName, + description: valueConfig.description, + value: valueConfig.value !== void 0 ? valueConfig.value : valueName, + isDeprecated: valueConfig.deprecationReason != null, + deprecationReason: valueConfig.deprecationReason, + extensions: valueConfig.extensions && (0, _toObjMap.default)(valueConfig.extensions), + astNode: valueConfig.astNode + }; + }); + } + var GraphQLInputObjectType = /* @__PURE__ */ function() { + function GraphQLInputObjectType2(config) { + this.name = config.name; + this.description = config.description; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes); + this._fields = defineInputFieldMap.bind(void 0, config); + typeof config.name === "string" || (0, _devAssert.default)(0, "Must provide name."); + } + var _proto6 = GraphQLInputObjectType2.prototype; + _proto6.getFields = function getFields() { + if (typeof this._fields === "function") { + this._fields = this._fields(); + } + return this._fields; + }; + _proto6.toConfig = function toConfig() { + var _this$extensionASTNod5; + var fields = (0, _mapValue.default)(this.getFields(), function(field) { + return { + description: field.description, + type: field.type, + defaultValue: field.defaultValue, + deprecationReason: field.deprecationReason, + extensions: field.extensions, + astNode: field.astNode + }; + }); + return { + name: this.name, + description: this.description, + fields, + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: (_this$extensionASTNod5 = this.extensionASTNodes) !== null && _this$extensionASTNod5 !== void 0 ? _this$extensionASTNod5 : [] + }; + }; + _proto6.toString = function toString() { + return this.name; + }; + _proto6.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLInputObjectType2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLInputObjectType"; + } + }]); + return GraphQLInputObjectType2; + }(); + exports2.GraphQLInputObjectType = GraphQLInputObjectType; + (0, _defineInspect.default)(GraphQLInputObjectType); + function defineInputFieldMap(config) { + var fieldMap = resolveThunk(config.fields); + isPlainObj(fieldMap) || (0, _devAssert.default)(0, "".concat(config.name, " fields must be an object with field names as keys or a function which returns such an object.")); + return (0, _mapValue.default)(fieldMap, function(fieldConfig, fieldName) { + !("resolve" in fieldConfig) || (0, _devAssert.default)(0, "".concat(config.name, ".").concat(fieldName, " field has a resolve property, but Input Types cannot define resolvers.")); + return { + name: fieldName, + description: fieldConfig.description, + type: fieldConfig.type, + defaultValue: fieldConfig.defaultValue, + deprecationReason: fieldConfig.deprecationReason, + extensions: fieldConfig.extensions && (0, _toObjMap.default)(fieldConfig.extensions), + astNode: fieldConfig.astNode + }; + }); + } + function isRequiredInputField(field) { + return isNonNullType(field.type) && field.defaultValue === void 0; + } + } +}); + +// node_modules/graphql/utilities/typeComparators.js +var require_typeComparators = __commonJS({ + "node_modules/graphql/utilities/typeComparators.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isEqualType = isEqualType; + exports2.isTypeSubTypeOf = isTypeSubTypeOf; + exports2.doTypesOverlap = doTypesOverlap; + var _definition = require_definition(); + function isEqualType(typeA, typeB) { + if (typeA === typeB) { + return true; + } + if ((0, _definition.isNonNullType)(typeA) && (0, _definition.isNonNullType)(typeB)) { + return isEqualType(typeA.ofType, typeB.ofType); + } + if ((0, _definition.isListType)(typeA) && (0, _definition.isListType)(typeB)) { + return isEqualType(typeA.ofType, typeB.ofType); + } + return false; + } + function isTypeSubTypeOf(schema2, maybeSubType, superType) { + if (maybeSubType === superType) { + return true; + } + if ((0, _definition.isNonNullType)(superType)) { + if ((0, _definition.isNonNullType)(maybeSubType)) { + return isTypeSubTypeOf(schema2, maybeSubType.ofType, superType.ofType); + } + return false; + } + if ((0, _definition.isNonNullType)(maybeSubType)) { + return isTypeSubTypeOf(schema2, maybeSubType.ofType, superType); + } + if ((0, _definition.isListType)(superType)) { + if ((0, _definition.isListType)(maybeSubType)) { + return isTypeSubTypeOf(schema2, maybeSubType.ofType, superType.ofType); + } + return false; + } + if ((0, _definition.isListType)(maybeSubType)) { + return false; + } + return (0, _definition.isAbstractType)(superType) && ((0, _definition.isInterfaceType)(maybeSubType) || (0, _definition.isObjectType)(maybeSubType)) && schema2.isSubType(superType, maybeSubType); + } + function doTypesOverlap(schema2, typeA, typeB) { + if (typeA === typeB) { + return true; + } + if ((0, _definition.isAbstractType)(typeA)) { + if ((0, _definition.isAbstractType)(typeB)) { + return schema2.getPossibleTypes(typeA).some(function(type) { + return schema2.isSubType(typeB, type); + }); + } + return schema2.isSubType(typeA, typeB); + } + if ((0, _definition.isAbstractType)(typeB)) { + return schema2.isSubType(typeB, typeA); + } + return false; + } + } +}); + +// node_modules/graphql/polyfills/arrayFrom.js +var require_arrayFrom = __commonJS({ + "node_modules/graphql/polyfills/arrayFrom.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _symbols = require_symbols(); + var arrayFrom = Array.from || function(obj, mapFn, thisArg) { + if (obj == null) { + throw new TypeError("Array.from requires an array-like object - not null or undefined"); + } + var iteratorMethod = obj[_symbols.SYMBOL_ITERATOR]; + if (typeof iteratorMethod === "function") { + var iterator = iteratorMethod.call(obj); + var result = []; + var step; + for (var i = 0; !(step = iterator.next()).done; ++i) { + result.push(mapFn.call(thisArg, step.value, i)); + if (i > 9999999) { + throw new TypeError("Near-infinite iteration."); + } + } + return result; + } + var length = obj.length; + if (typeof length === "number" && length >= 0 && length % 1 === 0) { + var _result = []; + for (var _i = 0; _i < length; ++_i) { + if (Object.prototype.hasOwnProperty.call(obj, _i)) { + _result.push(mapFn.call(thisArg, obj[_i], _i)); + } + } + return _result; + } + return []; + }; + var _default = arrayFrom; + exports2.default = _default; + } +}); + +// node_modules/graphql/polyfills/isFinite.js +var require_isFinite = __commonJS({ + "node_modules/graphql/polyfills/isFinite.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var isFinitePolyfill = Number.isFinite || function(value) { + return typeof value === "number" && isFinite(value); + }; + var _default = isFinitePolyfill; + exports2.default = _default; + } +}); + +// node_modules/graphql/jsutils/safeArrayFrom.js +var require_safeArrayFrom = __commonJS({ + "node_modules/graphql/jsutils/safeArrayFrom.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = safeArrayFrom; + var _symbols = require_symbols(); + function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function _typeof2(obj2) { + return typeof obj2; + }; + } else { + _typeof = function _typeof2(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + function safeArrayFrom(collection) { + var mapFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function(item) { + return item; + }; + if (collection == null || _typeof(collection) !== "object") { + return null; + } + if (Array.isArray(collection)) { + return collection.map(mapFn); + } + var iteratorMethod = collection[_symbols.SYMBOL_ITERATOR]; + if (typeof iteratorMethod === "function") { + var iterator = iteratorMethod.call(collection); + var result = []; + var step; + for (var i = 0; !(step = iterator.next()).done; ++i) { + result.push(mapFn(step.value, i)); + } + return result; + } + var length = collection.length; + if (typeof length === "number" && length >= 0 && length % 1 === 0) { + var _result = []; + for (var _i = 0; _i < length; ++_i) { + if (!Object.prototype.hasOwnProperty.call(collection, _i)) { + return null; + } + _result.push(mapFn(collection[String(_i)], _i)); + } + return _result; + } + return null; + } + } +}); + +// node_modules/graphql/polyfills/isInteger.js +var require_isInteger = __commonJS({ + "node_modules/graphql/polyfills/isInteger.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var isInteger = Number.isInteger || function(value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value; + }; + var _default = isInteger; + exports2.default = _default; + } +}); + +// node_modules/graphql/type/scalars.js +var require_scalars = __commonJS({ + "node_modules/graphql/type/scalars.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isSpecifiedScalarType = isSpecifiedScalarType; + exports2.specifiedScalarTypes = exports2.GraphQLID = exports2.GraphQLBoolean = exports2.GraphQLString = exports2.GraphQLFloat = exports2.GraphQLInt = void 0; + var _isFinite = _interopRequireDefault(require_isFinite()); + var _isInteger = _interopRequireDefault(require_isInteger()); + var _inspect = _interopRequireDefault(require_inspect()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _kinds = require_kinds(); + var _printer = require_printer(); + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var MAX_INT = 2147483647; + var MIN_INT = -2147483648; + function serializeInt(outputValue) { + var coercedValue = serializeObject(outputValue); + if (typeof coercedValue === "boolean") { + return coercedValue ? 1 : 0; + } + var num = coercedValue; + if (typeof coercedValue === "string" && coercedValue !== "") { + num = Number(coercedValue); + } + if (!(0, _isInteger.default)(num)) { + throw new _GraphQLError.GraphQLError("Int cannot represent non-integer value: ".concat((0, _inspect.default)(coercedValue))); + } + if (num > MAX_INT || num < MIN_INT) { + throw new _GraphQLError.GraphQLError("Int cannot represent non 32-bit signed integer value: " + (0, _inspect.default)(coercedValue)); + } + return num; + } + function coerceInt(inputValue) { + if (!(0, _isInteger.default)(inputValue)) { + throw new _GraphQLError.GraphQLError("Int cannot represent non-integer value: ".concat((0, _inspect.default)(inputValue))); + } + if (inputValue > MAX_INT || inputValue < MIN_INT) { + throw new _GraphQLError.GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(inputValue)); + } + return inputValue; + } + var GraphQLInt = new _definition.GraphQLScalarType({ + name: "Int", + description: "The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.", + serialize: serializeInt, + parseValue: coerceInt, + parseLiteral: function parseLiteral(valueNode) { + if (valueNode.kind !== _kinds.Kind.INT) { + throw new _GraphQLError.GraphQLError("Int cannot represent non-integer value: ".concat((0, _printer.print)(valueNode)), valueNode); + } + var num = parseInt(valueNode.value, 10); + if (num > MAX_INT || num < MIN_INT) { + throw new _GraphQLError.GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(valueNode.value), valueNode); + } + return num; + } + }); + exports2.GraphQLInt = GraphQLInt; + function serializeFloat(outputValue) { + var coercedValue = serializeObject(outputValue); + if (typeof coercedValue === "boolean") { + return coercedValue ? 1 : 0; + } + var num = coercedValue; + if (typeof coercedValue === "string" && coercedValue !== "") { + num = Number(coercedValue); + } + if (!(0, _isFinite.default)(num)) { + throw new _GraphQLError.GraphQLError("Float cannot represent non numeric value: ".concat((0, _inspect.default)(coercedValue))); + } + return num; + } + function coerceFloat(inputValue) { + if (!(0, _isFinite.default)(inputValue)) { + throw new _GraphQLError.GraphQLError("Float cannot represent non numeric value: ".concat((0, _inspect.default)(inputValue))); + } + return inputValue; + } + var GraphQLFloat = new _definition.GraphQLScalarType({ + name: "Float", + description: "The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).", + serialize: serializeFloat, + parseValue: coerceFloat, + parseLiteral: function parseLiteral(valueNode) { + if (valueNode.kind !== _kinds.Kind.FLOAT && valueNode.kind !== _kinds.Kind.INT) { + throw new _GraphQLError.GraphQLError("Float cannot represent non numeric value: ".concat((0, _printer.print)(valueNode)), valueNode); + } + return parseFloat(valueNode.value); + } + }); + exports2.GraphQLFloat = GraphQLFloat; + function serializeObject(outputValue) { + if ((0, _isObjectLike.default)(outputValue)) { + if (typeof outputValue.valueOf === "function") { + var valueOfResult = outputValue.valueOf(); + if (!(0, _isObjectLike.default)(valueOfResult)) { + return valueOfResult; + } + } + if (typeof outputValue.toJSON === "function") { + return outputValue.toJSON(); + } + } + return outputValue; + } + function serializeString(outputValue) { + var coercedValue = serializeObject(outputValue); + if (typeof coercedValue === "string") { + return coercedValue; + } + if (typeof coercedValue === "boolean") { + return coercedValue ? "true" : "false"; + } + if ((0, _isFinite.default)(coercedValue)) { + return coercedValue.toString(); + } + throw new _GraphQLError.GraphQLError("String cannot represent value: ".concat((0, _inspect.default)(outputValue))); + } + function coerceString(inputValue) { + if (typeof inputValue !== "string") { + throw new _GraphQLError.GraphQLError("String cannot represent a non string value: ".concat((0, _inspect.default)(inputValue))); + } + return inputValue; + } + var GraphQLString = new _definition.GraphQLScalarType({ + name: "String", + description: "The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.", + serialize: serializeString, + parseValue: coerceString, + parseLiteral: function parseLiteral(valueNode) { + if (valueNode.kind !== _kinds.Kind.STRING) { + throw new _GraphQLError.GraphQLError("String cannot represent a non string value: ".concat((0, _printer.print)(valueNode)), valueNode); + } + return valueNode.value; + } + }); + exports2.GraphQLString = GraphQLString; + function serializeBoolean(outputValue) { + var coercedValue = serializeObject(outputValue); + if (typeof coercedValue === "boolean") { + return coercedValue; + } + if ((0, _isFinite.default)(coercedValue)) { + return coercedValue !== 0; + } + throw new _GraphQLError.GraphQLError("Boolean cannot represent a non boolean value: ".concat((0, _inspect.default)(coercedValue))); + } + function coerceBoolean(inputValue) { + if (typeof inputValue !== "boolean") { + throw new _GraphQLError.GraphQLError("Boolean cannot represent a non boolean value: ".concat((0, _inspect.default)(inputValue))); + } + return inputValue; + } + var GraphQLBoolean = new _definition.GraphQLScalarType({ + name: "Boolean", + description: "The `Boolean` scalar type represents `true` or `false`.", + serialize: serializeBoolean, + parseValue: coerceBoolean, + parseLiteral: function parseLiteral(valueNode) { + if (valueNode.kind !== _kinds.Kind.BOOLEAN) { + throw new _GraphQLError.GraphQLError("Boolean cannot represent a non boolean value: ".concat((0, _printer.print)(valueNode)), valueNode); + } + return valueNode.value; + } + }); + exports2.GraphQLBoolean = GraphQLBoolean; + function serializeID(outputValue) { + var coercedValue = serializeObject(outputValue); + if (typeof coercedValue === "string") { + return coercedValue; + } + if ((0, _isInteger.default)(coercedValue)) { + return String(coercedValue); + } + throw new _GraphQLError.GraphQLError("ID cannot represent value: ".concat((0, _inspect.default)(outputValue))); + } + function coerceID(inputValue) { + if (typeof inputValue === "string") { + return inputValue; + } + if ((0, _isInteger.default)(inputValue)) { + return inputValue.toString(); + } + throw new _GraphQLError.GraphQLError("ID cannot represent value: ".concat((0, _inspect.default)(inputValue))); + } + var GraphQLID = new _definition.GraphQLScalarType({ + name: "ID", + description: 'The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.', + serialize: serializeID, + parseValue: coerceID, + parseLiteral: function parseLiteral(valueNode) { + if (valueNode.kind !== _kinds.Kind.STRING && valueNode.kind !== _kinds.Kind.INT) { + throw new _GraphQLError.GraphQLError("ID cannot represent a non-string and non-integer value: " + (0, _printer.print)(valueNode), valueNode); + } + return valueNode.value; + } + }); + exports2.GraphQLID = GraphQLID; + var specifiedScalarTypes = Object.freeze([GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID]); + exports2.specifiedScalarTypes = specifiedScalarTypes; + function isSpecifiedScalarType(type) { + return specifiedScalarTypes.some(function(_ref) { + var name = _ref.name; + return type.name === name; + }); + } + } +}); + +// node_modules/graphql/utilities/astFromValue.js +var require_astFromValue = __commonJS({ + "node_modules/graphql/utilities/astFromValue.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.astFromValue = astFromValue; + var _isFinite = _interopRequireDefault(require_isFinite()); + var _objectValues3 = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _safeArrayFrom = _interopRequireDefault(require_safeArrayFrom()); + var _kinds = require_kinds(); + var _scalars = require_scalars(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function astFromValue(value, type) { + if ((0, _definition.isNonNullType)(type)) { + var astValue = astFromValue(value, type.ofType); + if ((astValue === null || astValue === void 0 ? void 0 : astValue.kind) === _kinds.Kind.NULL) { + return null; + } + return astValue; + } + if (value === null) { + return { + kind: _kinds.Kind.NULL + }; + } + if (value === void 0) { + return null; + } + if ((0, _definition.isListType)(type)) { + var itemType = type.ofType; + var items = (0, _safeArrayFrom.default)(value); + if (items != null) { + var valuesNodes = []; + for (var _i2 = 0; _i2 < items.length; _i2++) { + var item = items[_i2]; + var itemNode = astFromValue(item, itemType); + if (itemNode != null) { + valuesNodes.push(itemNode); + } + } + return { + kind: _kinds.Kind.LIST, + values: valuesNodes + }; + } + return astFromValue(value, itemType); + } + if ((0, _definition.isInputObjectType)(type)) { + if (!(0, _isObjectLike.default)(value)) { + return null; + } + var fieldNodes = []; + for (var _i4 = 0, _objectValues2 = (0, _objectValues3.default)(type.getFields()); _i4 < _objectValues2.length; _i4++) { + var field = _objectValues2[_i4]; + var fieldValue = astFromValue(value[field.name], field.type); + if (fieldValue) { + fieldNodes.push({ + kind: _kinds.Kind.OBJECT_FIELD, + name: { + kind: _kinds.Kind.NAME, + value: field.name + }, + value: fieldValue + }); + } + } + return { + kind: _kinds.Kind.OBJECT, + fields: fieldNodes + }; + } + if ((0, _definition.isLeafType)(type)) { + var serialized = type.serialize(value); + if (serialized == null) { + return null; + } + if (typeof serialized === "boolean") { + return { + kind: _kinds.Kind.BOOLEAN, + value: serialized + }; + } + if (typeof serialized === "number" && (0, _isFinite.default)(serialized)) { + var stringNum = String(serialized); + return integerStringRegExp.test(stringNum) ? { + kind: _kinds.Kind.INT, + value: stringNum + } : { + kind: _kinds.Kind.FLOAT, + value: stringNum + }; + } + if (typeof serialized === "string") { + if ((0, _definition.isEnumType)(type)) { + return { + kind: _kinds.Kind.ENUM, + value: serialized + }; + } + if (type === _scalars.GraphQLID && integerStringRegExp.test(serialized)) { + return { + kind: _kinds.Kind.INT, + value: serialized + }; + } + return { + kind: _kinds.Kind.STRING, + value: serialized + }; + } + throw new TypeError("Cannot convert value to AST: ".concat((0, _inspect.default)(serialized), ".")); + } + (0, _invariant.default)(0, "Unexpected input type: " + (0, _inspect.default)(type)); + } + var integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/; + } +}); + +// node_modules/graphql/type/introspection.js +var require_introspection = __commonJS({ + "node_modules/graphql/type/introspection.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isIntrospectionType = isIntrospectionType; + exports2.introspectionTypes = exports2.TypeNameMetaFieldDef = exports2.TypeMetaFieldDef = exports2.SchemaMetaFieldDef = exports2.__TypeKind = exports2.TypeKind = exports2.__EnumValue = exports2.__InputValue = exports2.__Field = exports2.__Type = exports2.__DirectiveLocation = exports2.__Directive = exports2.__Schema = void 0; + var _objectValues = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _printer = require_printer(); + var _directiveLocation = require_directiveLocation(); + var _astFromValue = require_astFromValue(); + var _scalars = require_scalars(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var __Schema = new _definition.GraphQLObjectType({ + name: "__Schema", + description: "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.", + fields: function fields() { + return { + description: { + type: _scalars.GraphQLString, + resolve: function resolve(schema2) { + return schema2.description; + } + }, + types: { + description: "A list of all types supported by this server.", + type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type))), + resolve: function resolve(schema2) { + return (0, _objectValues.default)(schema2.getTypeMap()); + } + }, + queryType: { + description: "The type that query operations will be rooted at.", + type: new _definition.GraphQLNonNull(__Type), + resolve: function resolve(schema2) { + return schema2.getQueryType(); + } + }, + mutationType: { + description: "If this server supports mutation, the type that mutation operations will be rooted at.", + type: __Type, + resolve: function resolve(schema2) { + return schema2.getMutationType(); + } + }, + subscriptionType: { + description: "If this server support subscription, the type that subscription operations will be rooted at.", + type: __Type, + resolve: function resolve(schema2) { + return schema2.getSubscriptionType(); + } + }, + directives: { + description: "A list of all directives supported by this server.", + type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Directive))), + resolve: function resolve(schema2) { + return schema2.getDirectives(); + } + } + }; + } + }); + exports2.__Schema = __Schema; + var __Directive = new _definition.GraphQLObjectType({ + name: "__Directive", + description: "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.", + fields: function fields() { + return { + name: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + resolve: function resolve(directive) { + return directive.name; + } + }, + description: { + type: _scalars.GraphQLString, + resolve: function resolve(directive) { + return directive.description; + } + }, + isRepeatable: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean), + resolve: function resolve(directive) { + return directive.isRepeatable; + } + }, + locations: { + type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__DirectiveLocation))), + resolve: function resolve(directive) { + return directive.locations; + } + }, + args: { + type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))), + args: { + includeDeprecated: { + type: _scalars.GraphQLBoolean, + defaultValue: false + } + }, + resolve: function resolve(field, _ref) { + var includeDeprecated = _ref.includeDeprecated; + return includeDeprecated ? field.args : field.args.filter(function(arg) { + return arg.deprecationReason == null; + }); + } + } + }; + } + }); + exports2.__Directive = __Directive; + var __DirectiveLocation = new _definition.GraphQLEnumType({ + name: "__DirectiveLocation", + description: "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.", + values: { + QUERY: { + value: _directiveLocation.DirectiveLocation.QUERY, + description: "Location adjacent to a query operation." + }, + MUTATION: { + value: _directiveLocation.DirectiveLocation.MUTATION, + description: "Location adjacent to a mutation operation." + }, + SUBSCRIPTION: { + value: _directiveLocation.DirectiveLocation.SUBSCRIPTION, + description: "Location adjacent to a subscription operation." + }, + FIELD: { + value: _directiveLocation.DirectiveLocation.FIELD, + description: "Location adjacent to a field." + }, + FRAGMENT_DEFINITION: { + value: _directiveLocation.DirectiveLocation.FRAGMENT_DEFINITION, + description: "Location adjacent to a fragment definition." + }, + FRAGMENT_SPREAD: { + value: _directiveLocation.DirectiveLocation.FRAGMENT_SPREAD, + description: "Location adjacent to a fragment spread." + }, + INLINE_FRAGMENT: { + value: _directiveLocation.DirectiveLocation.INLINE_FRAGMENT, + description: "Location adjacent to an inline fragment." + }, + VARIABLE_DEFINITION: { + value: _directiveLocation.DirectiveLocation.VARIABLE_DEFINITION, + description: "Location adjacent to a variable definition." + }, + SCHEMA: { + value: _directiveLocation.DirectiveLocation.SCHEMA, + description: "Location adjacent to a schema definition." + }, + SCALAR: { + value: _directiveLocation.DirectiveLocation.SCALAR, + description: "Location adjacent to a scalar definition." + }, + OBJECT: { + value: _directiveLocation.DirectiveLocation.OBJECT, + description: "Location adjacent to an object type definition." + }, + FIELD_DEFINITION: { + value: _directiveLocation.DirectiveLocation.FIELD_DEFINITION, + description: "Location adjacent to a field definition." + }, + ARGUMENT_DEFINITION: { + value: _directiveLocation.DirectiveLocation.ARGUMENT_DEFINITION, + description: "Location adjacent to an argument definition." + }, + INTERFACE: { + value: _directiveLocation.DirectiveLocation.INTERFACE, + description: "Location adjacent to an interface definition." + }, + UNION: { + value: _directiveLocation.DirectiveLocation.UNION, + description: "Location adjacent to a union definition." + }, + ENUM: { + value: _directiveLocation.DirectiveLocation.ENUM, + description: "Location adjacent to an enum definition." + }, + ENUM_VALUE: { + value: _directiveLocation.DirectiveLocation.ENUM_VALUE, + description: "Location adjacent to an enum value definition." + }, + INPUT_OBJECT: { + value: _directiveLocation.DirectiveLocation.INPUT_OBJECT, + description: "Location adjacent to an input object type definition." + }, + INPUT_FIELD_DEFINITION: { + value: _directiveLocation.DirectiveLocation.INPUT_FIELD_DEFINITION, + description: "Location adjacent to an input object field definition." + } + } + }); + exports2.__DirectiveLocation = __DirectiveLocation; + var __Type = new _definition.GraphQLObjectType({ + name: "__Type", + description: "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name, description and optional `specifiedByUrl`, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.", + fields: function fields() { + return { + kind: { + type: new _definition.GraphQLNonNull(__TypeKind), + resolve: function resolve(type) { + if ((0, _definition.isScalarType)(type)) { + return TypeKind.SCALAR; + } + if ((0, _definition.isObjectType)(type)) { + return TypeKind.OBJECT; + } + if ((0, _definition.isInterfaceType)(type)) { + return TypeKind.INTERFACE; + } + if ((0, _definition.isUnionType)(type)) { + return TypeKind.UNION; + } + if ((0, _definition.isEnumType)(type)) { + return TypeKind.ENUM; + } + if ((0, _definition.isInputObjectType)(type)) { + return TypeKind.INPUT_OBJECT; + } + if ((0, _definition.isListType)(type)) { + return TypeKind.LIST; + } + if ((0, _definition.isNonNullType)(type)) { + return TypeKind.NON_NULL; + } + (0, _invariant.default)(0, 'Unexpected type: "'.concat((0, _inspect.default)(type), '".')); + } + }, + name: { + type: _scalars.GraphQLString, + resolve: function resolve(type) { + return type.name !== void 0 ? type.name : void 0; + } + }, + description: { + type: _scalars.GraphQLString, + resolve: function resolve(type) { + return type.description !== void 0 ? type.description : void 0; + } + }, + specifiedByUrl: { + type: _scalars.GraphQLString, + resolve: function resolve(obj) { + return obj.specifiedByUrl !== void 0 ? obj.specifiedByUrl : void 0; + } + }, + fields: { + type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Field)), + args: { + includeDeprecated: { + type: _scalars.GraphQLBoolean, + defaultValue: false + } + }, + resolve: function resolve(type, _ref2) { + var includeDeprecated = _ref2.includeDeprecated; + if ((0, _definition.isObjectType)(type) || (0, _definition.isInterfaceType)(type)) { + var fields2 = (0, _objectValues.default)(type.getFields()); + return includeDeprecated ? fields2 : fields2.filter(function(field) { + return field.deprecationReason == null; + }); + } + } + }, + interfaces: { + type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)), + resolve: function resolve(type) { + if ((0, _definition.isObjectType)(type) || (0, _definition.isInterfaceType)(type)) { + return type.getInterfaces(); + } + } + }, + possibleTypes: { + type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)), + resolve: function resolve(type, _args, _context, _ref3) { + var schema2 = _ref3.schema; + if ((0, _definition.isAbstractType)(type)) { + return schema2.getPossibleTypes(type); + } + } + }, + enumValues: { + type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__EnumValue)), + args: { + includeDeprecated: { + type: _scalars.GraphQLBoolean, + defaultValue: false + } + }, + resolve: function resolve(type, _ref4) { + var includeDeprecated = _ref4.includeDeprecated; + if ((0, _definition.isEnumType)(type)) { + var values = type.getValues(); + return includeDeprecated ? values : values.filter(function(field) { + return field.deprecationReason == null; + }); + } + } + }, + inputFields: { + type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue)), + args: { + includeDeprecated: { + type: _scalars.GraphQLBoolean, + defaultValue: false + } + }, + resolve: function resolve(type, _ref5) { + var includeDeprecated = _ref5.includeDeprecated; + if ((0, _definition.isInputObjectType)(type)) { + var values = (0, _objectValues.default)(type.getFields()); + return includeDeprecated ? values : values.filter(function(field) { + return field.deprecationReason == null; + }); + } + } + }, + ofType: { + type: __Type, + resolve: function resolve(type) { + return type.ofType !== void 0 ? type.ofType : void 0; + } + } + }; + } + }); + exports2.__Type = __Type; + var __Field = new _definition.GraphQLObjectType({ + name: "__Field", + description: "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.", + fields: function fields() { + return { + name: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + resolve: function resolve(field) { + return field.name; + } + }, + description: { + type: _scalars.GraphQLString, + resolve: function resolve(field) { + return field.description; + } + }, + args: { + type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))), + args: { + includeDeprecated: { + type: _scalars.GraphQLBoolean, + defaultValue: false + } + }, + resolve: function resolve(field, _ref6) { + var includeDeprecated = _ref6.includeDeprecated; + return includeDeprecated ? field.args : field.args.filter(function(arg) { + return arg.deprecationReason == null; + }); + } + }, + type: { + type: new _definition.GraphQLNonNull(__Type), + resolve: function resolve(field) { + return field.type; + } + }, + isDeprecated: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean), + resolve: function resolve(field) { + return field.deprecationReason != null; + } + }, + deprecationReason: { + type: _scalars.GraphQLString, + resolve: function resolve(field) { + return field.deprecationReason; + } + } + }; + } + }); + exports2.__Field = __Field; + var __InputValue = new _definition.GraphQLObjectType({ + name: "__InputValue", + description: "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.", + fields: function fields() { + return { + name: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + resolve: function resolve(inputValue) { + return inputValue.name; + } + }, + description: { + type: _scalars.GraphQLString, + resolve: function resolve(inputValue) { + return inputValue.description; + } + }, + type: { + type: new _definition.GraphQLNonNull(__Type), + resolve: function resolve(inputValue) { + return inputValue.type; + } + }, + defaultValue: { + type: _scalars.GraphQLString, + description: "A GraphQL-formatted string representing the default value for this input value.", + resolve: function resolve(inputValue) { + var type = inputValue.type, defaultValue = inputValue.defaultValue; + var valueAST = (0, _astFromValue.astFromValue)(defaultValue, type); + return valueAST ? (0, _printer.print)(valueAST) : null; + } + }, + isDeprecated: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean), + resolve: function resolve(field) { + return field.deprecationReason != null; + } + }, + deprecationReason: { + type: _scalars.GraphQLString, + resolve: function resolve(obj) { + return obj.deprecationReason; + } + } + }; + } + }); + exports2.__InputValue = __InputValue; + var __EnumValue = new _definition.GraphQLObjectType({ + name: "__EnumValue", + description: "One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.", + fields: function fields() { + return { + name: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + resolve: function resolve(enumValue) { + return enumValue.name; + } + }, + description: { + type: _scalars.GraphQLString, + resolve: function resolve(enumValue) { + return enumValue.description; + } + }, + isDeprecated: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean), + resolve: function resolve(enumValue) { + return enumValue.deprecationReason != null; + } + }, + deprecationReason: { + type: _scalars.GraphQLString, + resolve: function resolve(enumValue) { + return enumValue.deprecationReason; + } + } + }; + } + }); + exports2.__EnumValue = __EnumValue; + var TypeKind = Object.freeze({ + SCALAR: "SCALAR", + OBJECT: "OBJECT", + INTERFACE: "INTERFACE", + UNION: "UNION", + ENUM: "ENUM", + INPUT_OBJECT: "INPUT_OBJECT", + LIST: "LIST", + NON_NULL: "NON_NULL" + }); + exports2.TypeKind = TypeKind; + var __TypeKind = new _definition.GraphQLEnumType({ + name: "__TypeKind", + description: "An enum describing what kind of type a given `__Type` is.", + values: { + SCALAR: { + value: TypeKind.SCALAR, + description: "Indicates this type is a scalar." + }, + OBJECT: { + value: TypeKind.OBJECT, + description: "Indicates this type is an object. `fields` and `interfaces` are valid fields." + }, + INTERFACE: { + value: TypeKind.INTERFACE, + description: "Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields." + }, + UNION: { + value: TypeKind.UNION, + description: "Indicates this type is a union. `possibleTypes` is a valid field." + }, + ENUM: { + value: TypeKind.ENUM, + description: "Indicates this type is an enum. `enumValues` is a valid field." + }, + INPUT_OBJECT: { + value: TypeKind.INPUT_OBJECT, + description: "Indicates this type is an input object. `inputFields` is a valid field." + }, + LIST: { + value: TypeKind.LIST, + description: "Indicates this type is a list. `ofType` is a valid field." + }, + NON_NULL: { + value: TypeKind.NON_NULL, + description: "Indicates this type is a non-null. `ofType` is a valid field." + } + } + }); + exports2.__TypeKind = __TypeKind; + var SchemaMetaFieldDef = { + name: "__schema", + type: new _definition.GraphQLNonNull(__Schema), + description: "Access the current type schema of this server.", + args: [], + resolve: function resolve(_source, _args, _context, _ref7) { + var schema2 = _ref7.schema; + return schema2; + }, + isDeprecated: false, + deprecationReason: void 0, + extensions: void 0, + astNode: void 0 + }; + exports2.SchemaMetaFieldDef = SchemaMetaFieldDef; + var TypeMetaFieldDef = { + name: "__type", + type: __Type, + description: "Request the type information of a single type.", + args: [{ + name: "name", + description: void 0, + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + defaultValue: void 0, + deprecationReason: void 0, + extensions: void 0, + astNode: void 0 + }], + resolve: function resolve(_source, _ref8, _context, _ref9) { + var name = _ref8.name; + var schema2 = _ref9.schema; + return schema2.getType(name); + }, + isDeprecated: false, + deprecationReason: void 0, + extensions: void 0, + astNode: void 0 + }; + exports2.TypeMetaFieldDef = TypeMetaFieldDef; + var TypeNameMetaFieldDef = { + name: "__typename", + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + description: "The name of the current Object type at runtime.", + args: [], + resolve: function resolve(_source, _args, _context, _ref10) { + var parentType = _ref10.parentType; + return parentType.name; + }, + isDeprecated: false, + deprecationReason: void 0, + extensions: void 0, + astNode: void 0 + }; + exports2.TypeNameMetaFieldDef = TypeNameMetaFieldDef; + var introspectionTypes = Object.freeze([__Schema, __Directive, __DirectiveLocation, __Type, __Field, __InputValue, __EnumValue, __TypeKind]); + exports2.introspectionTypes = introspectionTypes; + function isIntrospectionType(type) { + return introspectionTypes.some(function(_ref11) { + var name = _ref11.name; + return type.name === name; + }); + } + } +}); + +// node_modules/graphql/type/directives.js +var require_directives = __commonJS({ + "node_modules/graphql/type/directives.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isDirective = isDirective; + exports2.assertDirective = assertDirective; + exports2.isSpecifiedDirective = isSpecifiedDirective; + exports2.specifiedDirectives = exports2.GraphQLSpecifiedByDirective = exports2.GraphQLDeprecatedDirective = exports2.DEFAULT_DEPRECATION_REASON = exports2.GraphQLSkipDirective = exports2.GraphQLIncludeDirective = exports2.GraphQLDirective = void 0; + var _objectEntries = _interopRequireDefault(require_objectEntries()); + var _symbols = require_symbols(); + var _inspect = _interopRequireDefault(require_inspect()); + var _toObjMap = _interopRequireDefault(require_toObjMap()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _instanceOf = _interopRequireDefault(require_instanceOf()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _defineInspect = _interopRequireDefault(require_defineInspect()); + var _directiveLocation = require_directiveLocation(); + var _scalars = require_scalars(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + function isDirective(directive) { + return (0, _instanceOf.default)(directive, GraphQLDirective); + } + function assertDirective(directive) { + if (!isDirective(directive)) { + throw new Error("Expected ".concat((0, _inspect.default)(directive), " to be a GraphQL directive.")); + } + return directive; + } + var GraphQLDirective = /* @__PURE__ */ function() { + function GraphQLDirective2(config) { + var _config$isRepeatable, _config$args; + this.name = config.name; + this.description = config.description; + this.locations = config.locations; + this.isRepeatable = (_config$isRepeatable = config.isRepeatable) !== null && _config$isRepeatable !== void 0 ? _config$isRepeatable : false; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + config.name || (0, _devAssert.default)(0, "Directive must be named."); + Array.isArray(config.locations) || (0, _devAssert.default)(0, "@".concat(config.name, " locations must be an Array.")); + var args = (_config$args = config.args) !== null && _config$args !== void 0 ? _config$args : {}; + (0, _isObjectLike.default)(args) && !Array.isArray(args) || (0, _devAssert.default)(0, "@".concat(config.name, " args must be an object with argument names as keys.")); + this.args = (0, _objectEntries.default)(args).map(function(_ref) { + var argName = _ref[0], argConfig = _ref[1]; + return { + name: argName, + description: argConfig.description, + type: argConfig.type, + defaultValue: argConfig.defaultValue, + deprecationReason: argConfig.deprecationReason, + extensions: argConfig.extensions && (0, _toObjMap.default)(argConfig.extensions), + astNode: argConfig.astNode + }; + }); + } + var _proto = GraphQLDirective2.prototype; + _proto.toConfig = function toConfig() { + return { + name: this.name, + description: this.description, + locations: this.locations, + args: (0, _definition.argsToArgsConfig)(this.args), + isRepeatable: this.isRepeatable, + extensions: this.extensions, + astNode: this.astNode + }; + }; + _proto.toString = function toString() { + return "@" + this.name; + }; + _proto.toJSON = function toJSON() { + return this.toString(); + }; + _createClass(GraphQLDirective2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLDirective"; + } + }]); + return GraphQLDirective2; + }(); + exports2.GraphQLDirective = GraphQLDirective; + (0, _defineInspect.default)(GraphQLDirective); + var GraphQLIncludeDirective = new GraphQLDirective({ + name: "include", + description: "Directs the executor to include this field or fragment only when the `if` argument is true.", + locations: [_directiveLocation.DirectiveLocation.FIELD, _directiveLocation.DirectiveLocation.FRAGMENT_SPREAD, _directiveLocation.DirectiveLocation.INLINE_FRAGMENT], + args: { + if: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean), + description: "Included when true." + } + } + }); + exports2.GraphQLIncludeDirective = GraphQLIncludeDirective; + var GraphQLSkipDirective = new GraphQLDirective({ + name: "skip", + description: "Directs the executor to skip this field or fragment when the `if` argument is true.", + locations: [_directiveLocation.DirectiveLocation.FIELD, _directiveLocation.DirectiveLocation.FRAGMENT_SPREAD, _directiveLocation.DirectiveLocation.INLINE_FRAGMENT], + args: { + if: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean), + description: "Skipped when true." + } + } + }); + exports2.GraphQLSkipDirective = GraphQLSkipDirective; + var DEFAULT_DEPRECATION_REASON = "No longer supported"; + exports2.DEFAULT_DEPRECATION_REASON = DEFAULT_DEPRECATION_REASON; + var GraphQLDeprecatedDirective = new GraphQLDirective({ + name: "deprecated", + description: "Marks an element of a GraphQL schema as no longer supported.", + locations: [_directiveLocation.DirectiveLocation.FIELD_DEFINITION, _directiveLocation.DirectiveLocation.ARGUMENT_DEFINITION, _directiveLocation.DirectiveLocation.INPUT_FIELD_DEFINITION, _directiveLocation.DirectiveLocation.ENUM_VALUE], + args: { + reason: { + type: _scalars.GraphQLString, + description: "Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax, as specified by [CommonMark](https://commonmark.org/).", + defaultValue: DEFAULT_DEPRECATION_REASON + } + } + }); + exports2.GraphQLDeprecatedDirective = GraphQLDeprecatedDirective; + var GraphQLSpecifiedByDirective = new GraphQLDirective({ + name: "specifiedBy", + description: "Exposes a URL that specifies the behaviour of this scalar.", + locations: [_directiveLocation.DirectiveLocation.SCALAR], + args: { + url: { + type: new _definition.GraphQLNonNull(_scalars.GraphQLString), + description: "The URL that specifies the behaviour of this scalar." + } + } + }); + exports2.GraphQLSpecifiedByDirective = GraphQLSpecifiedByDirective; + var specifiedDirectives = Object.freeze([GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLDeprecatedDirective, GraphQLSpecifiedByDirective]); + exports2.specifiedDirectives = specifiedDirectives; + function isSpecifiedDirective(directive) { + return specifiedDirectives.some(function(_ref2) { + var name = _ref2.name; + return name === directive.name; + }); + } + } +}); + +// node_modules/graphql/type/schema.js +var require_schema = __commonJS({ + "node_modules/graphql/type/schema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isSchema = isSchema; + exports2.assertSchema = assertSchema; + exports2.GraphQLSchema = void 0; + var _find = _interopRequireDefault(require_find()); + var _arrayFrom3 = _interopRequireDefault(require_arrayFrom()); + var _objectValues5 = _interopRequireDefault(require_objectValues()); + var _symbols = require_symbols(); + var _inspect = _interopRequireDefault(require_inspect()); + var _toObjMap = _interopRequireDefault(require_toObjMap()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _instanceOf = _interopRequireDefault(require_instanceOf()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _introspection = require_introspection(); + var _directives = require_directives(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + function isSchema(schema2) { + return (0, _instanceOf.default)(schema2, GraphQLSchema); + } + function assertSchema(schema2) { + if (!isSchema(schema2)) { + throw new Error("Expected ".concat((0, _inspect.default)(schema2), " to be a GraphQL schema.")); + } + return schema2; + } + var GraphQLSchema = /* @__PURE__ */ function() { + function GraphQLSchema2(config) { + var _config$directives; + this.__validationErrors = config.assumeValid === true ? [] : void 0; + (0, _isObjectLike.default)(config) || (0, _devAssert.default)(0, "Must provide configuration object."); + !config.types || Array.isArray(config.types) || (0, _devAssert.default)(0, '"types" must be Array if provided but got: '.concat((0, _inspect.default)(config.types), ".")); + !config.directives || Array.isArray(config.directives) || (0, _devAssert.default)(0, '"directives" must be Array if provided but got: ' + "".concat((0, _inspect.default)(config.directives), ".")); + this.description = config.description; + this.extensions = config.extensions && (0, _toObjMap.default)(config.extensions); + this.astNode = config.astNode; + this.extensionASTNodes = config.extensionASTNodes; + this._queryType = config.query; + this._mutationType = config.mutation; + this._subscriptionType = config.subscription; + this._directives = (_config$directives = config.directives) !== null && _config$directives !== void 0 ? _config$directives : _directives.specifiedDirectives; + var allReferencedTypes = new Set(config.types); + if (config.types != null) { + for (var _i2 = 0, _config$types2 = config.types; _i2 < _config$types2.length; _i2++) { + var type = _config$types2[_i2]; + allReferencedTypes.delete(type); + collectReferencedTypes(type, allReferencedTypes); + } + } + if (this._queryType != null) { + collectReferencedTypes(this._queryType, allReferencedTypes); + } + if (this._mutationType != null) { + collectReferencedTypes(this._mutationType, allReferencedTypes); + } + if (this._subscriptionType != null) { + collectReferencedTypes(this._subscriptionType, allReferencedTypes); + } + for (var _i4 = 0, _this$_directives2 = this._directives; _i4 < _this$_directives2.length; _i4++) { + var directive = _this$_directives2[_i4]; + if ((0, _directives.isDirective)(directive)) { + for (var _i6 = 0, _directive$args2 = directive.args; _i6 < _directive$args2.length; _i6++) { + var arg = _directive$args2[_i6]; + collectReferencedTypes(arg.type, allReferencedTypes); + } + } + } + collectReferencedTypes(_introspection.__Schema, allReferencedTypes); + this._typeMap = Object.create(null); + this._subTypeMap = Object.create(null); + this._implementationsMap = Object.create(null); + for (var _i8 = 0, _arrayFrom2 = (0, _arrayFrom3.default)(allReferencedTypes); _i8 < _arrayFrom2.length; _i8++) { + var namedType = _arrayFrom2[_i8]; + if (namedType == null) { + continue; + } + var typeName = namedType.name; + typeName || (0, _devAssert.default)(0, "One of the provided types for building the Schema is missing a name."); + if (this._typeMap[typeName] !== void 0) { + throw new Error('Schema must contain uniquely named types but contains multiple types named "'.concat(typeName, '".')); + } + this._typeMap[typeName] = namedType; + if ((0, _definition.isInterfaceType)(namedType)) { + for (var _i10 = 0, _namedType$getInterfa2 = namedType.getInterfaces(); _i10 < _namedType$getInterfa2.length; _i10++) { + var iface = _namedType$getInterfa2[_i10]; + if ((0, _definition.isInterfaceType)(iface)) { + var implementations = this._implementationsMap[iface.name]; + if (implementations === void 0) { + implementations = this._implementationsMap[iface.name] = { + objects: [], + interfaces: [] + }; + } + implementations.interfaces.push(namedType); + } + } + } else if ((0, _definition.isObjectType)(namedType)) { + for (var _i12 = 0, _namedType$getInterfa4 = namedType.getInterfaces(); _i12 < _namedType$getInterfa4.length; _i12++) { + var _iface = _namedType$getInterfa4[_i12]; + if ((0, _definition.isInterfaceType)(_iface)) { + var _implementations = this._implementationsMap[_iface.name]; + if (_implementations === void 0) { + _implementations = this._implementationsMap[_iface.name] = { + objects: [], + interfaces: [] + }; + } + _implementations.objects.push(namedType); + } + } + } + } + } + var _proto = GraphQLSchema2.prototype; + _proto.getQueryType = function getQueryType() { + return this._queryType; + }; + _proto.getMutationType = function getMutationType() { + return this._mutationType; + }; + _proto.getSubscriptionType = function getSubscriptionType() { + return this._subscriptionType; + }; + _proto.getTypeMap = function getTypeMap() { + return this._typeMap; + }; + _proto.getType = function getType(name) { + return this.getTypeMap()[name]; + }; + _proto.getPossibleTypes = function getPossibleTypes(abstractType) { + return (0, _definition.isUnionType)(abstractType) ? abstractType.getTypes() : this.getImplementations(abstractType).objects; + }; + _proto.getImplementations = function getImplementations(interfaceType) { + var implementations = this._implementationsMap[interfaceType.name]; + return implementations !== null && implementations !== void 0 ? implementations : { + objects: [], + interfaces: [] + }; + }; + _proto.isPossibleType = function isPossibleType(abstractType, possibleType) { + return this.isSubType(abstractType, possibleType); + }; + _proto.isSubType = function isSubType(abstractType, maybeSubType) { + var map = this._subTypeMap[abstractType.name]; + if (map === void 0) { + map = Object.create(null); + if ((0, _definition.isUnionType)(abstractType)) { + for (var _i14 = 0, _abstractType$getType2 = abstractType.getTypes(); _i14 < _abstractType$getType2.length; _i14++) { + var type = _abstractType$getType2[_i14]; + map[type.name] = true; + } + } else { + var implementations = this.getImplementations(abstractType); + for (var _i16 = 0, _implementations$obje2 = implementations.objects; _i16 < _implementations$obje2.length; _i16++) { + var _type = _implementations$obje2[_i16]; + map[_type.name] = true; + } + for (var _i18 = 0, _implementations$inte2 = implementations.interfaces; _i18 < _implementations$inte2.length; _i18++) { + var _type2 = _implementations$inte2[_i18]; + map[_type2.name] = true; + } + } + this._subTypeMap[abstractType.name] = map; + } + return map[maybeSubType.name] !== void 0; + }; + _proto.getDirectives = function getDirectives() { + return this._directives; + }; + _proto.getDirective = function getDirective(name) { + return (0, _find.default)(this.getDirectives(), function(directive) { + return directive.name === name; + }); + }; + _proto.toConfig = function toConfig() { + var _this$extensionASTNod; + return { + description: this.description, + query: this.getQueryType(), + mutation: this.getMutationType(), + subscription: this.getSubscriptionType(), + types: (0, _objectValues5.default)(this.getTypeMap()), + directives: this.getDirectives().slice(), + extensions: this.extensions, + astNode: this.astNode, + extensionASTNodes: (_this$extensionASTNod = this.extensionASTNodes) !== null && _this$extensionASTNod !== void 0 ? _this$extensionASTNod : [], + assumeValid: this.__validationErrors !== void 0 + }; + }; + _createClass(GraphQLSchema2, [{ + key: _symbols.SYMBOL_TO_STRING_TAG, + get: function get() { + return "GraphQLSchema"; + } + }]); + return GraphQLSchema2; + }(); + exports2.GraphQLSchema = GraphQLSchema; + function collectReferencedTypes(type, typeSet) { + var namedType = (0, _definition.getNamedType)(type); + if (!typeSet.has(namedType)) { + typeSet.add(namedType); + if ((0, _definition.isUnionType)(namedType)) { + for (var _i20 = 0, _namedType$getTypes2 = namedType.getTypes(); _i20 < _namedType$getTypes2.length; _i20++) { + var memberType = _namedType$getTypes2[_i20]; + collectReferencedTypes(memberType, typeSet); + } + } else if ((0, _definition.isObjectType)(namedType) || (0, _definition.isInterfaceType)(namedType)) { + for (var _i22 = 0, _namedType$getInterfa6 = namedType.getInterfaces(); _i22 < _namedType$getInterfa6.length; _i22++) { + var interfaceType = _namedType$getInterfa6[_i22]; + collectReferencedTypes(interfaceType, typeSet); + } + for (var _i24 = 0, _objectValues2 = (0, _objectValues5.default)(namedType.getFields()); _i24 < _objectValues2.length; _i24++) { + var field = _objectValues2[_i24]; + collectReferencedTypes(field.type, typeSet); + for (var _i26 = 0, _field$args2 = field.args; _i26 < _field$args2.length; _i26++) { + var arg = _field$args2[_i26]; + collectReferencedTypes(arg.type, typeSet); + } + } + } else if ((0, _definition.isInputObjectType)(namedType)) { + for (var _i28 = 0, _objectValues4 = (0, _objectValues5.default)(namedType.getFields()); _i28 < _objectValues4.length; _i28++) { + var _field = _objectValues4[_i28]; + collectReferencedTypes(_field.type, typeSet); + } + } + } + return typeSet; + } + } +}); + +// node_modules/graphql/type/validate.js +var require_validate = __commonJS({ + "node_modules/graphql/type/validate.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.validateSchema = validateSchema; + exports2.assertValidSchema = assertValidSchema; + var _find = _interopRequireDefault(require_find()); + var _objectValues5 = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _GraphQLError = require_GraphQLError(); + var _locatedError = require_locatedError(); + var _assertValidName = require_assertValidName(); + var _typeComparators = require_typeComparators(); + var _schema = require_schema(); + var _introspection = require_introspection(); + var _directives = require_directives(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function validateSchema(schema2) { + (0, _schema.assertSchema)(schema2); + if (schema2.__validationErrors) { + return schema2.__validationErrors; + } + var context = new SchemaValidationContext(schema2); + validateRootTypes(context); + validateDirectives(context); + validateTypes(context); + var errors = context.getErrors(); + schema2.__validationErrors = errors; + return errors; + } + function assertValidSchema(schema2) { + var errors = validateSchema(schema2); + if (errors.length !== 0) { + throw new Error(errors.map(function(error) { + return error.message; + }).join("\n\n")); + } + } + var SchemaValidationContext = /* @__PURE__ */ function() { + function SchemaValidationContext2(schema2) { + this._errors = []; + this.schema = schema2; + } + var _proto = SchemaValidationContext2.prototype; + _proto.reportError = function reportError(message, nodes) { + var _nodes = Array.isArray(nodes) ? nodes.filter(Boolean) : nodes; + this.addError(new _GraphQLError.GraphQLError(message, _nodes)); + }; + _proto.addError = function addError(error) { + this._errors.push(error); + }; + _proto.getErrors = function getErrors() { + return this._errors; + }; + return SchemaValidationContext2; + }(); + function validateRootTypes(context) { + var schema2 = context.schema; + var queryType = schema2.getQueryType(); + if (!queryType) { + context.reportError("Query root type must be provided.", schema2.astNode); + } else if (!(0, _definition.isObjectType)(queryType)) { + var _getOperationTypeNode; + context.reportError("Query root type must be Object type, it cannot be ".concat((0, _inspect.default)(queryType), "."), (_getOperationTypeNode = getOperationTypeNode(schema2, "query")) !== null && _getOperationTypeNode !== void 0 ? _getOperationTypeNode : queryType.astNode); + } + var mutationType = schema2.getMutationType(); + if (mutationType && !(0, _definition.isObjectType)(mutationType)) { + var _getOperationTypeNode2; + context.reportError("Mutation root type must be Object type if provided, it cannot be " + "".concat((0, _inspect.default)(mutationType), "."), (_getOperationTypeNode2 = getOperationTypeNode(schema2, "mutation")) !== null && _getOperationTypeNode2 !== void 0 ? _getOperationTypeNode2 : mutationType.astNode); + } + var subscriptionType = schema2.getSubscriptionType(); + if (subscriptionType && !(0, _definition.isObjectType)(subscriptionType)) { + var _getOperationTypeNode3; + context.reportError("Subscription root type must be Object type if provided, it cannot be " + "".concat((0, _inspect.default)(subscriptionType), "."), (_getOperationTypeNode3 = getOperationTypeNode(schema2, "subscription")) !== null && _getOperationTypeNode3 !== void 0 ? _getOperationTypeNode3 : subscriptionType.astNode); + } + } + function getOperationTypeNode(schema2, operation) { + var operationNodes = getAllSubNodes(schema2, function(node2) { + return node2.operationTypes; + }); + for (var _i2 = 0; _i2 < operationNodes.length; _i2++) { + var node = operationNodes[_i2]; + if (node.operation === operation) { + return node.type; + } + } + return void 0; + } + function validateDirectives(context) { + for (var _i4 = 0, _context$schema$getDi2 = context.schema.getDirectives(); _i4 < _context$schema$getDi2.length; _i4++) { + var directive = _context$schema$getDi2[_i4]; + if (!(0, _directives.isDirective)(directive)) { + context.reportError("Expected directive but got: ".concat((0, _inspect.default)(directive), "."), directive === null || directive === void 0 ? void 0 : directive.astNode); + continue; + } + validateName(context, directive); + for (var _i6 = 0, _directive$args2 = directive.args; _i6 < _directive$args2.length; _i6++) { + var arg = _directive$args2[_i6]; + validateName(context, arg); + if (!(0, _definition.isInputType)(arg.type)) { + context.reportError("The type of @".concat(directive.name, "(").concat(arg.name, ":) must be Input Type ") + "but got: ".concat((0, _inspect.default)(arg.type), "."), arg.astNode); + } + if ((0, _definition.isRequiredArgument)(arg) && arg.deprecationReason != null) { + var _arg$astNode; + context.reportError("Required argument @".concat(directive.name, "(").concat(arg.name, ":) cannot be deprecated."), [ + getDeprecatedDirectiveNode(arg.astNode), + (_arg$astNode = arg.astNode) === null || _arg$astNode === void 0 ? void 0 : _arg$astNode.type + ]); + } + } + } + } + function validateName(context, node) { + var error = (0, _assertValidName.isValidNameError)(node.name); + if (error) { + context.addError((0, _locatedError.locatedError)(error, node.astNode)); + } + } + function validateTypes(context) { + var validateInputObjectCircularRefs = createInputObjectCircularRefsValidator(context); + var typeMap = context.schema.getTypeMap(); + for (var _i8 = 0, _objectValues2 = (0, _objectValues5.default)(typeMap); _i8 < _objectValues2.length; _i8++) { + var type = _objectValues2[_i8]; + if (!(0, _definition.isNamedType)(type)) { + context.reportError("Expected GraphQL named type but got: ".concat((0, _inspect.default)(type), "."), type.astNode); + continue; + } + if (!(0, _introspection.isIntrospectionType)(type)) { + validateName(context, type); + } + if ((0, _definition.isObjectType)(type)) { + validateFields(context, type); + validateInterfaces(context, type); + } else if ((0, _definition.isInterfaceType)(type)) { + validateFields(context, type); + validateInterfaces(context, type); + } else if ((0, _definition.isUnionType)(type)) { + validateUnionMembers(context, type); + } else if ((0, _definition.isEnumType)(type)) { + validateEnumValues(context, type); + } else if ((0, _definition.isInputObjectType)(type)) { + validateInputFields(context, type); + validateInputObjectCircularRefs(type); + } + } + } + function validateFields(context, type) { + var fields = (0, _objectValues5.default)(type.getFields()); + if (fields.length === 0) { + context.reportError("Type ".concat(type.name, " must define one or more fields."), getAllNodes(type)); + } + for (var _i10 = 0; _i10 < fields.length; _i10++) { + var field = fields[_i10]; + validateName(context, field); + if (!(0, _definition.isOutputType)(field.type)) { + var _field$astNode; + context.reportError("The type of ".concat(type.name, ".").concat(field.name, " must be Output Type ") + "but got: ".concat((0, _inspect.default)(field.type), "."), (_field$astNode = field.astNode) === null || _field$astNode === void 0 ? void 0 : _field$astNode.type); + } + for (var _i12 = 0, _field$args2 = field.args; _i12 < _field$args2.length; _i12++) { + var arg = _field$args2[_i12]; + var argName = arg.name; + validateName(context, arg); + if (!(0, _definition.isInputType)(arg.type)) { + var _arg$astNode2; + context.reportError("The type of ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) must be Input ") + "Type but got: ".concat((0, _inspect.default)(arg.type), "."), (_arg$astNode2 = arg.astNode) === null || _arg$astNode2 === void 0 ? void 0 : _arg$astNode2.type); + } + if ((0, _definition.isRequiredArgument)(arg) && arg.deprecationReason != null) { + var _arg$astNode3; + context.reportError("Required argument ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) cannot be deprecated."), [ + getDeprecatedDirectiveNode(arg.astNode), + (_arg$astNode3 = arg.astNode) === null || _arg$astNode3 === void 0 ? void 0 : _arg$astNode3.type + ]); + } + } + } + } + function validateInterfaces(context, type) { + var ifaceTypeNames = Object.create(null); + for (var _i14 = 0, _type$getInterfaces2 = type.getInterfaces(); _i14 < _type$getInterfaces2.length; _i14++) { + var iface = _type$getInterfaces2[_i14]; + if (!(0, _definition.isInterfaceType)(iface)) { + context.reportError("Type ".concat((0, _inspect.default)(type), " must only implement Interface types, ") + "it cannot implement ".concat((0, _inspect.default)(iface), "."), getAllImplementsInterfaceNodes(type, iface)); + continue; + } + if (type === iface) { + context.reportError("Type ".concat(type.name, " cannot implement itself because it would create a circular reference."), getAllImplementsInterfaceNodes(type, iface)); + continue; + } + if (ifaceTypeNames[iface.name]) { + context.reportError("Type ".concat(type.name, " can only implement ").concat(iface.name, " once."), getAllImplementsInterfaceNodes(type, iface)); + continue; + } + ifaceTypeNames[iface.name] = true; + validateTypeImplementsAncestors(context, type, iface); + validateTypeImplementsInterface(context, type, iface); + } + } + function validateTypeImplementsInterface(context, type, iface) { + var typeFieldMap = type.getFields(); + for (var _i16 = 0, _objectValues4 = (0, _objectValues5.default)(iface.getFields()); _i16 < _objectValues4.length; _i16++) { + var ifaceField = _objectValues4[_i16]; + var fieldName = ifaceField.name; + var typeField = typeFieldMap[fieldName]; + if (!typeField) { + context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expected but ").concat(type.name, " does not provide it."), [ifaceField.astNode].concat(getAllNodes(type))); + continue; + } + if (!(0, _typeComparators.isTypeSubTypeOf)(context.schema, typeField.type, ifaceField.type)) { + var _ifaceField$astNode, _typeField$astNode; + context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expects type ") + "".concat((0, _inspect.default)(ifaceField.type), " but ").concat(type.name, ".").concat(fieldName, " ") + "is type ".concat((0, _inspect.default)(typeField.type), "."), [ + (_ifaceField$astNode = ifaceField.astNode) === null || _ifaceField$astNode === void 0 ? void 0 : _ifaceField$astNode.type, + (_typeField$astNode = typeField.astNode) === null || _typeField$astNode === void 0 ? void 0 : _typeField$astNode.type + ]); + } + var _loop = function _loop3(_i182, _ifaceField$args22) { + var ifaceArg = _ifaceField$args22[_i182]; + var argName = ifaceArg.name; + var typeArg = (0, _find.default)(typeField.args, function(arg) { + return arg.name === argName; + }); + if (!typeArg) { + context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) expected but ").concat(type.name, ".").concat(fieldName, " does not provide it."), [ifaceArg.astNode, typeField.astNode]); + return "continue"; + } + if (!(0, _typeComparators.isEqualType)(ifaceArg.type, typeArg.type)) { + var _ifaceArg$astNode, _typeArg$astNode; + context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) ") + "expects type ".concat((0, _inspect.default)(ifaceArg.type), " but ") + "".concat(type.name, ".").concat(fieldName, "(").concat(argName, ":) is type ") + "".concat((0, _inspect.default)(typeArg.type), "."), [ + (_ifaceArg$astNode = ifaceArg.astNode) === null || _ifaceArg$astNode === void 0 ? void 0 : _ifaceArg$astNode.type, + (_typeArg$astNode = typeArg.astNode) === null || _typeArg$astNode === void 0 ? void 0 : _typeArg$astNode.type + ]); + } + }; + for (var _i18 = 0, _ifaceField$args2 = ifaceField.args; _i18 < _ifaceField$args2.length; _i18++) { + var _ret = _loop(_i18, _ifaceField$args2); + if (_ret === "continue") + continue; + } + var _loop2 = function _loop22(_i202, _typeField$args22) { + var typeArg = _typeField$args22[_i202]; + var argName = typeArg.name; + var ifaceArg = (0, _find.default)(ifaceField.args, function(arg) { + return arg.name === argName; + }); + if (!ifaceArg && (0, _definition.isRequiredArgument)(typeArg)) { + context.reportError("Object field ".concat(type.name, ".").concat(fieldName, " includes required argument ").concat(argName, " that is missing from the Interface field ").concat(iface.name, ".").concat(fieldName, "."), [typeArg.astNode, ifaceField.astNode]); + } + }; + for (var _i20 = 0, _typeField$args2 = typeField.args; _i20 < _typeField$args2.length; _i20++) { + _loop2(_i20, _typeField$args2); + } + } + } + function validateTypeImplementsAncestors(context, type, iface) { + var ifaceInterfaces = type.getInterfaces(); + for (var _i22 = 0, _iface$getInterfaces2 = iface.getInterfaces(); _i22 < _iface$getInterfaces2.length; _i22++) { + var transitive = _iface$getInterfaces2[_i22]; + if (ifaceInterfaces.indexOf(transitive) === -1) { + context.reportError(transitive === type ? "Type ".concat(type.name, " cannot implement ").concat(iface.name, " because it would create a circular reference.") : "Type ".concat(type.name, " must implement ").concat(transitive.name, " because it is implemented by ").concat(iface.name, "."), [].concat(getAllImplementsInterfaceNodes(iface, transitive), getAllImplementsInterfaceNodes(type, iface))); + } + } + } + function validateUnionMembers(context, union) { + var memberTypes = union.getTypes(); + if (memberTypes.length === 0) { + context.reportError("Union type ".concat(union.name, " must define one or more member types."), getAllNodes(union)); + } + var includedTypeNames = Object.create(null); + for (var _i24 = 0; _i24 < memberTypes.length; _i24++) { + var memberType = memberTypes[_i24]; + if (includedTypeNames[memberType.name]) { + context.reportError("Union type ".concat(union.name, " can only include type ").concat(memberType.name, " once."), getUnionMemberTypeNodes(union, memberType.name)); + continue; + } + includedTypeNames[memberType.name] = true; + if (!(0, _definition.isObjectType)(memberType)) { + context.reportError("Union type ".concat(union.name, " can only include Object types, ") + "it cannot include ".concat((0, _inspect.default)(memberType), "."), getUnionMemberTypeNodes(union, String(memberType))); + } + } + } + function validateEnumValues(context, enumType) { + var enumValues = enumType.getValues(); + if (enumValues.length === 0) { + context.reportError("Enum type ".concat(enumType.name, " must define one or more values."), getAllNodes(enumType)); + } + for (var _i26 = 0; _i26 < enumValues.length; _i26++) { + var enumValue = enumValues[_i26]; + var valueName = enumValue.name; + validateName(context, enumValue); + if (valueName === "true" || valueName === "false" || valueName === "null") { + context.reportError("Enum type ".concat(enumType.name, " cannot include value: ").concat(valueName, "."), enumValue.astNode); + } + } + } + function validateInputFields(context, inputObj) { + var fields = (0, _objectValues5.default)(inputObj.getFields()); + if (fields.length === 0) { + context.reportError("Input Object type ".concat(inputObj.name, " must define one or more fields."), getAllNodes(inputObj)); + } + for (var _i28 = 0; _i28 < fields.length; _i28++) { + var field = fields[_i28]; + validateName(context, field); + if (!(0, _definition.isInputType)(field.type)) { + var _field$astNode2; + context.reportError("The type of ".concat(inputObj.name, ".").concat(field.name, " must be Input Type ") + "but got: ".concat((0, _inspect.default)(field.type), "."), (_field$astNode2 = field.astNode) === null || _field$astNode2 === void 0 ? void 0 : _field$astNode2.type); + } + if ((0, _definition.isRequiredInputField)(field) && field.deprecationReason != null) { + var _field$astNode3; + context.reportError("Required input field ".concat(inputObj.name, ".").concat(field.name, " cannot be deprecated."), [ + getDeprecatedDirectiveNode(field.astNode), + (_field$astNode3 = field.astNode) === null || _field$astNode3 === void 0 ? void 0 : _field$astNode3.type + ]); + } + } + } + function createInputObjectCircularRefsValidator(context) { + var visitedTypes = Object.create(null); + var fieldPath = []; + var fieldPathIndexByTypeName = Object.create(null); + return detectCycleRecursive; + function detectCycleRecursive(inputObj) { + if (visitedTypes[inputObj.name]) { + return; + } + visitedTypes[inputObj.name] = true; + fieldPathIndexByTypeName[inputObj.name] = fieldPath.length; + var fields = (0, _objectValues5.default)(inputObj.getFields()); + for (var _i30 = 0; _i30 < fields.length; _i30++) { + var field = fields[_i30]; + if ((0, _definition.isNonNullType)(field.type) && (0, _definition.isInputObjectType)(field.type.ofType)) { + var fieldType = field.type.ofType; + var cycleIndex = fieldPathIndexByTypeName[fieldType.name]; + fieldPath.push(field); + if (cycleIndex === void 0) { + detectCycleRecursive(fieldType); + } else { + var cyclePath = fieldPath.slice(cycleIndex); + var pathStr = cyclePath.map(function(fieldObj) { + return fieldObj.name; + }).join("."); + context.reportError('Cannot reference Input Object "'.concat(fieldType.name, '" within itself through a series of non-null fields: "').concat(pathStr, '".'), cyclePath.map(function(fieldObj) { + return fieldObj.astNode; + })); + } + fieldPath.pop(); + } + } + fieldPathIndexByTypeName[inputObj.name] = void 0; + } + } + function getAllNodes(object) { + var astNode = object.astNode, extensionASTNodes = object.extensionASTNodes; + return astNode ? extensionASTNodes ? [astNode].concat(extensionASTNodes) : [astNode] : extensionASTNodes !== null && extensionASTNodes !== void 0 ? extensionASTNodes : []; + } + function getAllSubNodes(object, getter) { + var subNodes = []; + for (var _i32 = 0, _getAllNodes2 = getAllNodes(object); _i32 < _getAllNodes2.length; _i32++) { + var _getter; + var node = _getAllNodes2[_i32]; + subNodes = subNodes.concat((_getter = getter(node)) !== null && _getter !== void 0 ? _getter : []); + } + return subNodes; + } + function getAllImplementsInterfaceNodes(type, iface) { + return getAllSubNodes(type, function(typeNode) { + return typeNode.interfaces; + }).filter(function(ifaceNode) { + return ifaceNode.name.value === iface.name; + }); + } + function getUnionMemberTypeNodes(union, typeName) { + return getAllSubNodes(union, function(unionNode) { + return unionNode.types; + }).filter(function(typeNode) { + return typeNode.name.value === typeName; + }); + } + function getDeprecatedDirectiveNode(definitionNode) { + var _definitionNode$direc; + return definitionNode === null || definitionNode === void 0 ? void 0 : (_definitionNode$direc = definitionNode.directives) === null || _definitionNode$direc === void 0 ? void 0 : _definitionNode$direc.find(function(node) { + return node.name.value === _directives.GraphQLDeprecatedDirective.name; + }); + } + } +}); + +// node_modules/graphql/utilities/typeFromAST.js +var require_typeFromAST = __commonJS({ + "node_modules/graphql/utilities/typeFromAST.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.typeFromAST = typeFromAST; + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _kinds = require_kinds(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function typeFromAST(schema2, typeNode) { + var innerType; + if (typeNode.kind === _kinds.Kind.LIST_TYPE) { + innerType = typeFromAST(schema2, typeNode.type); + return innerType && new _definition.GraphQLList(innerType); + } + if (typeNode.kind === _kinds.Kind.NON_NULL_TYPE) { + innerType = typeFromAST(schema2, typeNode.type); + return innerType && new _definition.GraphQLNonNull(innerType); + } + if (typeNode.kind === _kinds.Kind.NAMED_TYPE) { + return schema2.getType(typeNode.name.value); + } + (0, _invariant.default)(0, "Unexpected type node: " + (0, _inspect.default)(typeNode)); + } + } +}); + +// node_modules/graphql/utilities/TypeInfo.js +var require_TypeInfo = __commonJS({ + "node_modules/graphql/utilities/TypeInfo.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.visitWithTypeInfo = visitWithTypeInfo; + exports2.TypeInfo = void 0; + var _find = _interopRequireDefault(require_find()); + var _kinds = require_kinds(); + var _ast = require_ast(); + var _visitor = require_visitor(); + var _definition = require_definition(); + var _introspection = require_introspection(); + var _typeFromAST = require_typeFromAST(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var TypeInfo = /* @__PURE__ */ function() { + function TypeInfo2(schema2, getFieldDefFn, initialType) { + this._schema = schema2; + this._typeStack = []; + this._parentTypeStack = []; + this._inputTypeStack = []; + this._fieldDefStack = []; + this._defaultValueStack = []; + this._directive = null; + this._argument = null; + this._enumValue = null; + this._getFieldDef = getFieldDefFn !== null && getFieldDefFn !== void 0 ? getFieldDefFn : getFieldDef; + if (initialType) { + if ((0, _definition.isInputType)(initialType)) { + this._inputTypeStack.push(initialType); + } + if ((0, _definition.isCompositeType)(initialType)) { + this._parentTypeStack.push(initialType); + } + if ((0, _definition.isOutputType)(initialType)) { + this._typeStack.push(initialType); + } + } + } + var _proto = TypeInfo2.prototype; + _proto.getType = function getType() { + if (this._typeStack.length > 0) { + return this._typeStack[this._typeStack.length - 1]; + } + }; + _proto.getParentType = function getParentType() { + if (this._parentTypeStack.length > 0) { + return this._parentTypeStack[this._parentTypeStack.length - 1]; + } + }; + _proto.getInputType = function getInputType() { + if (this._inputTypeStack.length > 0) { + return this._inputTypeStack[this._inputTypeStack.length - 1]; + } + }; + _proto.getParentInputType = function getParentInputType() { + if (this._inputTypeStack.length > 1) { + return this._inputTypeStack[this._inputTypeStack.length - 2]; + } + }; + _proto.getFieldDef = function getFieldDef2() { + if (this._fieldDefStack.length > 0) { + return this._fieldDefStack[this._fieldDefStack.length - 1]; + } + }; + _proto.getDefaultValue = function getDefaultValue() { + if (this._defaultValueStack.length > 0) { + return this._defaultValueStack[this._defaultValueStack.length - 1]; + } + }; + _proto.getDirective = function getDirective() { + return this._directive; + }; + _proto.getArgument = function getArgument() { + return this._argument; + }; + _proto.getEnumValue = function getEnumValue() { + return this._enumValue; + }; + _proto.enter = function enter(node) { + var schema2 = this._schema; + switch (node.kind) { + case _kinds.Kind.SELECTION_SET: { + var namedType = (0, _definition.getNamedType)(this.getType()); + this._parentTypeStack.push((0, _definition.isCompositeType)(namedType) ? namedType : void 0); + break; + } + case _kinds.Kind.FIELD: { + var parentType = this.getParentType(); + var fieldDef; + var fieldType; + if (parentType) { + fieldDef = this._getFieldDef(schema2, parentType, node); + if (fieldDef) { + fieldType = fieldDef.type; + } + } + this._fieldDefStack.push(fieldDef); + this._typeStack.push((0, _definition.isOutputType)(fieldType) ? fieldType : void 0); + break; + } + case _kinds.Kind.DIRECTIVE: + this._directive = schema2.getDirective(node.name.value); + break; + case _kinds.Kind.OPERATION_DEFINITION: { + var type; + switch (node.operation) { + case "query": + type = schema2.getQueryType(); + break; + case "mutation": + type = schema2.getMutationType(); + break; + case "subscription": + type = schema2.getSubscriptionType(); + break; + } + this._typeStack.push((0, _definition.isObjectType)(type) ? type : void 0); + break; + } + case _kinds.Kind.INLINE_FRAGMENT: + case _kinds.Kind.FRAGMENT_DEFINITION: { + var typeConditionAST = node.typeCondition; + var outputType = typeConditionAST ? (0, _typeFromAST.typeFromAST)(schema2, typeConditionAST) : (0, _definition.getNamedType)(this.getType()); + this._typeStack.push((0, _definition.isOutputType)(outputType) ? outputType : void 0); + break; + } + case _kinds.Kind.VARIABLE_DEFINITION: { + var inputType = (0, _typeFromAST.typeFromAST)(schema2, node.type); + this._inputTypeStack.push((0, _definition.isInputType)(inputType) ? inputType : void 0); + break; + } + case _kinds.Kind.ARGUMENT: { + var _this$getDirective; + var argDef; + var argType; + var fieldOrDirective = (_this$getDirective = this.getDirective()) !== null && _this$getDirective !== void 0 ? _this$getDirective : this.getFieldDef(); + if (fieldOrDirective) { + argDef = (0, _find.default)(fieldOrDirective.args, function(arg) { + return arg.name === node.name.value; + }); + if (argDef) { + argType = argDef.type; + } + } + this._argument = argDef; + this._defaultValueStack.push(argDef ? argDef.defaultValue : void 0); + this._inputTypeStack.push((0, _definition.isInputType)(argType) ? argType : void 0); + break; + } + case _kinds.Kind.LIST: { + var listType = (0, _definition.getNullableType)(this.getInputType()); + var itemType = (0, _definition.isListType)(listType) ? listType.ofType : listType; + this._defaultValueStack.push(void 0); + this._inputTypeStack.push((0, _definition.isInputType)(itemType) ? itemType : void 0); + break; + } + case _kinds.Kind.OBJECT_FIELD: { + var objectType = (0, _definition.getNamedType)(this.getInputType()); + var inputFieldType; + var inputField; + if ((0, _definition.isInputObjectType)(objectType)) { + inputField = objectType.getFields()[node.name.value]; + if (inputField) { + inputFieldType = inputField.type; + } + } + this._defaultValueStack.push(inputField ? inputField.defaultValue : void 0); + this._inputTypeStack.push((0, _definition.isInputType)(inputFieldType) ? inputFieldType : void 0); + break; + } + case _kinds.Kind.ENUM: { + var enumType = (0, _definition.getNamedType)(this.getInputType()); + var enumValue; + if ((0, _definition.isEnumType)(enumType)) { + enumValue = enumType.getValue(node.value); + } + this._enumValue = enumValue; + break; + } + } + }; + _proto.leave = function leave(node) { + switch (node.kind) { + case _kinds.Kind.SELECTION_SET: + this._parentTypeStack.pop(); + break; + case _kinds.Kind.FIELD: + this._fieldDefStack.pop(); + this._typeStack.pop(); + break; + case _kinds.Kind.DIRECTIVE: + this._directive = null; + break; + case _kinds.Kind.OPERATION_DEFINITION: + case _kinds.Kind.INLINE_FRAGMENT: + case _kinds.Kind.FRAGMENT_DEFINITION: + this._typeStack.pop(); + break; + case _kinds.Kind.VARIABLE_DEFINITION: + this._inputTypeStack.pop(); + break; + case _kinds.Kind.ARGUMENT: + this._argument = null; + this._defaultValueStack.pop(); + this._inputTypeStack.pop(); + break; + case _kinds.Kind.LIST: + case _kinds.Kind.OBJECT_FIELD: + this._defaultValueStack.pop(); + this._inputTypeStack.pop(); + break; + case _kinds.Kind.ENUM: + this._enumValue = null; + break; + } + }; + return TypeInfo2; + }(); + exports2.TypeInfo = TypeInfo; + function getFieldDef(schema2, parentType, fieldNode) { + var name = fieldNode.name.value; + if (name === _introspection.SchemaMetaFieldDef.name && schema2.getQueryType() === parentType) { + return _introspection.SchemaMetaFieldDef; + } + if (name === _introspection.TypeMetaFieldDef.name && schema2.getQueryType() === parentType) { + return _introspection.TypeMetaFieldDef; + } + if (name === _introspection.TypeNameMetaFieldDef.name && (0, _definition.isCompositeType)(parentType)) { + return _introspection.TypeNameMetaFieldDef; + } + if ((0, _definition.isObjectType)(parentType) || (0, _definition.isInterfaceType)(parentType)) { + return parentType.getFields()[name]; + } + } + function visitWithTypeInfo(typeInfo, visitor) { + return { + enter: function enter(node) { + typeInfo.enter(node); + var fn = (0, _visitor.getVisitFn)(visitor, node.kind, false); + if (fn) { + var result = fn.apply(visitor, arguments); + if (result !== void 0) { + typeInfo.leave(node); + if ((0, _ast.isNode)(result)) { + typeInfo.enter(result); + } + } + return result; + } + }, + leave: function leave(node) { + var fn = (0, _visitor.getVisitFn)(visitor, node.kind, true); + var result; + if (fn) { + result = fn.apply(visitor, arguments); + } + typeInfo.leave(node); + return result; + } + }; + } + } +}); + +// node_modules/graphql/language/predicates.js +var require_predicates = __commonJS({ + "node_modules/graphql/language/predicates.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.isDefinitionNode = isDefinitionNode; + exports2.isExecutableDefinitionNode = isExecutableDefinitionNode; + exports2.isSelectionNode = isSelectionNode; + exports2.isValueNode = isValueNode; + exports2.isTypeNode = isTypeNode; + exports2.isTypeSystemDefinitionNode = isTypeSystemDefinitionNode; + exports2.isTypeDefinitionNode = isTypeDefinitionNode; + exports2.isTypeSystemExtensionNode = isTypeSystemExtensionNode; + exports2.isTypeExtensionNode = isTypeExtensionNode; + var _kinds = require_kinds(); + function isDefinitionNode(node) { + return isExecutableDefinitionNode(node) || isTypeSystemDefinitionNode(node) || isTypeSystemExtensionNode(node); + } + function isExecutableDefinitionNode(node) { + return node.kind === _kinds.Kind.OPERATION_DEFINITION || node.kind === _kinds.Kind.FRAGMENT_DEFINITION; + } + function isSelectionNode(node) { + return node.kind === _kinds.Kind.FIELD || node.kind === _kinds.Kind.FRAGMENT_SPREAD || node.kind === _kinds.Kind.INLINE_FRAGMENT; + } + function isValueNode(node) { + return node.kind === _kinds.Kind.VARIABLE || node.kind === _kinds.Kind.INT || node.kind === _kinds.Kind.FLOAT || node.kind === _kinds.Kind.STRING || node.kind === _kinds.Kind.BOOLEAN || node.kind === _kinds.Kind.NULL || node.kind === _kinds.Kind.ENUM || node.kind === _kinds.Kind.LIST || node.kind === _kinds.Kind.OBJECT; + } + function isTypeNode(node) { + return node.kind === _kinds.Kind.NAMED_TYPE || node.kind === _kinds.Kind.LIST_TYPE || node.kind === _kinds.Kind.NON_NULL_TYPE; + } + function isTypeSystemDefinitionNode(node) { + return node.kind === _kinds.Kind.SCHEMA_DEFINITION || isTypeDefinitionNode(node) || node.kind === _kinds.Kind.DIRECTIVE_DEFINITION; + } + function isTypeDefinitionNode(node) { + return node.kind === _kinds.Kind.SCALAR_TYPE_DEFINITION || node.kind === _kinds.Kind.OBJECT_TYPE_DEFINITION || node.kind === _kinds.Kind.INTERFACE_TYPE_DEFINITION || node.kind === _kinds.Kind.UNION_TYPE_DEFINITION || node.kind === _kinds.Kind.ENUM_TYPE_DEFINITION || node.kind === _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION; + } + function isTypeSystemExtensionNode(node) { + return node.kind === _kinds.Kind.SCHEMA_EXTENSION || isTypeExtensionNode(node); + } + function isTypeExtensionNode(node) { + return node.kind === _kinds.Kind.SCALAR_TYPE_EXTENSION || node.kind === _kinds.Kind.OBJECT_TYPE_EXTENSION || node.kind === _kinds.Kind.INTERFACE_TYPE_EXTENSION || node.kind === _kinds.Kind.UNION_TYPE_EXTENSION || node.kind === _kinds.Kind.ENUM_TYPE_EXTENSION || node.kind === _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION; + } + } +}); + +// node_modules/graphql/validation/rules/ExecutableDefinitionsRule.js +var require_ExecutableDefinitionsRule = __commonJS({ + "node_modules/graphql/validation/rules/ExecutableDefinitionsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.ExecutableDefinitionsRule = ExecutableDefinitionsRule; + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _predicates = require_predicates(); + function ExecutableDefinitionsRule(context) { + return { + Document: function Document(node) { + for (var _i2 = 0, _node$definitions2 = node.definitions; _i2 < _node$definitions2.length; _i2++) { + var definition = _node$definitions2[_i2]; + if (!(0, _predicates.isExecutableDefinitionNode)(definition)) { + var defName = definition.kind === _kinds.Kind.SCHEMA_DEFINITION || definition.kind === _kinds.Kind.SCHEMA_EXTENSION ? "schema" : '"' + definition.name.value + '"'; + context.reportError(new _GraphQLError.GraphQLError("The ".concat(defName, " definition is not executable."), definition)); + } + } + return false; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/UniqueOperationNamesRule.js +var require_UniqueOperationNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueOperationNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueOperationNamesRule = UniqueOperationNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueOperationNamesRule(context) { + var knownOperationNames = Object.create(null); + return { + OperationDefinition: function OperationDefinition(node) { + var operationName = node.name; + if (operationName) { + if (knownOperationNames[operationName.value]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one operation named "'.concat(operationName.value, '".'), [knownOperationNames[operationName.value], operationName])); + } else { + knownOperationNames[operationName.value] = operationName; + } + } + return false; + }, + FragmentDefinition: function FragmentDefinition() { + return false; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/LoneAnonymousOperationRule.js +var require_LoneAnonymousOperationRule = __commonJS({ + "node_modules/graphql/validation/rules/LoneAnonymousOperationRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.LoneAnonymousOperationRule = LoneAnonymousOperationRule; + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + function LoneAnonymousOperationRule(context) { + var operationCount = 0; + return { + Document: function Document(node) { + operationCount = node.definitions.filter(function(definition) { + return definition.kind === _kinds.Kind.OPERATION_DEFINITION; + }).length; + }, + OperationDefinition: function OperationDefinition(node) { + if (!node.name && operationCount > 1) { + context.reportError(new _GraphQLError.GraphQLError("This anonymous operation must be the only defined operation.", node)); + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/SingleFieldSubscriptionsRule.js +var require_SingleFieldSubscriptionsRule = __commonJS({ + "node_modules/graphql/validation/rules/SingleFieldSubscriptionsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.SingleFieldSubscriptionsRule = SingleFieldSubscriptionsRule; + var _GraphQLError = require_GraphQLError(); + function SingleFieldSubscriptionsRule(context) { + return { + OperationDefinition: function OperationDefinition(node) { + if (node.operation === "subscription") { + if (node.selectionSet.selections.length !== 1) { + context.reportError(new _GraphQLError.GraphQLError(node.name ? 'Subscription "'.concat(node.name.value, '" must select only one top level field.') : "Anonymous Subscription must select only one top level field.", node.selectionSet.selections.slice(1))); + } + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/KnownTypeNamesRule.js +var require_KnownTypeNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/KnownTypeNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.KnownTypeNamesRule = KnownTypeNamesRule; + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _GraphQLError = require_GraphQLError(); + var _predicates = require_predicates(); + var _scalars = require_scalars(); + var _introspection = require_introspection(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function KnownTypeNamesRule(context) { + var schema2 = context.getSchema(); + var existingTypesMap = schema2 ? schema2.getTypeMap() : Object.create(null); + var definedTypes = Object.create(null); + for (var _i2 = 0, _context$getDocument$2 = context.getDocument().definitions; _i2 < _context$getDocument$2.length; _i2++) { + var def = _context$getDocument$2[_i2]; + if ((0, _predicates.isTypeDefinitionNode)(def)) { + definedTypes[def.name.value] = true; + } + } + var typeNames = Object.keys(existingTypesMap).concat(Object.keys(definedTypes)); + return { + NamedType: function NamedType(node, _1, parent, _2, ancestors) { + var typeName = node.name.value; + if (!existingTypesMap[typeName] && !definedTypes[typeName]) { + var _ancestors$; + var definitionNode = (_ancestors$ = ancestors[2]) !== null && _ancestors$ !== void 0 ? _ancestors$ : parent; + var isSDL = definitionNode != null && isSDLNode(definitionNode); + if (isSDL && isStandardTypeName(typeName)) { + return; + } + var suggestedTypes = (0, _suggestionList.default)(typeName, isSDL ? standardTypeNames.concat(typeNames) : typeNames); + context.reportError(new _GraphQLError.GraphQLError('Unknown type "'.concat(typeName, '".') + (0, _didYouMean.default)(suggestedTypes), node)); + } + } + }; + } + var standardTypeNames = [].concat(_scalars.specifiedScalarTypes, _introspection.introspectionTypes).map(function(type) { + return type.name; + }); + function isStandardTypeName(typeName) { + return standardTypeNames.indexOf(typeName) !== -1; + } + function isSDLNode(value) { + return !Array.isArray(value) && ((0, _predicates.isTypeSystemDefinitionNode)(value) || (0, _predicates.isTypeSystemExtensionNode)(value)); + } + } +}); + +// node_modules/graphql/validation/rules/FragmentsOnCompositeTypesRule.js +var require_FragmentsOnCompositeTypesRule = __commonJS({ + "node_modules/graphql/validation/rules/FragmentsOnCompositeTypesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.FragmentsOnCompositeTypesRule = FragmentsOnCompositeTypesRule; + var _GraphQLError = require_GraphQLError(); + var _printer = require_printer(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + function FragmentsOnCompositeTypesRule(context) { + return { + InlineFragment: function InlineFragment(node) { + var typeCondition = node.typeCondition; + if (typeCondition) { + var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition); + if (type && !(0, _definition.isCompositeType)(type)) { + var typeStr = (0, _printer.print)(typeCondition); + context.reportError(new _GraphQLError.GraphQLError('Fragment cannot condition on non composite type "'.concat(typeStr, '".'), typeCondition)); + } + } + }, + FragmentDefinition: function FragmentDefinition(node) { + var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.typeCondition); + if (type && !(0, _definition.isCompositeType)(type)) { + var typeStr = (0, _printer.print)(node.typeCondition); + context.reportError(new _GraphQLError.GraphQLError('Fragment "'.concat(node.name.value, '" cannot condition on non composite type "').concat(typeStr, '".'), node.typeCondition)); + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/VariablesAreInputTypesRule.js +var require_VariablesAreInputTypesRule = __commonJS({ + "node_modules/graphql/validation/rules/VariablesAreInputTypesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.VariablesAreInputTypesRule = VariablesAreInputTypesRule; + var _GraphQLError = require_GraphQLError(); + var _printer = require_printer(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + function VariablesAreInputTypesRule(context) { + return { + VariableDefinition: function VariableDefinition(node) { + var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.type); + if (type && !(0, _definition.isInputType)(type)) { + var variableName = node.variable.name.value; + var typeName = (0, _printer.print)(node.type); + context.reportError(new _GraphQLError.GraphQLError('Variable "$'.concat(variableName, '" cannot be non-input type "').concat(typeName, '".'), node.type)); + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/ScalarLeafsRule.js +var require_ScalarLeafsRule = __commonJS({ + "node_modules/graphql/validation/rules/ScalarLeafsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.ScalarLeafsRule = ScalarLeafsRule; + var _inspect = _interopRequireDefault(require_inspect()); + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ScalarLeafsRule(context) { + return { + Field: function Field(node) { + var type = context.getType(); + var selectionSet = node.selectionSet; + if (type) { + if ((0, _definition.isLeafType)((0, _definition.getNamedType)(type))) { + if (selectionSet) { + var fieldName = node.name.value; + var typeStr = (0, _inspect.default)(type); + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(fieldName, '" must not have a selection since type "').concat(typeStr, '" has no subfields.'), selectionSet)); + } + } else if (!selectionSet) { + var _fieldName = node.name.value; + var _typeStr = (0, _inspect.default)(type); + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(_fieldName, '" of type "').concat(_typeStr, '" must have a selection of subfields. Did you mean "').concat(_fieldName, ' { ... }"?'), node)); + } + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.js +var require_FieldsOnCorrectTypeRule = __commonJS({ + "node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.FieldsOnCorrectTypeRule = FieldsOnCorrectTypeRule; + var _arrayFrom = _interopRequireDefault(require_arrayFrom()); + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _naturalCompare = _interopRequireDefault(require_naturalCompare()); + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function FieldsOnCorrectTypeRule(context) { + return { + Field: function Field(node) { + var type = context.getParentType(); + if (type) { + var fieldDef = context.getFieldDef(); + if (!fieldDef) { + var schema2 = context.getSchema(); + var fieldName = node.name.value; + var suggestion = (0, _didYouMean.default)("to use an inline fragment on", getSuggestedTypeNames(schema2, type, fieldName)); + if (suggestion === "") { + suggestion = (0, _didYouMean.default)(getSuggestedFieldNames(type, fieldName)); + } + context.reportError(new _GraphQLError.GraphQLError('Cannot query field "'.concat(fieldName, '" on type "').concat(type.name, '".') + suggestion, node)); + } + } + } + }; + } + function getSuggestedTypeNames(schema2, type, fieldName) { + if (!(0, _definition.isAbstractType)(type)) { + return []; + } + var suggestedTypes = new Set(); + var usageCount = Object.create(null); + for (var _i2 = 0, _schema$getPossibleTy2 = schema2.getPossibleTypes(type); _i2 < _schema$getPossibleTy2.length; _i2++) { + var possibleType = _schema$getPossibleTy2[_i2]; + if (!possibleType.getFields()[fieldName]) { + continue; + } + suggestedTypes.add(possibleType); + usageCount[possibleType.name] = 1; + for (var _i4 = 0, _possibleType$getInte2 = possibleType.getInterfaces(); _i4 < _possibleType$getInte2.length; _i4++) { + var _usageCount$possibleI; + var possibleInterface = _possibleType$getInte2[_i4]; + if (!possibleInterface.getFields()[fieldName]) { + continue; + } + suggestedTypes.add(possibleInterface); + usageCount[possibleInterface.name] = ((_usageCount$possibleI = usageCount[possibleInterface.name]) !== null && _usageCount$possibleI !== void 0 ? _usageCount$possibleI : 0) + 1; + } + } + return (0, _arrayFrom.default)(suggestedTypes).sort(function(typeA, typeB) { + var usageCountDiff = usageCount[typeB.name] - usageCount[typeA.name]; + if (usageCountDiff !== 0) { + return usageCountDiff; + } + if ((0, _definition.isInterfaceType)(typeA) && schema2.isSubType(typeA, typeB)) { + return -1; + } + if ((0, _definition.isInterfaceType)(typeB) && schema2.isSubType(typeB, typeA)) { + return 1; + } + return (0, _naturalCompare.default)(typeA.name, typeB.name); + }).map(function(x) { + return x.name; + }); + } + function getSuggestedFieldNames(type, fieldName) { + if ((0, _definition.isObjectType)(type) || (0, _definition.isInterfaceType)(type)) { + var possibleFieldNames = Object.keys(type.getFields()); + return (0, _suggestionList.default)(fieldName, possibleFieldNames); + } + return []; + } + } +}); + +// node_modules/graphql/validation/rules/UniqueFragmentNamesRule.js +var require_UniqueFragmentNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueFragmentNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueFragmentNamesRule = UniqueFragmentNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueFragmentNamesRule(context) { + var knownFragmentNames = Object.create(null); + return { + OperationDefinition: function OperationDefinition() { + return false; + }, + FragmentDefinition: function FragmentDefinition(node) { + var fragmentName = node.name.value; + if (knownFragmentNames[fragmentName]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one fragment named "'.concat(fragmentName, '".'), [knownFragmentNames[fragmentName], node.name])); + } else { + knownFragmentNames[fragmentName] = node.name; + } + return false; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/KnownFragmentNamesRule.js +var require_KnownFragmentNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/KnownFragmentNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.KnownFragmentNamesRule = KnownFragmentNamesRule; + var _GraphQLError = require_GraphQLError(); + function KnownFragmentNamesRule(context) { + return { + FragmentSpread: function FragmentSpread(node) { + var fragmentName = node.name.value; + var fragment = context.getFragment(fragmentName); + if (!fragment) { + context.reportError(new _GraphQLError.GraphQLError('Unknown fragment "'.concat(fragmentName, '".'), node.name)); + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/NoUnusedFragmentsRule.js +var require_NoUnusedFragmentsRule = __commonJS({ + "node_modules/graphql/validation/rules/NoUnusedFragmentsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.NoUnusedFragmentsRule = NoUnusedFragmentsRule; + var _GraphQLError = require_GraphQLError(); + function NoUnusedFragmentsRule(context) { + var operationDefs = []; + var fragmentDefs = []; + return { + OperationDefinition: function OperationDefinition(node) { + operationDefs.push(node); + return false; + }, + FragmentDefinition: function FragmentDefinition(node) { + fragmentDefs.push(node); + return false; + }, + Document: { + leave: function leave() { + var fragmentNameUsed = Object.create(null); + for (var _i2 = 0; _i2 < operationDefs.length; _i2++) { + var operation = operationDefs[_i2]; + for (var _i4 = 0, _context$getRecursive2 = context.getRecursivelyReferencedFragments(operation); _i4 < _context$getRecursive2.length; _i4++) { + var fragment = _context$getRecursive2[_i4]; + fragmentNameUsed[fragment.name.value] = true; + } + } + for (var _i6 = 0; _i6 < fragmentDefs.length; _i6++) { + var fragmentDef = fragmentDefs[_i6]; + var fragName = fragmentDef.name.value; + if (fragmentNameUsed[fragName] !== true) { + context.reportError(new _GraphQLError.GraphQLError('Fragment "'.concat(fragName, '" is never used.'), fragmentDef)); + } + } + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/PossibleFragmentSpreadsRule.js +var require_PossibleFragmentSpreadsRule = __commonJS({ + "node_modules/graphql/validation/rules/PossibleFragmentSpreadsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.PossibleFragmentSpreadsRule = PossibleFragmentSpreadsRule; + var _inspect = _interopRequireDefault(require_inspect()); + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + var _typeComparators = require_typeComparators(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function PossibleFragmentSpreadsRule(context) { + return { + InlineFragment: function InlineFragment(node) { + var fragType = context.getType(); + var parentType = context.getParentType(); + if ((0, _definition.isCompositeType)(fragType) && (0, _definition.isCompositeType)(parentType) && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) { + var parentTypeStr = (0, _inspect.default)(parentType); + var fragTypeStr = (0, _inspect.default)(fragType); + context.reportError(new _GraphQLError.GraphQLError('Fragment cannot be spread here as objects of type "'.concat(parentTypeStr, '" can never be of type "').concat(fragTypeStr, '".'), node)); + } + }, + FragmentSpread: function FragmentSpread(node) { + var fragName = node.name.value; + var fragType = getFragmentType(context, fragName); + var parentType = context.getParentType(); + if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) { + var parentTypeStr = (0, _inspect.default)(parentType); + var fragTypeStr = (0, _inspect.default)(fragType); + context.reportError(new _GraphQLError.GraphQLError('Fragment "'.concat(fragName, '" cannot be spread here as objects of type "').concat(parentTypeStr, '" can never be of type "').concat(fragTypeStr, '".'), node)); + } + } + }; + } + function getFragmentType(context, name) { + var frag = context.getFragment(name); + if (frag) { + var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), frag.typeCondition); + if ((0, _definition.isCompositeType)(type)) { + return type; + } + } + } + } +}); + +// node_modules/graphql/validation/rules/NoFragmentCyclesRule.js +var require_NoFragmentCyclesRule = __commonJS({ + "node_modules/graphql/validation/rules/NoFragmentCyclesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.NoFragmentCyclesRule = NoFragmentCyclesRule; + var _GraphQLError = require_GraphQLError(); + function NoFragmentCyclesRule(context) { + var visitedFrags = Object.create(null); + var spreadPath = []; + var spreadPathIndexByName = Object.create(null); + return { + OperationDefinition: function OperationDefinition() { + return false; + }, + FragmentDefinition: function FragmentDefinition(node) { + detectCycleRecursive(node); + return false; + } + }; + function detectCycleRecursive(fragment) { + if (visitedFrags[fragment.name.value]) { + return; + } + var fragmentName = fragment.name.value; + visitedFrags[fragmentName] = true; + var spreadNodes = context.getFragmentSpreads(fragment.selectionSet); + if (spreadNodes.length === 0) { + return; + } + spreadPathIndexByName[fragmentName] = spreadPath.length; + for (var _i2 = 0; _i2 < spreadNodes.length; _i2++) { + var spreadNode = spreadNodes[_i2]; + var spreadName = spreadNode.name.value; + var cycleIndex = spreadPathIndexByName[spreadName]; + spreadPath.push(spreadNode); + if (cycleIndex === void 0) { + var spreadFragment = context.getFragment(spreadName); + if (spreadFragment) { + detectCycleRecursive(spreadFragment); + } + } else { + var cyclePath = spreadPath.slice(cycleIndex); + var viaPath = cyclePath.slice(0, -1).map(function(s) { + return '"' + s.name.value + '"'; + }).join(", "); + context.reportError(new _GraphQLError.GraphQLError('Cannot spread fragment "'.concat(spreadName, '" within itself') + (viaPath !== "" ? " via ".concat(viaPath, ".") : "."), cyclePath)); + } + spreadPath.pop(); + } + spreadPathIndexByName[fragmentName] = void 0; + } + } + } +}); + +// node_modules/graphql/validation/rules/UniqueVariableNamesRule.js +var require_UniqueVariableNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueVariableNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueVariableNamesRule = UniqueVariableNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueVariableNamesRule(context) { + var knownVariableNames = Object.create(null); + return { + OperationDefinition: function OperationDefinition() { + knownVariableNames = Object.create(null); + }, + VariableDefinition: function VariableDefinition(node) { + var variableName = node.variable.name.value; + if (knownVariableNames[variableName]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one variable named "$'.concat(variableName, '".'), [knownVariableNames[variableName], node.variable.name])); + } else { + knownVariableNames[variableName] = node.variable.name; + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/NoUndefinedVariablesRule.js +var require_NoUndefinedVariablesRule = __commonJS({ + "node_modules/graphql/validation/rules/NoUndefinedVariablesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.NoUndefinedVariablesRule = NoUndefinedVariablesRule; + var _GraphQLError = require_GraphQLError(); + function NoUndefinedVariablesRule(context) { + var variableNameDefined = Object.create(null); + return { + OperationDefinition: { + enter: function enter() { + variableNameDefined = Object.create(null); + }, + leave: function leave(operation) { + var usages = context.getRecursiveVariableUsages(operation); + for (var _i2 = 0; _i2 < usages.length; _i2++) { + var _ref2 = usages[_i2]; + var node = _ref2.node; + var varName = node.name.value; + if (variableNameDefined[varName] !== true) { + context.reportError(new _GraphQLError.GraphQLError(operation.name ? 'Variable "$'.concat(varName, '" is not defined by operation "').concat(operation.name.value, '".') : 'Variable "$'.concat(varName, '" is not defined.'), [node, operation])); + } + } + } + }, + VariableDefinition: function VariableDefinition(node) { + variableNameDefined[node.variable.name.value] = true; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/NoUnusedVariablesRule.js +var require_NoUnusedVariablesRule = __commonJS({ + "node_modules/graphql/validation/rules/NoUnusedVariablesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.NoUnusedVariablesRule = NoUnusedVariablesRule; + var _GraphQLError = require_GraphQLError(); + function NoUnusedVariablesRule(context) { + var variableDefs = []; + return { + OperationDefinition: { + enter: function enter() { + variableDefs = []; + }, + leave: function leave(operation) { + var variableNameUsed = Object.create(null); + var usages = context.getRecursiveVariableUsages(operation); + for (var _i2 = 0; _i2 < usages.length; _i2++) { + var _ref2 = usages[_i2]; + var node = _ref2.node; + variableNameUsed[node.name.value] = true; + } + for (var _i4 = 0, _variableDefs2 = variableDefs; _i4 < _variableDefs2.length; _i4++) { + var variableDef = _variableDefs2[_i4]; + var variableName = variableDef.variable.name.value; + if (variableNameUsed[variableName] !== true) { + context.reportError(new _GraphQLError.GraphQLError(operation.name ? 'Variable "$'.concat(variableName, '" is never used in operation "').concat(operation.name.value, '".') : 'Variable "$'.concat(variableName, '" is never used.'), variableDef)); + } + } + } + }, + VariableDefinition: function VariableDefinition(def) { + variableDefs.push(def); + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/KnownDirectivesRule.js +var require_KnownDirectivesRule = __commonJS({ + "node_modules/graphql/validation/rules/KnownDirectivesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.KnownDirectivesRule = KnownDirectivesRule; + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _directiveLocation = require_directiveLocation(); + var _directives = require_directives(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function KnownDirectivesRule(context) { + var locationsMap = Object.create(null); + var schema2 = context.getSchema(); + var definedDirectives = schema2 ? schema2.getDirectives() : _directives.specifiedDirectives; + for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) { + var directive = definedDirectives[_i2]; + locationsMap[directive.name] = directive.locations; + } + var astDefinitions = context.getDocument().definitions; + for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) { + var def = astDefinitions[_i4]; + if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) { + locationsMap[def.name.value] = def.locations.map(function(name) { + return name.value; + }); + } + } + return { + Directive: function Directive(node, _key, _parent, _path, ancestors) { + var name = node.name.value; + var locations = locationsMap[name]; + if (!locations) { + context.reportError(new _GraphQLError.GraphQLError('Unknown directive "@'.concat(name, '".'), node)); + return; + } + var candidateLocation = getDirectiveLocationForASTPath(ancestors); + if (candidateLocation && locations.indexOf(candidateLocation) === -1) { + context.reportError(new _GraphQLError.GraphQLError('Directive "@'.concat(name, '" may not be used on ').concat(candidateLocation, "."), node)); + } + } + }; + } + function getDirectiveLocationForASTPath(ancestors) { + var appliedTo = ancestors[ancestors.length - 1]; + !Array.isArray(appliedTo) || (0, _invariant.default)(0); + switch (appliedTo.kind) { + case _kinds.Kind.OPERATION_DEFINITION: + return getDirectiveLocationForOperation(appliedTo.operation); + case _kinds.Kind.FIELD: + return _directiveLocation.DirectiveLocation.FIELD; + case _kinds.Kind.FRAGMENT_SPREAD: + return _directiveLocation.DirectiveLocation.FRAGMENT_SPREAD; + case _kinds.Kind.INLINE_FRAGMENT: + return _directiveLocation.DirectiveLocation.INLINE_FRAGMENT; + case _kinds.Kind.FRAGMENT_DEFINITION: + return _directiveLocation.DirectiveLocation.FRAGMENT_DEFINITION; + case _kinds.Kind.VARIABLE_DEFINITION: + return _directiveLocation.DirectiveLocation.VARIABLE_DEFINITION; + case _kinds.Kind.SCHEMA_DEFINITION: + case _kinds.Kind.SCHEMA_EXTENSION: + return _directiveLocation.DirectiveLocation.SCHEMA; + case _kinds.Kind.SCALAR_TYPE_DEFINITION: + case _kinds.Kind.SCALAR_TYPE_EXTENSION: + return _directiveLocation.DirectiveLocation.SCALAR; + case _kinds.Kind.OBJECT_TYPE_DEFINITION: + case _kinds.Kind.OBJECT_TYPE_EXTENSION: + return _directiveLocation.DirectiveLocation.OBJECT; + case _kinds.Kind.FIELD_DEFINITION: + return _directiveLocation.DirectiveLocation.FIELD_DEFINITION; + case _kinds.Kind.INTERFACE_TYPE_DEFINITION: + case _kinds.Kind.INTERFACE_TYPE_EXTENSION: + return _directiveLocation.DirectiveLocation.INTERFACE; + case _kinds.Kind.UNION_TYPE_DEFINITION: + case _kinds.Kind.UNION_TYPE_EXTENSION: + return _directiveLocation.DirectiveLocation.UNION; + case _kinds.Kind.ENUM_TYPE_DEFINITION: + case _kinds.Kind.ENUM_TYPE_EXTENSION: + return _directiveLocation.DirectiveLocation.ENUM; + case _kinds.Kind.ENUM_VALUE_DEFINITION: + return _directiveLocation.DirectiveLocation.ENUM_VALUE; + case _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION: + case _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION: + return _directiveLocation.DirectiveLocation.INPUT_OBJECT; + case _kinds.Kind.INPUT_VALUE_DEFINITION: { + var parentNode = ancestors[ancestors.length - 3]; + return parentNode.kind === _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION ? _directiveLocation.DirectiveLocation.INPUT_FIELD_DEFINITION : _directiveLocation.DirectiveLocation.ARGUMENT_DEFINITION; + } + } + } + function getDirectiveLocationForOperation(operation) { + switch (operation) { + case "query": + return _directiveLocation.DirectiveLocation.QUERY; + case "mutation": + return _directiveLocation.DirectiveLocation.MUTATION; + case "subscription": + return _directiveLocation.DirectiveLocation.SUBSCRIPTION; + } + (0, _invariant.default)(0, "Unexpected operation: " + (0, _inspect.default)(operation)); + } + } +}); + +// node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.js +var require_UniqueDirectivesPerLocationRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueDirectivesPerLocationRule = UniqueDirectivesPerLocationRule; + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _predicates = require_predicates(); + var _directives = require_directives(); + function UniqueDirectivesPerLocationRule(context) { + var uniqueDirectiveMap = Object.create(null); + var schema2 = context.getSchema(); + var definedDirectives = schema2 ? schema2.getDirectives() : _directives.specifiedDirectives; + for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) { + var directive = definedDirectives[_i2]; + uniqueDirectiveMap[directive.name] = !directive.isRepeatable; + } + var astDefinitions = context.getDocument().definitions; + for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) { + var def = astDefinitions[_i4]; + if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) { + uniqueDirectiveMap[def.name.value] = !def.repeatable; + } + } + var schemaDirectives = Object.create(null); + var typeDirectivesMap = Object.create(null); + return { + enter: function enter(node) { + if (node.directives == null) { + return; + } + var seenDirectives; + if (node.kind === _kinds.Kind.SCHEMA_DEFINITION || node.kind === _kinds.Kind.SCHEMA_EXTENSION) { + seenDirectives = schemaDirectives; + } else if ((0, _predicates.isTypeDefinitionNode)(node) || (0, _predicates.isTypeExtensionNode)(node)) { + var typeName = node.name.value; + seenDirectives = typeDirectivesMap[typeName]; + if (seenDirectives === void 0) { + typeDirectivesMap[typeName] = seenDirectives = Object.create(null); + } + } else { + seenDirectives = Object.create(null); + } + for (var _i6 = 0, _node$directives2 = node.directives; _i6 < _node$directives2.length; _i6++) { + var _directive = _node$directives2[_i6]; + var directiveName = _directive.name.value; + if (uniqueDirectiveMap[directiveName]) { + if (seenDirectives[directiveName]) { + context.reportError(new _GraphQLError.GraphQLError('The directive "@'.concat(directiveName, '" can only be used once at this location.'), [seenDirectives[directiveName], _directive])); + } else { + seenDirectives[directiveName] = _directive; + } + } + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/KnownArgumentNamesRule.js +var require_KnownArgumentNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/KnownArgumentNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.KnownArgumentNamesRule = KnownArgumentNamesRule; + exports2.KnownArgumentNamesOnDirectivesRule = KnownArgumentNamesOnDirectivesRule; + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _directives = require_directives(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function KnownArgumentNamesRule(context) { + return _objectSpread(_objectSpread({}, KnownArgumentNamesOnDirectivesRule(context)), {}, { + Argument: function Argument(argNode) { + var argDef = context.getArgument(); + var fieldDef = context.getFieldDef(); + var parentType = context.getParentType(); + if (!argDef && fieldDef && parentType) { + var argName = argNode.name.value; + var knownArgsNames = fieldDef.args.map(function(arg) { + return arg.name; + }); + var suggestions = (0, _suggestionList.default)(argName, knownArgsNames); + context.reportError(new _GraphQLError.GraphQLError('Unknown argument "'.concat(argName, '" on field "').concat(parentType.name, ".").concat(fieldDef.name, '".') + (0, _didYouMean.default)(suggestions), argNode)); + } + } + }); + } + function KnownArgumentNamesOnDirectivesRule(context) { + var directiveArgs = Object.create(null); + var schema2 = context.getSchema(); + var definedDirectives = schema2 ? schema2.getDirectives() : _directives.specifiedDirectives; + for (var _i2 = 0; _i2 < definedDirectives.length; _i2++) { + var directive = definedDirectives[_i2]; + directiveArgs[directive.name] = directive.args.map(function(arg) { + return arg.name; + }); + } + var astDefinitions = context.getDocument().definitions; + for (var _i4 = 0; _i4 < astDefinitions.length; _i4++) { + var def = astDefinitions[_i4]; + if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) { + var _def$arguments; + var argsNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : []; + directiveArgs[def.name.value] = argsNodes.map(function(arg) { + return arg.name.value; + }); + } + } + return { + Directive: function Directive(directiveNode) { + var directiveName = directiveNode.name.value; + var knownArgs = directiveArgs[directiveName]; + if (directiveNode.arguments && knownArgs) { + for (var _i6 = 0, _directiveNode$argume2 = directiveNode.arguments; _i6 < _directiveNode$argume2.length; _i6++) { + var argNode = _directiveNode$argume2[_i6]; + var argName = argNode.name.value; + if (knownArgs.indexOf(argName) === -1) { + var suggestions = (0, _suggestionList.default)(argName, knownArgs); + context.reportError(new _GraphQLError.GraphQLError('Unknown argument "'.concat(argName, '" on directive "@').concat(directiveName, '".') + (0, _didYouMean.default)(suggestions), argNode)); + } + } + } + return false; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/UniqueArgumentNamesRule.js +var require_UniqueArgumentNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueArgumentNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueArgumentNamesRule = UniqueArgumentNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueArgumentNamesRule(context) { + var knownArgNames = Object.create(null); + return { + Field: function Field() { + knownArgNames = Object.create(null); + }, + Directive: function Directive() { + knownArgNames = Object.create(null); + }, + Argument: function Argument(node) { + var argName = node.name.value; + if (knownArgNames[argName]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one argument named "'.concat(argName, '".'), [knownArgNames[argName], node.name])); + } else { + knownArgNames[argName] = node.name; + } + return false; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.js +var require_ValuesOfCorrectTypeRule = __commonJS({ + "node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.ValuesOfCorrectTypeRule = ValuesOfCorrectTypeRule; + var _objectValues3 = _interopRequireDefault(require_objectValues()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _inspect = _interopRequireDefault(require_inspect()); + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _GraphQLError = require_GraphQLError(); + var _printer = require_printer(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ValuesOfCorrectTypeRule(context) { + return { + ListValue: function ListValue(node) { + var type = (0, _definition.getNullableType)(context.getParentInputType()); + if (!(0, _definition.isListType)(type)) { + isValidValueNode(context, node); + return false; + } + }, + ObjectValue: function ObjectValue(node) { + var type = (0, _definition.getNamedType)(context.getInputType()); + if (!(0, _definition.isInputObjectType)(type)) { + isValidValueNode(context, node); + return false; + } + var fieldNodeMap = (0, _keyMap.default)(node.fields, function(field) { + return field.name.value; + }); + for (var _i2 = 0, _objectValues2 = (0, _objectValues3.default)(type.getFields()); _i2 < _objectValues2.length; _i2++) { + var fieldDef = _objectValues2[_i2]; + var fieldNode = fieldNodeMap[fieldDef.name]; + if (!fieldNode && (0, _definition.isRequiredInputField)(fieldDef)) { + var typeStr = (0, _inspect.default)(fieldDef.type); + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(type.name, ".").concat(fieldDef.name, '" of required type "').concat(typeStr, '" was not provided.'), node)); + } + } + }, + ObjectField: function ObjectField(node) { + var parentType = (0, _definition.getNamedType)(context.getParentInputType()); + var fieldType = context.getInputType(); + if (!fieldType && (0, _definition.isInputObjectType)(parentType)) { + var suggestions = (0, _suggestionList.default)(node.name.value, Object.keys(parentType.getFields())); + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(node.name.value, '" is not defined by type "').concat(parentType.name, '".') + (0, _didYouMean.default)(suggestions), node)); + } + }, + NullValue: function NullValue(node) { + var type = context.getInputType(); + if ((0, _definition.isNonNullType)(type)) { + context.reportError(new _GraphQLError.GraphQLError('Expected value of type "'.concat((0, _inspect.default)(type), '", found ').concat((0, _printer.print)(node), "."), node)); + } + }, + EnumValue: function EnumValue(node) { + return isValidValueNode(context, node); + }, + IntValue: function IntValue(node) { + return isValidValueNode(context, node); + }, + FloatValue: function FloatValue(node) { + return isValidValueNode(context, node); + }, + StringValue: function StringValue(node) { + return isValidValueNode(context, node); + }, + BooleanValue: function BooleanValue(node) { + return isValidValueNode(context, node); + } + }; + } + function isValidValueNode(context, node) { + var locationType = context.getInputType(); + if (!locationType) { + return; + } + var type = (0, _definition.getNamedType)(locationType); + if (!(0, _definition.isLeafType)(type)) { + var typeStr = (0, _inspect.default)(locationType); + context.reportError(new _GraphQLError.GraphQLError('Expected value of type "'.concat(typeStr, '", found ').concat((0, _printer.print)(node), "."), node)); + return; + } + try { + var parseResult = type.parseLiteral(node, void 0); + if (parseResult === void 0) { + var _typeStr = (0, _inspect.default)(locationType); + context.reportError(new _GraphQLError.GraphQLError('Expected value of type "'.concat(_typeStr, '", found ').concat((0, _printer.print)(node), "."), node)); + } + } catch (error) { + var _typeStr2 = (0, _inspect.default)(locationType); + if (error instanceof _GraphQLError.GraphQLError) { + context.reportError(error); + } else { + context.reportError(new _GraphQLError.GraphQLError('Expected value of type "'.concat(_typeStr2, '", found ').concat((0, _printer.print)(node), "; ") + error.message, node, void 0, void 0, void 0, error)); + } + } + } + } +}); + +// node_modules/graphql/validation/rules/ProvidedRequiredArgumentsRule.js +var require_ProvidedRequiredArgumentsRule = __commonJS({ + "node_modules/graphql/validation/rules/ProvidedRequiredArgumentsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.ProvidedRequiredArgumentsRule = ProvidedRequiredArgumentsRule; + exports2.ProvidedRequiredArgumentsOnDirectivesRule = ProvidedRequiredArgumentsOnDirectivesRule; + var _inspect = _interopRequireDefault(require_inspect()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _printer = require_printer(); + var _directives = require_directives(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function ProvidedRequiredArgumentsRule(context) { + return _objectSpread(_objectSpread({}, ProvidedRequiredArgumentsOnDirectivesRule(context)), {}, { + Field: { + leave: function leave(fieldNode) { + var _fieldNode$arguments; + var fieldDef = context.getFieldDef(); + if (!fieldDef) { + return false; + } + var argNodes = (_fieldNode$arguments = fieldNode.arguments) !== null && _fieldNode$arguments !== void 0 ? _fieldNode$arguments : []; + var argNodeMap = (0, _keyMap.default)(argNodes, function(arg) { + return arg.name.value; + }); + for (var _i2 = 0, _fieldDef$args2 = fieldDef.args; _i2 < _fieldDef$args2.length; _i2++) { + var argDef = _fieldDef$args2[_i2]; + var argNode = argNodeMap[argDef.name]; + if (!argNode && (0, _definition.isRequiredArgument)(argDef)) { + var argTypeStr = (0, _inspect.default)(argDef.type); + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(fieldDef.name, '" argument "').concat(argDef.name, '" of type "').concat(argTypeStr, '" is required, but it was not provided.'), fieldNode)); + } + } + } + } + }); + } + function ProvidedRequiredArgumentsOnDirectivesRule(context) { + var requiredArgsMap = Object.create(null); + var schema2 = context.getSchema(); + var definedDirectives = schema2 ? schema2.getDirectives() : _directives.specifiedDirectives; + for (var _i4 = 0; _i4 < definedDirectives.length; _i4++) { + var directive = definedDirectives[_i4]; + requiredArgsMap[directive.name] = (0, _keyMap.default)(directive.args.filter(_definition.isRequiredArgument), function(arg) { + return arg.name; + }); + } + var astDefinitions = context.getDocument().definitions; + for (var _i6 = 0; _i6 < astDefinitions.length; _i6++) { + var def = astDefinitions[_i6]; + if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) { + var _def$arguments; + var argNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : []; + requiredArgsMap[def.name.value] = (0, _keyMap.default)(argNodes.filter(isRequiredArgumentNode), function(arg) { + return arg.name.value; + }); + } + } + return { + Directive: { + leave: function leave(directiveNode) { + var directiveName = directiveNode.name.value; + var requiredArgs = requiredArgsMap[directiveName]; + if (requiredArgs) { + var _directiveNode$argume; + var _argNodes = (_directiveNode$argume = directiveNode.arguments) !== null && _directiveNode$argume !== void 0 ? _directiveNode$argume : []; + var argNodeMap = (0, _keyMap.default)(_argNodes, function(arg) { + return arg.name.value; + }); + for (var _i8 = 0, _Object$keys2 = Object.keys(requiredArgs); _i8 < _Object$keys2.length; _i8++) { + var argName = _Object$keys2[_i8]; + if (!argNodeMap[argName]) { + var argType = requiredArgs[argName].type; + var argTypeStr = (0, _definition.isType)(argType) ? (0, _inspect.default)(argType) : (0, _printer.print)(argType); + context.reportError(new _GraphQLError.GraphQLError('Directive "@'.concat(directiveName, '" argument "').concat(argName, '" of type "').concat(argTypeStr, '" is required, but it was not provided.'), directiveNode)); + } + } + } + } + } + }; + } + function isRequiredArgumentNode(arg) { + return arg.type.kind === _kinds.Kind.NON_NULL_TYPE && arg.defaultValue == null; + } + } +}); + +// node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.js +var require_VariablesInAllowedPositionRule = __commonJS({ + "node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.VariablesInAllowedPositionRule = VariablesInAllowedPositionRule; + var _inspect = _interopRequireDefault(require_inspect()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + var _typeComparators = require_typeComparators(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function VariablesInAllowedPositionRule(context) { + var varDefMap = Object.create(null); + return { + OperationDefinition: { + enter: function enter() { + varDefMap = Object.create(null); + }, + leave: function leave(operation) { + var usages = context.getRecursiveVariableUsages(operation); + for (var _i2 = 0; _i2 < usages.length; _i2++) { + var _ref2 = usages[_i2]; + var node = _ref2.node; + var type = _ref2.type; + var defaultValue = _ref2.defaultValue; + var varName = node.name.value; + var varDef = varDefMap[varName]; + if (varDef && type) { + var schema2 = context.getSchema(); + var varType = (0, _typeFromAST.typeFromAST)(schema2, varDef.type); + if (varType && !allowedVariableUsage(schema2, varType, varDef.defaultValue, type, defaultValue)) { + var varTypeStr = (0, _inspect.default)(varType); + var typeStr = (0, _inspect.default)(type); + context.reportError(new _GraphQLError.GraphQLError('Variable "$'.concat(varName, '" of type "').concat(varTypeStr, '" used in position expecting type "').concat(typeStr, '".'), [varDef, node])); + } + } + } + } + }, + VariableDefinition: function VariableDefinition(node) { + varDefMap[node.variable.name.value] = node; + } + }; + } + function allowedVariableUsage(schema2, varType, varDefaultValue, locationType, locationDefaultValue) { + if ((0, _definition.isNonNullType)(locationType) && !(0, _definition.isNonNullType)(varType)) { + var hasNonNullVariableDefaultValue = varDefaultValue != null && varDefaultValue.kind !== _kinds.Kind.NULL; + var hasLocationDefaultValue = locationDefaultValue !== void 0; + if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) { + return false; + } + var nullableLocationType = locationType.ofType; + return (0, _typeComparators.isTypeSubTypeOf)(schema2, varType, nullableLocationType); + } + return (0, _typeComparators.isTypeSubTypeOf)(schema2, varType, locationType); + } + } +}); + +// node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.js +var require_OverlappingFieldsCanBeMergedRule = __commonJS({ + "node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.OverlappingFieldsCanBeMergedRule = OverlappingFieldsCanBeMergedRule; + var _find = _interopRequireDefault(require_find()); + var _objectEntries3 = _interopRequireDefault(require_objectEntries()); + var _inspect = _interopRequireDefault(require_inspect()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _printer = require_printer(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function reasonMessage(reason) { + if (Array.isArray(reason)) { + return reason.map(function(_ref) { + var responseName = _ref[0], subReason = _ref[1]; + return 'subfields "'.concat(responseName, '" conflict because ') + reasonMessage(subReason); + }).join(" and "); + } + return reason; + } + function OverlappingFieldsCanBeMergedRule(context) { + var comparedFragmentPairs = new PairSet(); + var cachedFieldsAndFragmentNames = new Map(); + return { + SelectionSet: function SelectionSet(selectionSet) { + var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, context.getParentType(), selectionSet); + for (var _i2 = 0; _i2 < conflicts.length; _i2++) { + var _ref3 = conflicts[_i2]; + var _ref2$ = _ref3[0]; + var responseName = _ref2$[0]; + var reason = _ref2$[1]; + var fields1 = _ref3[1]; + var fields2 = _ref3[2]; + var reasonMsg = reasonMessage(reason); + context.reportError(new _GraphQLError.GraphQLError('Fields "'.concat(responseName, '" conflict because ').concat(reasonMsg, ". Use different aliases on the fields to fetch both if this was intentional."), fields1.concat(fields2))); + } + } + }; + } + function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentType, selectionSet) { + var conflicts = []; + var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet), fieldMap = _getFieldsAndFragment[0], fragmentNames = _getFieldsAndFragment[1]; + collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap); + if (fragmentNames.length !== 0) { + for (var i = 0; i < fragmentNames.length; i++) { + collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, fieldMap, fragmentNames[i]); + for (var j = i + 1; j < fragmentNames.length; j++) { + collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, fragmentNames[i], fragmentNames[j]); + } + } + } + return conflicts; + } + function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) { + var fragment = context.getFragment(fragmentName); + if (!fragment) { + return; + } + var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment), fieldMap2 = _getReferencedFieldsA[0], fragmentNames2 = _getReferencedFieldsA[1]; + if (fieldMap === fieldMap2) { + return; + } + collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fieldMap2); + for (var i = 0; i < fragmentNames2.length; i++) { + collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentNames2[i]); + } + } + function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentName2) { + if (fragmentName1 === fragmentName2) { + return; + } + if (comparedFragmentPairs.has(fragmentName1, fragmentName2, areMutuallyExclusive)) { + return; + } + comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive); + var fragment1 = context.getFragment(fragmentName1); + var fragment2 = context.getFragment(fragmentName2); + if (!fragment1 || !fragment2) { + return; + } + var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment1), fieldMap1 = _getReferencedFieldsA2[0], fragmentNames1 = _getReferencedFieldsA2[1]; + var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2), fieldMap2 = _getReferencedFieldsA3[0], fragmentNames2 = _getReferencedFieldsA3[1]; + collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); + for (var j = 0; j < fragmentNames2.length; j++) { + collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentNames2[j]); + } + for (var i = 0; i < fragmentNames1.length; i++) { + collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[i], fragmentName2); + } + } + function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) { + var conflicts = []; + var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1, selectionSet1), fieldMap1 = _getFieldsAndFragment2[0], fragmentNames1 = _getFieldsAndFragment2[1]; + var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2, selectionSet2), fieldMap2 = _getFieldsAndFragment3[0], fragmentNames2 = _getFieldsAndFragment3[1]; + collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); + if (fragmentNames2.length !== 0) { + for (var j = 0; j < fragmentNames2.length; j++) { + collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fragmentNames2[j]); + } + } + if (fragmentNames1.length !== 0) { + for (var i = 0; i < fragmentNames1.length; i++) { + collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap2, fragmentNames1[i]); + } + } + for (var _i3 = 0; _i3 < fragmentNames1.length; _i3++) { + for (var _j = 0; _j < fragmentNames2.length; _j++) { + collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[_i3], fragmentNames2[_j]); + } + } + return conflicts; + } + function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap) { + for (var _i5 = 0, _objectEntries2 = (0, _objectEntries3.default)(fieldMap); _i5 < _objectEntries2.length; _i5++) { + var _ref5 = _objectEntries2[_i5]; + var responseName = _ref5[0]; + var fields = _ref5[1]; + if (fields.length > 1) { + for (var i = 0; i < fields.length; i++) { + for (var j = i + 1; j < fields.length; j++) { + var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, responseName, fields[i], fields[j]); + if (conflict) { + conflicts.push(conflict); + } + } + } + } + } + } + function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) { + for (var _i7 = 0, _Object$keys2 = Object.keys(fieldMap1); _i7 < _Object$keys2.length; _i7++) { + var responseName = _Object$keys2[_i7]; + var fields2 = fieldMap2[responseName]; + if (fields2) { + var fields1 = fieldMap1[responseName]; + for (var i = 0; i < fields1.length; i++) { + for (var j = 0; j < fields2.length; j++) { + var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, fields1[i], fields2[j]); + if (conflict) { + conflicts.push(conflict); + } + } + } + } + } + } + function findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, field1, field2) { + var parentType1 = field1[0], node1 = field1[1], def1 = field1[2]; + var parentType2 = field2[0], node2 = field2[1], def2 = field2[2]; + var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && (0, _definition.isObjectType)(parentType1) && (0, _definition.isObjectType)(parentType2); + if (!areMutuallyExclusive) { + var _node1$arguments, _node2$arguments; + var name1 = node1.name.value; + var name2 = node2.name.value; + if (name1 !== name2) { + return [[responseName, '"'.concat(name1, '" and "').concat(name2, '" are different fields')], [node1], [node2]]; + } + var args1 = (_node1$arguments = node1.arguments) !== null && _node1$arguments !== void 0 ? _node1$arguments : []; + var args2 = (_node2$arguments = node2.arguments) !== null && _node2$arguments !== void 0 ? _node2$arguments : []; + if (!sameArguments(args1, args2)) { + return [[responseName, "they have differing arguments"], [node1], [node2]]; + } + } + var type1 = def1 === null || def1 === void 0 ? void 0 : def1.type; + var type2 = def2 === null || def2 === void 0 ? void 0 : def2.type; + if (type1 && type2 && doTypesConflict(type1, type2)) { + return [[responseName, 'they return conflicting types "'.concat((0, _inspect.default)(type1), '" and "').concat((0, _inspect.default)(type2), '"')], [node1], [node2]]; + } + var selectionSet1 = node1.selectionSet; + var selectionSet2 = node2.selectionSet; + if (selectionSet1 && selectionSet2) { + var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, (0, _definition.getNamedType)(type1), selectionSet1, (0, _definition.getNamedType)(type2), selectionSet2); + return subfieldConflicts(conflicts, responseName, node1, node2); + } + } + function sameArguments(arguments1, arguments2) { + if (arguments1.length !== arguments2.length) { + return false; + } + return arguments1.every(function(argument1) { + var argument2 = (0, _find.default)(arguments2, function(argument) { + return argument.name.value === argument1.name.value; + }); + if (!argument2) { + return false; + } + return sameValue(argument1.value, argument2.value); + }); + } + function sameValue(value1, value2) { + return (0, _printer.print)(value1) === (0, _printer.print)(value2); + } + function doTypesConflict(type1, type2) { + if ((0, _definition.isListType)(type1)) { + return (0, _definition.isListType)(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true; + } + if ((0, _definition.isListType)(type2)) { + return true; + } + if ((0, _definition.isNonNullType)(type1)) { + return (0, _definition.isNonNullType)(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true; + } + if ((0, _definition.isNonNullType)(type2)) { + return true; + } + if ((0, _definition.isLeafType)(type1) || (0, _definition.isLeafType)(type2)) { + return type1 !== type2; + } + return false; + } + function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) { + var cached = cachedFieldsAndFragmentNames.get(selectionSet); + if (!cached) { + var nodeAndDefs = Object.create(null); + var fragmentNames = Object.create(null); + _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames); + cached = [nodeAndDefs, Object.keys(fragmentNames)]; + cachedFieldsAndFragmentNames.set(selectionSet, cached); + } + return cached; + } + function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) { + var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet); + if (cached) { + return cached; + } + var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment.typeCondition); + return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet); + } + function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) { + for (var _i9 = 0, _selectionSet$selecti2 = selectionSet.selections; _i9 < _selectionSet$selecti2.length; _i9++) { + var selection = _selectionSet$selecti2[_i9]; + switch (selection.kind) { + case _kinds.Kind.FIELD: { + var fieldName = selection.name.value; + var fieldDef = void 0; + if ((0, _definition.isObjectType)(parentType) || (0, _definition.isInterfaceType)(parentType)) { + fieldDef = parentType.getFields()[fieldName]; + } + var responseName = selection.alias ? selection.alias.value : fieldName; + if (!nodeAndDefs[responseName]) { + nodeAndDefs[responseName] = []; + } + nodeAndDefs[responseName].push([parentType, selection, fieldDef]); + break; + } + case _kinds.Kind.FRAGMENT_SPREAD: + fragmentNames[selection.name.value] = true; + break; + case _kinds.Kind.INLINE_FRAGMENT: { + var typeCondition = selection.typeCondition; + var inlineFragmentType = typeCondition ? (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition) : parentType; + _collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, nodeAndDefs, fragmentNames); + break; + } + } + } + } + function subfieldConflicts(conflicts, responseName, node1, node2) { + if (conflicts.length > 0) { + return [[responseName, conflicts.map(function(_ref6) { + var reason = _ref6[0]; + return reason; + })], conflicts.reduce(function(allFields, _ref7) { + var fields1 = _ref7[1]; + return allFields.concat(fields1); + }, [node1]), conflicts.reduce(function(allFields, _ref8) { + var fields2 = _ref8[2]; + return allFields.concat(fields2); + }, [node2])]; + } + } + var PairSet = /* @__PURE__ */ function() { + function PairSet2() { + this._data = Object.create(null); + } + var _proto = PairSet2.prototype; + _proto.has = function has(a, b, areMutuallyExclusive) { + var first = this._data[a]; + var result = first && first[b]; + if (result === void 0) { + return false; + } + if (areMutuallyExclusive === false) { + return result === false; + } + return true; + }; + _proto.add = function add(a, b, areMutuallyExclusive) { + this._pairSetAdd(a, b, areMutuallyExclusive); + this._pairSetAdd(b, a, areMutuallyExclusive); + }; + _proto._pairSetAdd = function _pairSetAdd(a, b, areMutuallyExclusive) { + var map = this._data[a]; + if (!map) { + map = Object.create(null); + this._data[a] = map; + } + map[b] = areMutuallyExclusive; + }; + return PairSet2; + }(); + } +}); + +// node_modules/graphql/validation/rules/UniqueInputFieldNamesRule.js +var require_UniqueInputFieldNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueInputFieldNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueInputFieldNamesRule = UniqueInputFieldNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueInputFieldNamesRule(context) { + var knownNameStack = []; + var knownNames = Object.create(null); + return { + ObjectValue: { + enter: function enter() { + knownNameStack.push(knownNames); + knownNames = Object.create(null); + }, + leave: function leave() { + knownNames = knownNameStack.pop(); + } + }, + ObjectField: function ObjectField(node) { + var fieldName = node.name.value; + if (knownNames[fieldName]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one input field named "'.concat(fieldName, '".'), [knownNames[fieldName], node.name])); + } else { + knownNames[fieldName] = node.name; + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/LoneSchemaDefinitionRule.js +var require_LoneSchemaDefinitionRule = __commonJS({ + "node_modules/graphql/validation/rules/LoneSchemaDefinitionRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.LoneSchemaDefinitionRule = LoneSchemaDefinitionRule; + var _GraphQLError = require_GraphQLError(); + function LoneSchemaDefinitionRule(context) { + var _ref, _ref2, _oldSchema$astNode; + var oldSchema = context.getSchema(); + var alreadyDefined = (_ref = (_ref2 = (_oldSchema$astNode = oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.astNode) !== null && _oldSchema$astNode !== void 0 ? _oldSchema$astNode : oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.getQueryType()) !== null && _ref2 !== void 0 ? _ref2 : oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.getMutationType()) !== null && _ref !== void 0 ? _ref : oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.getSubscriptionType(); + var schemaDefinitionsCount = 0; + return { + SchemaDefinition: function SchemaDefinition(node) { + if (alreadyDefined) { + context.reportError(new _GraphQLError.GraphQLError("Cannot define a new schema within a schema extension.", node)); + return; + } + if (schemaDefinitionsCount > 0) { + context.reportError(new _GraphQLError.GraphQLError("Must provide only one schema definition.", node)); + } + ++schemaDefinitionsCount; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/UniqueOperationTypesRule.js +var require_UniqueOperationTypesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueOperationTypesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueOperationTypesRule = UniqueOperationTypesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueOperationTypesRule(context) { + var schema2 = context.getSchema(); + var definedOperationTypes = Object.create(null); + var existingOperationTypes = schema2 ? { + query: schema2.getQueryType(), + mutation: schema2.getMutationType(), + subscription: schema2.getSubscriptionType() + } : {}; + return { + SchemaDefinition: checkOperationTypes, + SchemaExtension: checkOperationTypes + }; + function checkOperationTypes(node) { + var _node$operationTypes; + var operationTypesNodes = (_node$operationTypes = node.operationTypes) !== null && _node$operationTypes !== void 0 ? _node$operationTypes : []; + for (var _i2 = 0; _i2 < operationTypesNodes.length; _i2++) { + var operationType = operationTypesNodes[_i2]; + var operation = operationType.operation; + var alreadyDefinedOperationType = definedOperationTypes[operation]; + if (existingOperationTypes[operation]) { + context.reportError(new _GraphQLError.GraphQLError("Type for ".concat(operation, " already defined in the schema. It cannot be redefined."), operationType)); + } else if (alreadyDefinedOperationType) { + context.reportError(new _GraphQLError.GraphQLError("There can be only one ".concat(operation, " type in schema."), [alreadyDefinedOperationType, operationType])); + } else { + definedOperationTypes[operation] = operationType; + } + } + return false; + } + } + } +}); + +// node_modules/graphql/validation/rules/UniqueTypeNamesRule.js +var require_UniqueTypeNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueTypeNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueTypeNamesRule = UniqueTypeNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueTypeNamesRule(context) { + var knownTypeNames = Object.create(null); + var schema2 = context.getSchema(); + return { + ScalarTypeDefinition: checkTypeName, + ObjectTypeDefinition: checkTypeName, + InterfaceTypeDefinition: checkTypeName, + UnionTypeDefinition: checkTypeName, + EnumTypeDefinition: checkTypeName, + InputObjectTypeDefinition: checkTypeName + }; + function checkTypeName(node) { + var typeName = node.name.value; + if (schema2 !== null && schema2 !== void 0 && schema2.getType(typeName)) { + context.reportError(new _GraphQLError.GraphQLError('Type "'.concat(typeName, '" already exists in the schema. It cannot also be defined in this type definition.'), node.name)); + return; + } + if (knownTypeNames[typeName]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one type named "'.concat(typeName, '".'), [knownTypeNames[typeName], node.name])); + } else { + knownTypeNames[typeName] = node.name; + } + return false; + } + } + } +}); + +// node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.js +var require_UniqueEnumValueNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueEnumValueNamesRule = UniqueEnumValueNamesRule; + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function UniqueEnumValueNamesRule(context) { + var schema2 = context.getSchema(); + var existingTypeMap = schema2 ? schema2.getTypeMap() : Object.create(null); + var knownValueNames = Object.create(null); + return { + EnumTypeDefinition: checkValueUniqueness, + EnumTypeExtension: checkValueUniqueness + }; + function checkValueUniqueness(node) { + var _node$values; + var typeName = node.name.value; + if (!knownValueNames[typeName]) { + knownValueNames[typeName] = Object.create(null); + } + var valueNodes = (_node$values = node.values) !== null && _node$values !== void 0 ? _node$values : []; + var valueNames = knownValueNames[typeName]; + for (var _i2 = 0; _i2 < valueNodes.length; _i2++) { + var valueDef = valueNodes[_i2]; + var valueName = valueDef.name.value; + var existingType = existingTypeMap[typeName]; + if ((0, _definition.isEnumType)(existingType) && existingType.getValue(valueName)) { + context.reportError(new _GraphQLError.GraphQLError('Enum value "'.concat(typeName, ".").concat(valueName, '" already exists in the schema. It cannot also be defined in this type extension.'), valueDef.name)); + } else if (valueNames[valueName]) { + context.reportError(new _GraphQLError.GraphQLError('Enum value "'.concat(typeName, ".").concat(valueName, '" can only be defined once.'), [valueNames[valueName], valueDef.name])); + } else { + valueNames[valueName] = valueDef.name; + } + } + return false; + } + } + } +}); + +// node_modules/graphql/validation/rules/UniqueFieldDefinitionNamesRule.js +var require_UniqueFieldDefinitionNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueFieldDefinitionNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueFieldDefinitionNamesRule = UniqueFieldDefinitionNamesRule; + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function UniqueFieldDefinitionNamesRule(context) { + var schema2 = context.getSchema(); + var existingTypeMap = schema2 ? schema2.getTypeMap() : Object.create(null); + var knownFieldNames = Object.create(null); + return { + InputObjectTypeDefinition: checkFieldUniqueness, + InputObjectTypeExtension: checkFieldUniqueness, + InterfaceTypeDefinition: checkFieldUniqueness, + InterfaceTypeExtension: checkFieldUniqueness, + ObjectTypeDefinition: checkFieldUniqueness, + ObjectTypeExtension: checkFieldUniqueness + }; + function checkFieldUniqueness(node) { + var _node$fields; + var typeName = node.name.value; + if (!knownFieldNames[typeName]) { + knownFieldNames[typeName] = Object.create(null); + } + var fieldNodes = (_node$fields = node.fields) !== null && _node$fields !== void 0 ? _node$fields : []; + var fieldNames = knownFieldNames[typeName]; + for (var _i2 = 0; _i2 < fieldNodes.length; _i2++) { + var fieldDef = fieldNodes[_i2]; + var fieldName = fieldDef.name.value; + if (hasField(existingTypeMap[typeName], fieldName)) { + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(typeName, ".").concat(fieldName, '" already exists in the schema. It cannot also be defined in this type extension.'), fieldDef.name)); + } else if (fieldNames[fieldName]) { + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(typeName, ".").concat(fieldName, '" can only be defined once.'), [fieldNames[fieldName], fieldDef.name])); + } else { + fieldNames[fieldName] = fieldDef.name; + } + } + return false; + } + } + function hasField(type, fieldName) { + if ((0, _definition.isObjectType)(type) || (0, _definition.isInterfaceType)(type) || (0, _definition.isInputObjectType)(type)) { + return type.getFields()[fieldName] != null; + } + return false; + } + } +}); + +// node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.js +var require_UniqueDirectiveNamesRule = __commonJS({ + "node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.UniqueDirectiveNamesRule = UniqueDirectiveNamesRule; + var _GraphQLError = require_GraphQLError(); + function UniqueDirectiveNamesRule(context) { + var knownDirectiveNames = Object.create(null); + var schema2 = context.getSchema(); + return { + DirectiveDefinition: function DirectiveDefinition(node) { + var directiveName = node.name.value; + if (schema2 !== null && schema2 !== void 0 && schema2.getDirective(directiveName)) { + context.reportError(new _GraphQLError.GraphQLError('Directive "@'.concat(directiveName, '" already exists in the schema. It cannot be redefined.'), node.name)); + return; + } + if (knownDirectiveNames[directiveName]) { + context.reportError(new _GraphQLError.GraphQLError('There can be only one directive named "@'.concat(directiveName, '".'), [knownDirectiveNames[directiveName], node.name])); + } else { + knownDirectiveNames[directiveName] = node.name; + } + return false; + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/PossibleTypeExtensionsRule.js +var require_PossibleTypeExtensionsRule = __commonJS({ + "node_modules/graphql/validation/rules/PossibleTypeExtensionsRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.PossibleTypeExtensionsRule = PossibleTypeExtensionsRule; + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _predicates = require_predicates(); + var _definition = require_definition(); + var _defKindToExtKind; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function PossibleTypeExtensionsRule(context) { + var schema2 = context.getSchema(); + var definedTypes = Object.create(null); + for (var _i2 = 0, _context$getDocument$2 = context.getDocument().definitions; _i2 < _context$getDocument$2.length; _i2++) { + var def = _context$getDocument$2[_i2]; + if ((0, _predicates.isTypeDefinitionNode)(def)) { + definedTypes[def.name.value] = def; + } + } + return { + ScalarTypeExtension: checkExtension, + ObjectTypeExtension: checkExtension, + InterfaceTypeExtension: checkExtension, + UnionTypeExtension: checkExtension, + EnumTypeExtension: checkExtension, + InputObjectTypeExtension: checkExtension + }; + function checkExtension(node) { + var typeName = node.name.value; + var defNode = definedTypes[typeName]; + var existingType = schema2 === null || schema2 === void 0 ? void 0 : schema2.getType(typeName); + var expectedKind; + if (defNode) { + expectedKind = defKindToExtKind[defNode.kind]; + } else if (existingType) { + expectedKind = typeToExtKind(existingType); + } + if (expectedKind) { + if (expectedKind !== node.kind) { + var kindStr = extensionKindToTypeName(node.kind); + context.reportError(new _GraphQLError.GraphQLError("Cannot extend non-".concat(kindStr, ' type "').concat(typeName, '".'), defNode ? [defNode, node] : node)); + } + } else { + var allTypeNames = Object.keys(definedTypes); + if (schema2) { + allTypeNames = allTypeNames.concat(Object.keys(schema2.getTypeMap())); + } + var suggestedTypes = (0, _suggestionList.default)(typeName, allTypeNames); + context.reportError(new _GraphQLError.GraphQLError('Cannot extend type "'.concat(typeName, '" because it is not defined.') + (0, _didYouMean.default)(suggestedTypes), node.name)); + } + } + } + var defKindToExtKind = (_defKindToExtKind = {}, _defineProperty(_defKindToExtKind, _kinds.Kind.SCALAR_TYPE_DEFINITION, _kinds.Kind.SCALAR_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.OBJECT_TYPE_DEFINITION, _kinds.Kind.OBJECT_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.INTERFACE_TYPE_DEFINITION, _kinds.Kind.INTERFACE_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.UNION_TYPE_DEFINITION, _kinds.Kind.UNION_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.ENUM_TYPE_DEFINITION, _kinds.Kind.ENUM_TYPE_EXTENSION), _defineProperty(_defKindToExtKind, _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION, _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION), _defKindToExtKind); + function typeToExtKind(type) { + if ((0, _definition.isScalarType)(type)) { + return _kinds.Kind.SCALAR_TYPE_EXTENSION; + } + if ((0, _definition.isObjectType)(type)) { + return _kinds.Kind.OBJECT_TYPE_EXTENSION; + } + if ((0, _definition.isInterfaceType)(type)) { + return _kinds.Kind.INTERFACE_TYPE_EXTENSION; + } + if ((0, _definition.isUnionType)(type)) { + return _kinds.Kind.UNION_TYPE_EXTENSION; + } + if ((0, _definition.isEnumType)(type)) { + return _kinds.Kind.ENUM_TYPE_EXTENSION; + } + if ((0, _definition.isInputObjectType)(type)) { + return _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION; + } + (0, _invariant.default)(0, "Unexpected type: " + (0, _inspect.default)(type)); + } + function extensionKindToTypeName(kind) { + switch (kind) { + case _kinds.Kind.SCALAR_TYPE_EXTENSION: + return "scalar"; + case _kinds.Kind.OBJECT_TYPE_EXTENSION: + return "object"; + case _kinds.Kind.INTERFACE_TYPE_EXTENSION: + return "interface"; + case _kinds.Kind.UNION_TYPE_EXTENSION: + return "union"; + case _kinds.Kind.ENUM_TYPE_EXTENSION: + return "enum"; + case _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION: + return "input object"; + } + (0, _invariant.default)(0, "Unexpected kind: " + (0, _inspect.default)(kind)); + } + } +}); + +// node_modules/graphql/validation/specifiedRules.js +var require_specifiedRules = __commonJS({ + "node_modules/graphql/validation/specifiedRules.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.specifiedSDLRules = exports2.specifiedRules = void 0; + var _ExecutableDefinitionsRule = require_ExecutableDefinitionsRule(); + var _UniqueOperationNamesRule = require_UniqueOperationNamesRule(); + var _LoneAnonymousOperationRule = require_LoneAnonymousOperationRule(); + var _SingleFieldSubscriptionsRule = require_SingleFieldSubscriptionsRule(); + var _KnownTypeNamesRule = require_KnownTypeNamesRule(); + var _FragmentsOnCompositeTypesRule = require_FragmentsOnCompositeTypesRule(); + var _VariablesAreInputTypesRule = require_VariablesAreInputTypesRule(); + var _ScalarLeafsRule = require_ScalarLeafsRule(); + var _FieldsOnCorrectTypeRule = require_FieldsOnCorrectTypeRule(); + var _UniqueFragmentNamesRule = require_UniqueFragmentNamesRule(); + var _KnownFragmentNamesRule = require_KnownFragmentNamesRule(); + var _NoUnusedFragmentsRule = require_NoUnusedFragmentsRule(); + var _PossibleFragmentSpreadsRule = require_PossibleFragmentSpreadsRule(); + var _NoFragmentCyclesRule = require_NoFragmentCyclesRule(); + var _UniqueVariableNamesRule = require_UniqueVariableNamesRule(); + var _NoUndefinedVariablesRule = require_NoUndefinedVariablesRule(); + var _NoUnusedVariablesRule = require_NoUnusedVariablesRule(); + var _KnownDirectivesRule = require_KnownDirectivesRule(); + var _UniqueDirectivesPerLocationRule = require_UniqueDirectivesPerLocationRule(); + var _KnownArgumentNamesRule = require_KnownArgumentNamesRule(); + var _UniqueArgumentNamesRule = require_UniqueArgumentNamesRule(); + var _ValuesOfCorrectTypeRule = require_ValuesOfCorrectTypeRule(); + var _ProvidedRequiredArgumentsRule = require_ProvidedRequiredArgumentsRule(); + var _VariablesInAllowedPositionRule = require_VariablesInAllowedPositionRule(); + var _OverlappingFieldsCanBeMergedRule = require_OverlappingFieldsCanBeMergedRule(); + var _UniqueInputFieldNamesRule = require_UniqueInputFieldNamesRule(); + var _LoneSchemaDefinitionRule = require_LoneSchemaDefinitionRule(); + var _UniqueOperationTypesRule = require_UniqueOperationTypesRule(); + var _UniqueTypeNamesRule = require_UniqueTypeNamesRule(); + var _UniqueEnumValueNamesRule = require_UniqueEnumValueNamesRule(); + var _UniqueFieldDefinitionNamesRule = require_UniqueFieldDefinitionNamesRule(); + var _UniqueDirectiveNamesRule = require_UniqueDirectiveNamesRule(); + var _PossibleTypeExtensionsRule = require_PossibleTypeExtensionsRule(); + var specifiedRules = Object.freeze([_ExecutableDefinitionsRule.ExecutableDefinitionsRule, _UniqueOperationNamesRule.UniqueOperationNamesRule, _LoneAnonymousOperationRule.LoneAnonymousOperationRule, _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule, _KnownTypeNamesRule.KnownTypeNamesRule, _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule, _VariablesAreInputTypesRule.VariablesAreInputTypesRule, _ScalarLeafsRule.ScalarLeafsRule, _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule, _UniqueFragmentNamesRule.UniqueFragmentNamesRule, _KnownFragmentNamesRule.KnownFragmentNamesRule, _NoUnusedFragmentsRule.NoUnusedFragmentsRule, _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule, _NoFragmentCyclesRule.NoFragmentCyclesRule, _UniqueVariableNamesRule.UniqueVariableNamesRule, _NoUndefinedVariablesRule.NoUndefinedVariablesRule, _NoUnusedVariablesRule.NoUnusedVariablesRule, _KnownDirectivesRule.KnownDirectivesRule, _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule, _KnownArgumentNamesRule.KnownArgumentNamesRule, _UniqueArgumentNamesRule.UniqueArgumentNamesRule, _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule, _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule, _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule, _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule, _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule]); + exports2.specifiedRules = specifiedRules; + var specifiedSDLRules = Object.freeze([_LoneSchemaDefinitionRule.LoneSchemaDefinitionRule, _UniqueOperationTypesRule.UniqueOperationTypesRule, _UniqueTypeNamesRule.UniqueTypeNamesRule, _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule, _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule, _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule, _KnownTypeNamesRule.KnownTypeNamesRule, _KnownDirectivesRule.KnownDirectivesRule, _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule, _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule, _KnownArgumentNamesRule.KnownArgumentNamesOnDirectivesRule, _UniqueArgumentNamesRule.UniqueArgumentNamesRule, _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule, _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsOnDirectivesRule]); + exports2.specifiedSDLRules = specifiedSDLRules; + } +}); + +// node_modules/graphql/validation/ValidationContext.js +var require_ValidationContext = __commonJS({ + "node_modules/graphql/validation/ValidationContext.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.ValidationContext = exports2.SDLValidationContext = exports2.ASTValidationContext = void 0; + var _kinds = require_kinds(); + var _visitor = require_visitor(); + var _TypeInfo = require_TypeInfo(); + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + var ASTValidationContext = /* @__PURE__ */ function() { + function ASTValidationContext2(ast, onError) { + this._ast = ast; + this._fragments = void 0; + this._fragmentSpreads = new Map(); + this._recursivelyReferencedFragments = new Map(); + this._onError = onError; + } + var _proto = ASTValidationContext2.prototype; + _proto.reportError = function reportError(error) { + this._onError(error); + }; + _proto.getDocument = function getDocument() { + return this._ast; + }; + _proto.getFragment = function getFragment(name) { + var fragments = this._fragments; + if (!fragments) { + this._fragments = fragments = this.getDocument().definitions.reduce(function(frags, statement) { + if (statement.kind === _kinds.Kind.FRAGMENT_DEFINITION) { + frags[statement.name.value] = statement; + } + return frags; + }, Object.create(null)); + } + return fragments[name]; + }; + _proto.getFragmentSpreads = function getFragmentSpreads(node) { + var spreads = this._fragmentSpreads.get(node); + if (!spreads) { + spreads = []; + var setsToVisit = [node]; + while (setsToVisit.length !== 0) { + var set = setsToVisit.pop(); + for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) { + var selection = _set$selections2[_i2]; + if (selection.kind === _kinds.Kind.FRAGMENT_SPREAD) { + spreads.push(selection); + } else if (selection.selectionSet) { + setsToVisit.push(selection.selectionSet); + } + } + } + this._fragmentSpreads.set(node, spreads); + } + return spreads; + }; + _proto.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) { + var fragments = this._recursivelyReferencedFragments.get(operation); + if (!fragments) { + fragments = []; + var collectedNames = Object.create(null); + var nodesToVisit = [operation.selectionSet]; + while (nodesToVisit.length !== 0) { + var node = nodesToVisit.pop(); + for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) { + var spread = _this$getFragmentSpre2[_i4]; + var fragName = spread.name.value; + if (collectedNames[fragName] !== true) { + collectedNames[fragName] = true; + var fragment = this.getFragment(fragName); + if (fragment) { + fragments.push(fragment); + nodesToVisit.push(fragment.selectionSet); + } + } + } + } + this._recursivelyReferencedFragments.set(operation, fragments); + } + return fragments; + }; + return ASTValidationContext2; + }(); + exports2.ASTValidationContext = ASTValidationContext; + var SDLValidationContext = /* @__PURE__ */ function(_ASTValidationContext) { + _inheritsLoose(SDLValidationContext2, _ASTValidationContext); + function SDLValidationContext2(ast, schema2, onError) { + var _this; + _this = _ASTValidationContext.call(this, ast, onError) || this; + _this._schema = schema2; + return _this; + } + var _proto2 = SDLValidationContext2.prototype; + _proto2.getSchema = function getSchema() { + return this._schema; + }; + return SDLValidationContext2; + }(ASTValidationContext); + exports2.SDLValidationContext = SDLValidationContext; + var ValidationContext = /* @__PURE__ */ function(_ASTValidationContext2) { + _inheritsLoose(ValidationContext2, _ASTValidationContext2); + function ValidationContext2(schema2, ast, typeInfo, onError) { + var _this2; + _this2 = _ASTValidationContext2.call(this, ast, onError) || this; + _this2._schema = schema2; + _this2._typeInfo = typeInfo; + _this2._variableUsages = new Map(); + _this2._recursiveVariableUsages = new Map(); + return _this2; + } + var _proto3 = ValidationContext2.prototype; + _proto3.getSchema = function getSchema() { + return this._schema; + }; + _proto3.getVariableUsages = function getVariableUsages(node) { + var usages = this._variableUsages.get(node); + if (!usages) { + var newUsages = []; + var typeInfo = new _TypeInfo.TypeInfo(this._schema); + (0, _visitor.visit)(node, (0, _TypeInfo.visitWithTypeInfo)(typeInfo, { + VariableDefinition: function VariableDefinition() { + return false; + }, + Variable: function Variable(variable) { + newUsages.push({ + node: variable, + type: typeInfo.getInputType(), + defaultValue: typeInfo.getDefaultValue() + }); + } + })); + usages = newUsages; + this._variableUsages.set(node, usages); + } + return usages; + }; + _proto3.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) { + var usages = this._recursiveVariableUsages.get(operation); + if (!usages) { + usages = this.getVariableUsages(operation); + for (var _i6 = 0, _this$getRecursivelyR2 = this.getRecursivelyReferencedFragments(operation); _i6 < _this$getRecursivelyR2.length; _i6++) { + var frag = _this$getRecursivelyR2[_i6]; + usages = usages.concat(this.getVariableUsages(frag)); + } + this._recursiveVariableUsages.set(operation, usages); + } + return usages; + }; + _proto3.getType = function getType() { + return this._typeInfo.getType(); + }; + _proto3.getParentType = function getParentType() { + return this._typeInfo.getParentType(); + }; + _proto3.getInputType = function getInputType() { + return this._typeInfo.getInputType(); + }; + _proto3.getParentInputType = function getParentInputType() { + return this._typeInfo.getParentInputType(); + }; + _proto3.getFieldDef = function getFieldDef() { + return this._typeInfo.getFieldDef(); + }; + _proto3.getDirective = function getDirective() { + return this._typeInfo.getDirective(); + }; + _proto3.getArgument = function getArgument() { + return this._typeInfo.getArgument(); + }; + _proto3.getEnumValue = function getEnumValue() { + return this._typeInfo.getEnumValue(); + }; + return ValidationContext2; + }(ASTValidationContext); + exports2.ValidationContext = ValidationContext; + } +}); + +// node_modules/graphql/validation/validate.js +var require_validate2 = __commonJS({ + "node_modules/graphql/validation/validate.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.validate = validate; + exports2.validateSDL = validateSDL; + exports2.assertValidSDL = assertValidSDL; + exports2.assertValidSDLExtension = assertValidSDLExtension; + var _devAssert = _interopRequireDefault(require_devAssert()); + var _GraphQLError = require_GraphQLError(); + var _visitor = require_visitor(); + var _validate = require_validate(); + var _TypeInfo = require_TypeInfo(); + var _specifiedRules = require_specifiedRules(); + var _ValidationContext = require_ValidationContext(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function validate(schema2, documentAST) { + var rules = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _specifiedRules.specifiedRules; + var typeInfo = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : new _TypeInfo.TypeInfo(schema2); + var options = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : { + maxErrors: void 0 + }; + documentAST || (0, _devAssert.default)(0, "Must provide document."); + (0, _validate.assertValidSchema)(schema2); + var abortObj = Object.freeze({}); + var errors = []; + var context = new _ValidationContext.ValidationContext(schema2, documentAST, typeInfo, function(error) { + if (options.maxErrors != null && errors.length >= options.maxErrors) { + errors.push(new _GraphQLError.GraphQLError("Too many validation errors, error limit reached. Validation aborted.")); + throw abortObj; + } + errors.push(error); + }); + var visitor = (0, _visitor.visitInParallel)(rules.map(function(rule) { + return rule(context); + })); + try { + (0, _visitor.visit)(documentAST, (0, _TypeInfo.visitWithTypeInfo)(typeInfo, visitor)); + } catch (e) { + if (e !== abortObj) { + throw e; + } + } + return errors; + } + function validateSDL(documentAST, schemaToExtend) { + var rules = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _specifiedRules.specifiedSDLRules; + var errors = []; + var context = new _ValidationContext.SDLValidationContext(documentAST, schemaToExtend, function(error) { + errors.push(error); + }); + var visitors = rules.map(function(rule) { + return rule(context); + }); + (0, _visitor.visit)(documentAST, (0, _visitor.visitInParallel)(visitors)); + return errors; + } + function assertValidSDL(documentAST) { + var errors = validateSDL(documentAST); + if (errors.length !== 0) { + throw new Error(errors.map(function(error) { + return error.message; + }).join("\n\n")); + } + } + function assertValidSDLExtension(documentAST, schema2) { + var errors = validateSDL(documentAST, schema2); + if (errors.length !== 0) { + throw new Error(errors.map(function(error) { + return error.message; + }).join("\n\n")); + } + } + } +}); + +// node_modules/graphql/jsutils/memoize3.js +var require_memoize3 = __commonJS({ + "node_modules/graphql/jsutils/memoize3.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = memoize3; + function memoize3(fn) { + var cache0; + return function memoized(a1, a2, a3) { + if (!cache0) { + cache0 = new WeakMap(); + } + var cache1 = cache0.get(a1); + var cache2; + if (cache1) { + cache2 = cache1.get(a2); + if (cache2) { + var cachedValue = cache2.get(a3); + if (cachedValue !== void 0) { + return cachedValue; + } + } + } else { + cache1 = new WeakMap(); + cache0.set(a1, cache1); + } + if (!cache2) { + cache2 = new WeakMap(); + cache1.set(a2, cache2); + } + var newValue = fn(a1, a2, a3); + cache2.set(a3, newValue); + return newValue; + }; + } + } +}); + +// node_modules/graphql/jsutils/promiseReduce.js +var require_promiseReduce = __commonJS({ + "node_modules/graphql/jsutils/promiseReduce.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = promiseReduce; + var _isPromise = _interopRequireDefault(require_isPromise()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function promiseReduce(values, callback, initialValue) { + return values.reduce(function(previous, value) { + return (0, _isPromise.default)(previous) ? previous.then(function(resolved) { + return callback(resolved, value); + }) : callback(previous, value); + }, initialValue); + } + } +}); + +// node_modules/graphql/jsutils/promiseForObject.js +var require_promiseForObject = __commonJS({ + "node_modules/graphql/jsutils/promiseForObject.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = promiseForObject; + function promiseForObject(object) { + var keys = Object.keys(object); + var valuesAndPromises = keys.map(function(name) { + return object[name]; + }); + return Promise.all(valuesAndPromises).then(function(values) { + return values.reduce(function(resolvedObject, value, i) { + resolvedObject[keys[i]] = value; + return resolvedObject; + }, Object.create(null)); + }); + } + } +}); + +// node_modules/graphql/jsutils/Path.js +var require_Path = __commonJS({ + "node_modules/graphql/jsutils/Path.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.addPath = addPath; + exports2.pathToArray = pathToArray; + function addPath(prev, key, typename) { + return { + prev, + key, + typename + }; + } + function pathToArray(path) { + var flattened = []; + var curr = path; + while (curr) { + flattened.push(curr.key); + curr = curr.prev; + } + return flattened.reverse(); + } + } +}); + +// node_modules/graphql/utilities/getOperationRootType.js +var require_getOperationRootType = __commonJS({ + "node_modules/graphql/utilities/getOperationRootType.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.getOperationRootType = getOperationRootType; + var _GraphQLError = require_GraphQLError(); + function getOperationRootType(schema2, operation) { + if (operation.operation === "query") { + var queryType = schema2.getQueryType(); + if (!queryType) { + throw new _GraphQLError.GraphQLError("Schema does not define the required query root type.", operation); + } + return queryType; + } + if (operation.operation === "mutation") { + var mutationType = schema2.getMutationType(); + if (!mutationType) { + throw new _GraphQLError.GraphQLError("Schema is not configured for mutations.", operation); + } + return mutationType; + } + if (operation.operation === "subscription") { + var subscriptionType = schema2.getSubscriptionType(); + if (!subscriptionType) { + throw new _GraphQLError.GraphQLError("Schema is not configured for subscriptions.", operation); + } + return subscriptionType; + } + throw new _GraphQLError.GraphQLError("Can only have query, mutation and subscription operations.", operation); + } + } +}); + +// node_modules/graphql/jsutils/printPathArray.js +var require_printPathArray = __commonJS({ + "node_modules/graphql/jsutils/printPathArray.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = printPathArray; + function printPathArray(path) { + return path.map(function(key) { + return typeof key === "number" ? "[" + key.toString() + "]" : "." + key; + }).join(""); + } + } +}); + +// node_modules/graphql/utilities/valueFromAST.js +var require_valueFromAST = __commonJS({ + "node_modules/graphql/utilities/valueFromAST.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.valueFromAST = valueFromAST; + var _objectValues3 = _interopRequireDefault(require_objectValues()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _kinds = require_kinds(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function valueFromAST(valueNode, type, variables) { + if (!valueNode) { + return; + } + if (valueNode.kind === _kinds.Kind.VARIABLE) { + var variableName = valueNode.name.value; + if (variables == null || variables[variableName] === void 0) { + return; + } + var variableValue = variables[variableName]; + if (variableValue === null && (0, _definition.isNonNullType)(type)) { + return; + } + return variableValue; + } + if ((0, _definition.isNonNullType)(type)) { + if (valueNode.kind === _kinds.Kind.NULL) { + return; + } + return valueFromAST(valueNode, type.ofType, variables); + } + if (valueNode.kind === _kinds.Kind.NULL) { + return null; + } + if ((0, _definition.isListType)(type)) { + var itemType = type.ofType; + if (valueNode.kind === _kinds.Kind.LIST) { + var coercedValues = []; + for (var _i2 = 0, _valueNode$values2 = valueNode.values; _i2 < _valueNode$values2.length; _i2++) { + var itemNode = _valueNode$values2[_i2]; + if (isMissingVariable(itemNode, variables)) { + if ((0, _definition.isNonNullType)(itemType)) { + return; + } + coercedValues.push(null); + } else { + var itemValue = valueFromAST(itemNode, itemType, variables); + if (itemValue === void 0) { + return; + } + coercedValues.push(itemValue); + } + } + return coercedValues; + } + var coercedValue = valueFromAST(valueNode, itemType, variables); + if (coercedValue === void 0) { + return; + } + return [coercedValue]; + } + if ((0, _definition.isInputObjectType)(type)) { + if (valueNode.kind !== _kinds.Kind.OBJECT) { + return; + } + var coercedObj = Object.create(null); + var fieldNodes = (0, _keyMap.default)(valueNode.fields, function(field2) { + return field2.name.value; + }); + for (var _i4 = 0, _objectValues2 = (0, _objectValues3.default)(type.getFields()); _i4 < _objectValues2.length; _i4++) { + var field = _objectValues2[_i4]; + var fieldNode = fieldNodes[field.name]; + if (!fieldNode || isMissingVariable(fieldNode.value, variables)) { + if (field.defaultValue !== void 0) { + coercedObj[field.name] = field.defaultValue; + } else if ((0, _definition.isNonNullType)(field.type)) { + return; + } + continue; + } + var fieldValue = valueFromAST(fieldNode.value, field.type, variables); + if (fieldValue === void 0) { + return; + } + coercedObj[field.name] = fieldValue; + } + return coercedObj; + } + if ((0, _definition.isLeafType)(type)) { + var result; + try { + result = type.parseLiteral(valueNode, variables); + } catch (_error) { + return; + } + if (result === void 0) { + return; + } + return result; + } + (0, _invariant.default)(0, "Unexpected input type: " + (0, _inspect.default)(type)); + } + function isMissingVariable(valueNode, variables) { + return valueNode.kind === _kinds.Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === void 0); + } + } +}); + +// node_modules/graphql/utilities/coerceInputValue.js +var require_coerceInputValue = __commonJS({ + "node_modules/graphql/utilities/coerceInputValue.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.coerceInputValue = coerceInputValue; + var _objectValues3 = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _didYouMean = _interopRequireDefault(require_didYouMean()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _safeArrayFrom = _interopRequireDefault(require_safeArrayFrom()); + var _suggestionList = _interopRequireDefault(require_suggestionList()); + var _printPathArray = _interopRequireDefault(require_printPathArray()); + var _Path = require_Path(); + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function coerceInputValue(inputValue, type) { + var onError = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : defaultOnError; + return coerceInputValueImpl(inputValue, type, onError); + } + function defaultOnError(path, invalidValue, error) { + var errorPrefix = "Invalid value " + (0, _inspect.default)(invalidValue); + if (path.length > 0) { + errorPrefix += ' at "value'.concat((0, _printPathArray.default)(path), '"'); + } + error.message = errorPrefix + ": " + error.message; + throw error; + } + function coerceInputValueImpl(inputValue, type, onError, path) { + if ((0, _definition.isNonNullType)(type)) { + if (inputValue != null) { + return coerceInputValueImpl(inputValue, type.ofType, onError, path); + } + onError((0, _Path.pathToArray)(path), inputValue, new _GraphQLError.GraphQLError('Expected non-nullable type "'.concat((0, _inspect.default)(type), '" not to be null.'))); + return; + } + if (inputValue == null) { + return null; + } + if ((0, _definition.isListType)(type)) { + var itemType = type.ofType; + var coercedList = (0, _safeArrayFrom.default)(inputValue, function(itemValue, index) { + var itemPath = (0, _Path.addPath)(path, index, void 0); + return coerceInputValueImpl(itemValue, itemType, onError, itemPath); + }); + if (coercedList != null) { + return coercedList; + } + return [coerceInputValueImpl(inputValue, itemType, onError, path)]; + } + if ((0, _definition.isInputObjectType)(type)) { + if (!(0, _isObjectLike.default)(inputValue)) { + onError((0, _Path.pathToArray)(path), inputValue, new _GraphQLError.GraphQLError('Expected type "'.concat(type.name, '" to be an object.'))); + return; + } + var coercedValue = {}; + var fieldDefs = type.getFields(); + for (var _i2 = 0, _objectValues2 = (0, _objectValues3.default)(fieldDefs); _i2 < _objectValues2.length; _i2++) { + var field = _objectValues2[_i2]; + var fieldValue = inputValue[field.name]; + if (fieldValue === void 0) { + if (field.defaultValue !== void 0) { + coercedValue[field.name] = field.defaultValue; + } else if ((0, _definition.isNonNullType)(field.type)) { + var typeStr = (0, _inspect.default)(field.type); + onError((0, _Path.pathToArray)(path), inputValue, new _GraphQLError.GraphQLError('Field "'.concat(field.name, '" of required type "').concat(typeStr, '" was not provided.'))); + } + continue; + } + coercedValue[field.name] = coerceInputValueImpl(fieldValue, field.type, onError, (0, _Path.addPath)(path, field.name, type.name)); + } + for (var _i4 = 0, _Object$keys2 = Object.keys(inputValue); _i4 < _Object$keys2.length; _i4++) { + var fieldName = _Object$keys2[_i4]; + if (!fieldDefs[fieldName]) { + var suggestions = (0, _suggestionList.default)(fieldName, Object.keys(type.getFields())); + onError((0, _Path.pathToArray)(path), inputValue, new _GraphQLError.GraphQLError('Field "'.concat(fieldName, '" is not defined by type "').concat(type.name, '".') + (0, _didYouMean.default)(suggestions))); + } + } + return coercedValue; + } + if ((0, _definition.isLeafType)(type)) { + var parseResult; + try { + parseResult = type.parseValue(inputValue); + } catch (error) { + if (error instanceof _GraphQLError.GraphQLError) { + onError((0, _Path.pathToArray)(path), inputValue, error); + } else { + onError((0, _Path.pathToArray)(path), inputValue, new _GraphQLError.GraphQLError('Expected type "'.concat(type.name, '". ') + error.message, void 0, void 0, void 0, void 0, error)); + } + return; + } + if (parseResult === void 0) { + onError((0, _Path.pathToArray)(path), inputValue, new _GraphQLError.GraphQLError('Expected type "'.concat(type.name, '".'))); + } + return parseResult; + } + (0, _invariant.default)(0, "Unexpected input type: " + (0, _inspect.default)(type)); + } + } +}); + +// node_modules/graphql/execution/values.js +var require_values = __commonJS({ + "node_modules/graphql/execution/values.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.getVariableValues = getVariableValues; + exports2.getArgumentValues = getArgumentValues; + exports2.getDirectiveValues = getDirectiveValues; + var _find = _interopRequireDefault(require_find()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _inspect = _interopRequireDefault(require_inspect()); + var _printPathArray = _interopRequireDefault(require_printPathArray()); + var _GraphQLError = require_GraphQLError(); + var _kinds = require_kinds(); + var _printer = require_printer(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + var _valueFromAST = require_valueFromAST(); + var _coerceInputValue = require_coerceInputValue(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function getVariableValues(schema2, varDefNodes, inputs, options) { + var errors = []; + var maxErrors = options === null || options === void 0 ? void 0 : options.maxErrors; + try { + var coerced = coerceVariableValues(schema2, varDefNodes, inputs, function(error) { + if (maxErrors != null && errors.length >= maxErrors) { + throw new _GraphQLError.GraphQLError("Too many errors processing variables, error limit reached. Execution aborted."); + } + errors.push(error); + }); + if (errors.length === 0) { + return { + coerced + }; + } + } catch (error) { + errors.push(error); + } + return { + errors + }; + } + function coerceVariableValues(schema2, varDefNodes, inputs, onError) { + var coercedValues = {}; + var _loop = function _loop2(_i22) { + var varDefNode = varDefNodes[_i22]; + var varName = varDefNode.variable.name.value; + var varType = (0, _typeFromAST.typeFromAST)(schema2, varDefNode.type); + if (!(0, _definition.isInputType)(varType)) { + var varTypeStr = (0, _printer.print)(varDefNode.type); + onError(new _GraphQLError.GraphQLError('Variable "$'.concat(varName, '" expected value of type "').concat(varTypeStr, '" which cannot be used as an input type.'), varDefNode.type)); + return "continue"; + } + if (!hasOwnProperty(inputs, varName)) { + if (varDefNode.defaultValue) { + coercedValues[varName] = (0, _valueFromAST.valueFromAST)(varDefNode.defaultValue, varType); + } else if ((0, _definition.isNonNullType)(varType)) { + var _varTypeStr = (0, _inspect.default)(varType); + onError(new _GraphQLError.GraphQLError('Variable "$'.concat(varName, '" of required type "').concat(_varTypeStr, '" was not provided.'), varDefNode)); + } + return "continue"; + } + var value = inputs[varName]; + if (value === null && (0, _definition.isNonNullType)(varType)) { + var _varTypeStr2 = (0, _inspect.default)(varType); + onError(new _GraphQLError.GraphQLError('Variable "$'.concat(varName, '" of non-null type "').concat(_varTypeStr2, '" must not be null.'), varDefNode)); + return "continue"; + } + coercedValues[varName] = (0, _coerceInputValue.coerceInputValue)(value, varType, function(path, invalidValue, error) { + var prefix = 'Variable "$'.concat(varName, '" got invalid value ') + (0, _inspect.default)(invalidValue); + if (path.length > 0) { + prefix += ' at "'.concat(varName).concat((0, _printPathArray.default)(path), '"'); + } + onError(new _GraphQLError.GraphQLError(prefix + "; " + error.message, varDefNode, void 0, void 0, void 0, error.originalError)); + }); + }; + for (var _i2 = 0; _i2 < varDefNodes.length; _i2++) { + var _ret = _loop(_i2); + if (_ret === "continue") + continue; + } + return coercedValues; + } + function getArgumentValues(def, node, variableValues) { + var _node$arguments; + var coercedValues = {}; + var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : []; + var argNodeMap = (0, _keyMap.default)(argumentNodes, function(arg) { + return arg.name.value; + }); + for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) { + var argDef = _def$args2[_i4]; + var name = argDef.name; + var argType = argDef.type; + var argumentNode = argNodeMap[name]; + if (!argumentNode) { + if (argDef.defaultValue !== void 0) { + coercedValues[name] = argDef.defaultValue; + } else if ((0, _definition.isNonNullType)(argType)) { + throw new _GraphQLError.GraphQLError('Argument "'.concat(name, '" of required type "').concat((0, _inspect.default)(argType), '" ') + "was not provided.", node); + } + continue; + } + var valueNode = argumentNode.value; + var isNull = valueNode.kind === _kinds.Kind.NULL; + if (valueNode.kind === _kinds.Kind.VARIABLE) { + var variableName = valueNode.name.value; + if (variableValues == null || !hasOwnProperty(variableValues, variableName)) { + if (argDef.defaultValue !== void 0) { + coercedValues[name] = argDef.defaultValue; + } else if ((0, _definition.isNonNullType)(argType)) { + throw new _GraphQLError.GraphQLError('Argument "'.concat(name, '" of required type "').concat((0, _inspect.default)(argType), '" ') + 'was provided the variable "$'.concat(variableName, '" which was not provided a runtime value.'), valueNode); + } + continue; + } + isNull = variableValues[variableName] == null; + } + if (isNull && (0, _definition.isNonNullType)(argType)) { + throw new _GraphQLError.GraphQLError('Argument "'.concat(name, '" of non-null type "').concat((0, _inspect.default)(argType), '" ') + "must not be null.", valueNode); + } + var coercedValue = (0, _valueFromAST.valueFromAST)(valueNode, argType, variableValues); + if (coercedValue === void 0) { + throw new _GraphQLError.GraphQLError('Argument "'.concat(name, '" has invalid value ').concat((0, _printer.print)(valueNode), "."), valueNode); + } + coercedValues[name] = coercedValue; + } + return coercedValues; + } + function getDirectiveValues(directiveDef, node, variableValues) { + var directiveNode = node.directives && (0, _find.default)(node.directives, function(directive) { + return directive.name.value === directiveDef.name; + }); + if (directiveNode) { + return getArgumentValues(directiveDef, directiveNode, variableValues); + } + } + function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); + } + } +}); + +// node_modules/graphql/execution/execute.js +var require_execute = __commonJS({ + "node_modules/graphql/execution/execute.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.execute = execute; + exports2.executeSync = executeSync; + exports2.assertValidExecutionArguments = assertValidExecutionArguments; + exports2.buildExecutionContext = buildExecutionContext; + exports2.collectFields = collectFields; + exports2.buildResolveInfo = buildResolveInfo; + exports2.getFieldDef = getFieldDef; + exports2.defaultFieldResolver = exports2.defaultTypeResolver = void 0; + var _inspect = _interopRequireDefault(require_inspect()); + var _memoize = _interopRequireDefault(require_memoize3()); + var _invariant = _interopRequireDefault(require_invariant()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _isPromise = _interopRequireDefault(require_isPromise()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _safeArrayFrom = _interopRequireDefault(require_safeArrayFrom()); + var _promiseReduce = _interopRequireDefault(require_promiseReduce()); + var _promiseForObject = _interopRequireDefault(require_promiseForObject()); + var _Path = require_Path(); + var _GraphQLError = require_GraphQLError(); + var _locatedError = require_locatedError(); + var _kinds = require_kinds(); + var _validate = require_validate(); + var _introspection = require_introspection(); + var _directives = require_directives(); + var _definition = require_definition(); + var _typeFromAST = require_typeFromAST(); + var _getOperationRootType = require_getOperationRootType(); + var _values = require_values(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function execute(argsOrSchema, document2, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) { + return arguments.length === 1 ? executeImpl(argsOrSchema) : executeImpl({ + schema: argsOrSchema, + document: document2, + rootValue, + contextValue, + variableValues, + operationName, + fieldResolver, + typeResolver + }); + } + function executeSync(args) { + var result = executeImpl(args); + if ((0, _isPromise.default)(result)) { + throw new Error("GraphQL execution failed to complete synchronously."); + } + return result; + } + function executeImpl(args) { + var schema2 = args.schema, document2 = args.document, rootValue = args.rootValue, contextValue = args.contextValue, variableValues = args.variableValues, operationName = args.operationName, fieldResolver = args.fieldResolver, typeResolver = args.typeResolver; + assertValidExecutionArguments(schema2, document2, variableValues); + var exeContext = buildExecutionContext(schema2, document2, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver); + if (Array.isArray(exeContext)) { + return { + errors: exeContext + }; + } + var data = executeOperation(exeContext, exeContext.operation, rootValue); + return buildResponse(exeContext, data); + } + function buildResponse(exeContext, data) { + if ((0, _isPromise.default)(data)) { + return data.then(function(resolved) { + return buildResponse(exeContext, resolved); + }); + } + return exeContext.errors.length === 0 ? { + data + } : { + errors: exeContext.errors, + data + }; + } + function assertValidExecutionArguments(schema2, document2, rawVariableValues) { + document2 || (0, _devAssert.default)(0, "Must provide document."); + (0, _validate.assertValidSchema)(schema2); + rawVariableValues == null || (0, _isObjectLike.default)(rawVariableValues) || (0, _devAssert.default)(0, "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided."); + } + function buildExecutionContext(schema2, document2, rootValue, contextValue, rawVariableValues, operationName, fieldResolver, typeResolver) { + var _definition$name, _operation$variableDe; + var operation; + var fragments = Object.create(null); + for (var _i2 = 0, _document$definitions2 = document2.definitions; _i2 < _document$definitions2.length; _i2++) { + var definition = _document$definitions2[_i2]; + switch (definition.kind) { + case _kinds.Kind.OPERATION_DEFINITION: + if (operationName == null) { + if (operation !== void 0) { + return [new _GraphQLError.GraphQLError("Must provide operation name if query contains multiple operations.")]; + } + operation = definition; + } else if (((_definition$name = definition.name) === null || _definition$name === void 0 ? void 0 : _definition$name.value) === operationName) { + operation = definition; + } + break; + case _kinds.Kind.FRAGMENT_DEFINITION: + fragments[definition.name.value] = definition; + break; + } + } + if (!operation) { + if (operationName != null) { + return [new _GraphQLError.GraphQLError('Unknown operation named "'.concat(operationName, '".'))]; + } + return [new _GraphQLError.GraphQLError("Must provide an operation.")]; + } + var variableDefinitions = (_operation$variableDe = operation.variableDefinitions) !== null && _operation$variableDe !== void 0 ? _operation$variableDe : []; + var coercedVariableValues = (0, _values.getVariableValues)(schema2, variableDefinitions, rawVariableValues !== null && rawVariableValues !== void 0 ? rawVariableValues : {}, { + maxErrors: 50 + }); + if (coercedVariableValues.errors) { + return coercedVariableValues.errors; + } + return { + schema: schema2, + fragments, + rootValue, + contextValue, + operation, + variableValues: coercedVariableValues.coerced, + fieldResolver: fieldResolver !== null && fieldResolver !== void 0 ? fieldResolver : defaultFieldResolver, + typeResolver: typeResolver !== null && typeResolver !== void 0 ? typeResolver : defaultTypeResolver, + errors: [] + }; + } + function executeOperation(exeContext, operation, rootValue) { + var type = (0, _getOperationRootType.getOperationRootType)(exeContext.schema, operation); + var fields = collectFields(exeContext, type, operation.selectionSet, Object.create(null), Object.create(null)); + var path = void 0; + try { + var result = operation.operation === "mutation" ? executeFieldsSerially(exeContext, type, rootValue, path, fields) : executeFields(exeContext, type, rootValue, path, fields); + if ((0, _isPromise.default)(result)) { + return result.then(void 0, function(error) { + exeContext.errors.push(error); + return Promise.resolve(null); + }); + } + return result; + } catch (error) { + exeContext.errors.push(error); + return null; + } + } + function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) { + return (0, _promiseReduce.default)(Object.keys(fields), function(results, responseName) { + var fieldNodes = fields[responseName]; + var fieldPath = (0, _Path.addPath)(path, responseName, parentType.name); + var result = resolveField(exeContext, parentType, sourceValue, fieldNodes, fieldPath); + if (result === void 0) { + return results; + } + if ((0, _isPromise.default)(result)) { + return result.then(function(resolvedResult) { + results[responseName] = resolvedResult; + return results; + }); + } + results[responseName] = result; + return results; + }, Object.create(null)); + } + function executeFields(exeContext, parentType, sourceValue, path, fields) { + var results = Object.create(null); + var containsPromise = false; + for (var _i4 = 0, _Object$keys2 = Object.keys(fields); _i4 < _Object$keys2.length; _i4++) { + var responseName = _Object$keys2[_i4]; + var fieldNodes = fields[responseName]; + var fieldPath = (0, _Path.addPath)(path, responseName, parentType.name); + var result = resolveField(exeContext, parentType, sourceValue, fieldNodes, fieldPath); + if (result !== void 0) { + results[responseName] = result; + if ((0, _isPromise.default)(result)) { + containsPromise = true; + } + } + } + if (!containsPromise) { + return results; + } + return (0, _promiseForObject.default)(results); + } + function collectFields(exeContext, runtimeType, selectionSet, fields, visitedFragmentNames) { + for (var _i6 = 0, _selectionSet$selecti2 = selectionSet.selections; _i6 < _selectionSet$selecti2.length; _i6++) { + var selection = _selectionSet$selecti2[_i6]; + switch (selection.kind) { + case _kinds.Kind.FIELD: { + if (!shouldIncludeNode(exeContext, selection)) { + continue; + } + var name = getFieldEntryKey(selection); + if (!fields[name]) { + fields[name] = []; + } + fields[name].push(selection); + break; + } + case _kinds.Kind.INLINE_FRAGMENT: { + if (!shouldIncludeNode(exeContext, selection) || !doesFragmentConditionMatch(exeContext, selection, runtimeType)) { + continue; + } + collectFields(exeContext, runtimeType, selection.selectionSet, fields, visitedFragmentNames); + break; + } + case _kinds.Kind.FRAGMENT_SPREAD: { + var fragName = selection.name.value; + if (visitedFragmentNames[fragName] || !shouldIncludeNode(exeContext, selection)) { + continue; + } + visitedFragmentNames[fragName] = true; + var fragment = exeContext.fragments[fragName]; + if (!fragment || !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) { + continue; + } + collectFields(exeContext, runtimeType, fragment.selectionSet, fields, visitedFragmentNames); + break; + } + } + } + return fields; + } + function shouldIncludeNode(exeContext, node) { + var skip = (0, _values.getDirectiveValues)(_directives.GraphQLSkipDirective, node, exeContext.variableValues); + if ((skip === null || skip === void 0 ? void 0 : skip.if) === true) { + return false; + } + var include = (0, _values.getDirectiveValues)(_directives.GraphQLIncludeDirective, node, exeContext.variableValues); + if ((include === null || include === void 0 ? void 0 : include.if) === false) { + return false; + } + return true; + } + function doesFragmentConditionMatch(exeContext, fragment, type) { + var typeConditionNode = fragment.typeCondition; + if (!typeConditionNode) { + return true; + } + var conditionalType = (0, _typeFromAST.typeFromAST)(exeContext.schema, typeConditionNode); + if (conditionalType === type) { + return true; + } + if ((0, _definition.isAbstractType)(conditionalType)) { + return exeContext.schema.isSubType(conditionalType, type); + } + return false; + } + function getFieldEntryKey(node) { + return node.alias ? node.alias.value : node.name.value; + } + function resolveField(exeContext, parentType, source, fieldNodes, path) { + var _fieldDef$resolve; + var fieldNode = fieldNodes[0]; + var fieldName = fieldNode.name.value; + var fieldDef = getFieldDef(exeContext.schema, parentType, fieldName); + if (!fieldDef) { + return; + } + var returnType = fieldDef.type; + var resolveFn = (_fieldDef$resolve = fieldDef.resolve) !== null && _fieldDef$resolve !== void 0 ? _fieldDef$resolve : exeContext.fieldResolver; + var info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path); + try { + var args = (0, _values.getArgumentValues)(fieldDef, fieldNodes[0], exeContext.variableValues); + var _contextValue = exeContext.contextValue; + var result = resolveFn(source, args, _contextValue, info); + var completed; + if ((0, _isPromise.default)(result)) { + completed = result.then(function(resolved) { + return completeValue(exeContext, returnType, fieldNodes, info, path, resolved); + }); + } else { + completed = completeValue(exeContext, returnType, fieldNodes, info, path, result); + } + if ((0, _isPromise.default)(completed)) { + return completed.then(void 0, function(rawError) { + var error2 = (0, _locatedError.locatedError)(rawError, fieldNodes, (0, _Path.pathToArray)(path)); + return handleFieldError(error2, returnType, exeContext); + }); + } + return completed; + } catch (rawError) { + var error = (0, _locatedError.locatedError)(rawError, fieldNodes, (0, _Path.pathToArray)(path)); + return handleFieldError(error, returnType, exeContext); + } + } + function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) { + return { + fieldName: fieldDef.name, + fieldNodes, + returnType: fieldDef.type, + parentType, + path, + schema: exeContext.schema, + fragments: exeContext.fragments, + rootValue: exeContext.rootValue, + operation: exeContext.operation, + variableValues: exeContext.variableValues + }; + } + function handleFieldError(error, returnType, exeContext) { + if ((0, _definition.isNonNullType)(returnType)) { + throw error; + } + exeContext.errors.push(error); + return null; + } + function completeValue(exeContext, returnType, fieldNodes, info, path, result) { + if (result instanceof Error) { + throw result; + } + if ((0, _definition.isNonNullType)(returnType)) { + var completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result); + if (completed === null) { + throw new Error("Cannot return null for non-nullable field ".concat(info.parentType.name, ".").concat(info.fieldName, ".")); + } + return completed; + } + if (result == null) { + return null; + } + if ((0, _definition.isListType)(returnType)) { + return completeListValue(exeContext, returnType, fieldNodes, info, path, result); + } + if ((0, _definition.isLeafType)(returnType)) { + return completeLeafValue(returnType, result); + } + if ((0, _definition.isAbstractType)(returnType)) { + return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result); + } + if ((0, _definition.isObjectType)(returnType)) { + return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result); + } + (0, _invariant.default)(0, "Cannot complete value of unexpected output type: " + (0, _inspect.default)(returnType)); + } + function completeListValue(exeContext, returnType, fieldNodes, info, path, result) { + var itemType = returnType.ofType; + var containsPromise = false; + var completedResults = (0, _safeArrayFrom.default)(result, function(item, index) { + var itemPath = (0, _Path.addPath)(path, index, void 0); + try { + var completedItem; + if ((0, _isPromise.default)(item)) { + completedItem = item.then(function(resolved) { + return completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved); + }); + } else { + completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item); + } + if ((0, _isPromise.default)(completedItem)) { + containsPromise = true; + return completedItem.then(void 0, function(rawError) { + var error2 = (0, _locatedError.locatedError)(rawError, fieldNodes, (0, _Path.pathToArray)(itemPath)); + return handleFieldError(error2, itemType, exeContext); + }); + } + return completedItem; + } catch (rawError) { + var error = (0, _locatedError.locatedError)(rawError, fieldNodes, (0, _Path.pathToArray)(itemPath)); + return handleFieldError(error, itemType, exeContext); + } + }); + if (completedResults == null) { + throw new _GraphQLError.GraphQLError('Expected Iterable, but did not find one for field "'.concat(info.parentType.name, ".").concat(info.fieldName, '".')); + } + return containsPromise ? Promise.all(completedResults) : completedResults; + } + function completeLeafValue(returnType, result) { + var serializedResult = returnType.serialize(result); + if (serializedResult === void 0) { + throw new Error('Expected a value of type "'.concat((0, _inspect.default)(returnType), '" but ') + "received: ".concat((0, _inspect.default)(result))); + } + return serializedResult; + } + function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) { + var _returnType$resolveTy; + var resolveTypeFn = (_returnType$resolveTy = returnType.resolveType) !== null && _returnType$resolveTy !== void 0 ? _returnType$resolveTy : exeContext.typeResolver; + var contextValue = exeContext.contextValue; + var runtimeType = resolveTypeFn(result, contextValue, info, returnType); + if ((0, _isPromise.default)(runtimeType)) { + return runtimeType.then(function(resolvedRuntimeType) { + return completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result); + }); + } + return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result); + } + function ensureValidRuntimeType(runtimeTypeOrName, exeContext, returnType, fieldNodes, info, result) { + if (runtimeTypeOrName == null) { + throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" must resolve to an Object type at runtime for field "').concat(info.parentType.name, ".").concat(info.fieldName, '". Either the "').concat(returnType.name, '" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.'), fieldNodes); + } + var runtimeTypeName = (0, _definition.isNamedType)(runtimeTypeOrName) ? runtimeTypeOrName.name : runtimeTypeOrName; + if (typeof runtimeTypeName !== "string") { + throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" must resolve to an Object type at runtime for field "').concat(info.parentType.name, ".").concat(info.fieldName, '" with ') + "value ".concat((0, _inspect.default)(result), ', received "').concat((0, _inspect.default)(runtimeTypeOrName), '".')); + } + var runtimeType = exeContext.schema.getType(runtimeTypeName); + if (runtimeType == null) { + throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" was resolve to a type "').concat(runtimeTypeName, '" that does not exist inside schema.'), fieldNodes); + } + if (!(0, _definition.isObjectType)(runtimeType)) { + throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" was resolve to a non-object type "').concat(runtimeTypeName, '".'), fieldNodes); + } + if (!exeContext.schema.isSubType(returnType, runtimeType)) { + throw new _GraphQLError.GraphQLError('Runtime Object type "'.concat(runtimeType.name, '" is not a possible type for "').concat(returnType.name, '".'), fieldNodes); + } + return runtimeType; + } + function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result) { + if (returnType.isTypeOf) { + var isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info); + if ((0, _isPromise.default)(isTypeOf)) { + return isTypeOf.then(function(resolvedIsTypeOf) { + if (!resolvedIsTypeOf) { + throw invalidReturnTypeError(returnType, result, fieldNodes); + } + return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result); + }); + } + if (!isTypeOf) { + throw invalidReturnTypeError(returnType, result, fieldNodes); + } + } + return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result); + } + function invalidReturnTypeError(returnType, result, fieldNodes) { + return new _GraphQLError.GraphQLError('Expected value of type "'.concat(returnType.name, '" but got: ').concat((0, _inspect.default)(result), "."), fieldNodes); + } + function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result) { + var subFieldNodes = collectSubfields(exeContext, returnType, fieldNodes); + return executeFields(exeContext, returnType, result, path, subFieldNodes); + } + var collectSubfields = (0, _memoize.default)(_collectSubfields); + function _collectSubfields(exeContext, returnType, fieldNodes) { + var subFieldNodes = Object.create(null); + var visitedFragmentNames = Object.create(null); + for (var _i8 = 0; _i8 < fieldNodes.length; _i8++) { + var node = fieldNodes[_i8]; + if (node.selectionSet) { + subFieldNodes = collectFields(exeContext, returnType, node.selectionSet, subFieldNodes, visitedFragmentNames); + } + } + return subFieldNodes; + } + var defaultTypeResolver = function defaultTypeResolver2(value, contextValue, info, abstractType) { + if ((0, _isObjectLike.default)(value) && typeof value.__typename === "string") { + return value.__typename; + } + var possibleTypes = info.schema.getPossibleTypes(abstractType); + var promisedIsTypeOfResults = []; + for (var i = 0; i < possibleTypes.length; i++) { + var type = possibleTypes[i]; + if (type.isTypeOf) { + var isTypeOfResult = type.isTypeOf(value, contextValue, info); + if ((0, _isPromise.default)(isTypeOfResult)) { + promisedIsTypeOfResults[i] = isTypeOfResult; + } else if (isTypeOfResult) { + return type.name; + } + } + } + if (promisedIsTypeOfResults.length) { + return Promise.all(promisedIsTypeOfResults).then(function(isTypeOfResults) { + for (var _i9 = 0; _i9 < isTypeOfResults.length; _i9++) { + if (isTypeOfResults[_i9]) { + return possibleTypes[_i9].name; + } + } + }); + } + }; + exports2.defaultTypeResolver = defaultTypeResolver; + var defaultFieldResolver = function defaultFieldResolver2(source, args, contextValue, info) { + if ((0, _isObjectLike.default)(source) || typeof source === "function") { + var property = source[info.fieldName]; + if (typeof property === "function") { + return source[info.fieldName](args, contextValue, info); + } + return property; + } + }; + exports2.defaultFieldResolver = defaultFieldResolver; + function getFieldDef(schema2, parentType, fieldName) { + if (fieldName === _introspection.SchemaMetaFieldDef.name && schema2.getQueryType() === parentType) { + return _introspection.SchemaMetaFieldDef; + } else if (fieldName === _introspection.TypeMetaFieldDef.name && schema2.getQueryType() === parentType) { + return _introspection.TypeMetaFieldDef; + } else if (fieldName === _introspection.TypeNameMetaFieldDef.name) { + return _introspection.TypeNameMetaFieldDef; + } + return parentType.getFields()[fieldName]; + } + } +}); + +// node_modules/graphql/graphql.js +var require_graphql = __commonJS({ + "node_modules/graphql/graphql.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.graphql = graphql; + exports2.graphqlSync = graphqlSync; + var _isPromise = _interopRequireDefault(require_isPromise()); + var _parser = require_parser(); + var _validate = require_validate2(); + var _validate2 = require_validate(); + var _execute = require_execute(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function graphql(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) { + var _arguments = arguments; + return new Promise(function(resolve) { + return resolve(_arguments.length === 1 ? graphqlImpl(argsOrSchema) : graphqlImpl({ + schema: argsOrSchema, + source, + rootValue, + contextValue, + variableValues, + operationName, + fieldResolver, + typeResolver + })); + }); + } + function graphqlSync(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) { + var result = arguments.length === 1 ? graphqlImpl(argsOrSchema) : graphqlImpl({ + schema: argsOrSchema, + source, + rootValue, + contextValue, + variableValues, + operationName, + fieldResolver, + typeResolver + }); + if ((0, _isPromise.default)(result)) { + throw new Error("GraphQL execution failed to complete synchronously."); + } + return result; + } + function graphqlImpl(args) { + var schema2 = args.schema, source = args.source, rootValue = args.rootValue, contextValue = args.contextValue, variableValues = args.variableValues, operationName = args.operationName, fieldResolver = args.fieldResolver, typeResolver = args.typeResolver; + var schemaValidationErrors = (0, _validate2.validateSchema)(schema2); + if (schemaValidationErrors.length > 0) { + return { + errors: schemaValidationErrors + }; + } + var document2; + try { + document2 = (0, _parser.parse)(source); + } catch (syntaxError) { + return { + errors: [syntaxError] + }; + } + var validationErrors = (0, _validate.validate)(schema2, document2); + if (validationErrors.length > 0) { + return { + errors: validationErrors + }; + } + return (0, _execute.execute)({ + schema: schema2, + document: document2, + rootValue, + contextValue, + variableValues, + operationName, + fieldResolver, + typeResolver + }); + } + } +}); + +// node_modules/graphql/type/index.js +var require_type = __commonJS({ + "node_modules/graphql/type/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "isSchema", { + enumerable: true, + get: function get() { + return _schema.isSchema; + } + }); + Object.defineProperty(exports2, "assertSchema", { + enumerable: true, + get: function get() { + return _schema.assertSchema; + } + }); + Object.defineProperty(exports2, "GraphQLSchema", { + enumerable: true, + get: function get() { + return _schema.GraphQLSchema; + } + }); + Object.defineProperty(exports2, "isType", { + enumerable: true, + get: function get() { + return _definition.isType; + } + }); + Object.defineProperty(exports2, "isScalarType", { + enumerable: true, + get: function get() { + return _definition.isScalarType; + } + }); + Object.defineProperty(exports2, "isObjectType", { + enumerable: true, + get: function get() { + return _definition.isObjectType; + } + }); + Object.defineProperty(exports2, "isInterfaceType", { + enumerable: true, + get: function get() { + return _definition.isInterfaceType; + } + }); + Object.defineProperty(exports2, "isUnionType", { + enumerable: true, + get: function get() { + return _definition.isUnionType; + } + }); + Object.defineProperty(exports2, "isEnumType", { + enumerable: true, + get: function get() { + return _definition.isEnumType; + } + }); + Object.defineProperty(exports2, "isInputObjectType", { + enumerable: true, + get: function get() { + return _definition.isInputObjectType; + } + }); + Object.defineProperty(exports2, "isListType", { + enumerable: true, + get: function get() { + return _definition.isListType; + } + }); + Object.defineProperty(exports2, "isNonNullType", { + enumerable: true, + get: function get() { + return _definition.isNonNullType; + } + }); + Object.defineProperty(exports2, "isInputType", { + enumerable: true, + get: function get() { + return _definition.isInputType; + } + }); + Object.defineProperty(exports2, "isOutputType", { + enumerable: true, + get: function get() { + return _definition.isOutputType; + } + }); + Object.defineProperty(exports2, "isLeafType", { + enumerable: true, + get: function get() { + return _definition.isLeafType; + } + }); + Object.defineProperty(exports2, "isCompositeType", { + enumerable: true, + get: function get() { + return _definition.isCompositeType; + } + }); + Object.defineProperty(exports2, "isAbstractType", { + enumerable: true, + get: function get() { + return _definition.isAbstractType; + } + }); + Object.defineProperty(exports2, "isWrappingType", { + enumerable: true, + get: function get() { + return _definition.isWrappingType; + } + }); + Object.defineProperty(exports2, "isNullableType", { + enumerable: true, + get: function get() { + return _definition.isNullableType; + } + }); + Object.defineProperty(exports2, "isNamedType", { + enumerable: true, + get: function get() { + return _definition.isNamedType; + } + }); + Object.defineProperty(exports2, "isRequiredArgument", { + enumerable: true, + get: function get() { + return _definition.isRequiredArgument; + } + }); + Object.defineProperty(exports2, "isRequiredInputField", { + enumerable: true, + get: function get() { + return _definition.isRequiredInputField; + } + }); + Object.defineProperty(exports2, "assertType", { + enumerable: true, + get: function get() { + return _definition.assertType; + } + }); + Object.defineProperty(exports2, "assertScalarType", { + enumerable: true, + get: function get() { + return _definition.assertScalarType; + } + }); + Object.defineProperty(exports2, "assertObjectType", { + enumerable: true, + get: function get() { + return _definition.assertObjectType; + } + }); + Object.defineProperty(exports2, "assertInterfaceType", { + enumerable: true, + get: function get() { + return _definition.assertInterfaceType; + } + }); + Object.defineProperty(exports2, "assertUnionType", { + enumerable: true, + get: function get() { + return _definition.assertUnionType; + } + }); + Object.defineProperty(exports2, "assertEnumType", { + enumerable: true, + get: function get() { + return _definition.assertEnumType; + } + }); + Object.defineProperty(exports2, "assertInputObjectType", { + enumerable: true, + get: function get() { + return _definition.assertInputObjectType; + } + }); + Object.defineProperty(exports2, "assertListType", { + enumerable: true, + get: function get() { + return _definition.assertListType; + } + }); + Object.defineProperty(exports2, "assertNonNullType", { + enumerable: true, + get: function get() { + return _definition.assertNonNullType; + } + }); + Object.defineProperty(exports2, "assertInputType", { + enumerable: true, + get: function get() { + return _definition.assertInputType; + } + }); + Object.defineProperty(exports2, "assertOutputType", { + enumerable: true, + get: function get() { + return _definition.assertOutputType; + } + }); + Object.defineProperty(exports2, "assertLeafType", { + enumerable: true, + get: function get() { + return _definition.assertLeafType; + } + }); + Object.defineProperty(exports2, "assertCompositeType", { + enumerable: true, + get: function get() { + return _definition.assertCompositeType; + } + }); + Object.defineProperty(exports2, "assertAbstractType", { + enumerable: true, + get: function get() { + return _definition.assertAbstractType; + } + }); + Object.defineProperty(exports2, "assertWrappingType", { + enumerable: true, + get: function get() { + return _definition.assertWrappingType; + } + }); + Object.defineProperty(exports2, "assertNullableType", { + enumerable: true, + get: function get() { + return _definition.assertNullableType; + } + }); + Object.defineProperty(exports2, "assertNamedType", { + enumerable: true, + get: function get() { + return _definition.assertNamedType; + } + }); + Object.defineProperty(exports2, "getNullableType", { + enumerable: true, + get: function get() { + return _definition.getNullableType; + } + }); + Object.defineProperty(exports2, "getNamedType", { + enumerable: true, + get: function get() { + return _definition.getNamedType; + } + }); + Object.defineProperty(exports2, "GraphQLScalarType", { + enumerable: true, + get: function get() { + return _definition.GraphQLScalarType; + } + }); + Object.defineProperty(exports2, "GraphQLObjectType", { + enumerable: true, + get: function get() { + return _definition.GraphQLObjectType; + } + }); + Object.defineProperty(exports2, "GraphQLInterfaceType", { + enumerable: true, + get: function get() { + return _definition.GraphQLInterfaceType; + } + }); + Object.defineProperty(exports2, "GraphQLUnionType", { + enumerable: true, + get: function get() { + return _definition.GraphQLUnionType; + } + }); + Object.defineProperty(exports2, "GraphQLEnumType", { + enumerable: true, + get: function get() { + return _definition.GraphQLEnumType; + } + }); + Object.defineProperty(exports2, "GraphQLInputObjectType", { + enumerable: true, + get: function get() { + return _definition.GraphQLInputObjectType; + } + }); + Object.defineProperty(exports2, "GraphQLList", { + enumerable: true, + get: function get() { + return _definition.GraphQLList; + } + }); + Object.defineProperty(exports2, "GraphQLNonNull", { + enumerable: true, + get: function get() { + return _definition.GraphQLNonNull; + } + }); + Object.defineProperty(exports2, "isDirective", { + enumerable: true, + get: function get() { + return _directives.isDirective; + } + }); + Object.defineProperty(exports2, "assertDirective", { + enumerable: true, + get: function get() { + return _directives.assertDirective; + } + }); + Object.defineProperty(exports2, "GraphQLDirective", { + enumerable: true, + get: function get() { + return _directives.GraphQLDirective; + } + }); + Object.defineProperty(exports2, "isSpecifiedDirective", { + enumerable: true, + get: function get() { + return _directives.isSpecifiedDirective; + } + }); + Object.defineProperty(exports2, "specifiedDirectives", { + enumerable: true, + get: function get() { + return _directives.specifiedDirectives; + } + }); + Object.defineProperty(exports2, "GraphQLIncludeDirective", { + enumerable: true, + get: function get() { + return _directives.GraphQLIncludeDirective; + } + }); + Object.defineProperty(exports2, "GraphQLSkipDirective", { + enumerable: true, + get: function get() { + return _directives.GraphQLSkipDirective; + } + }); + Object.defineProperty(exports2, "GraphQLDeprecatedDirective", { + enumerable: true, + get: function get() { + return _directives.GraphQLDeprecatedDirective; + } + }); + Object.defineProperty(exports2, "GraphQLSpecifiedByDirective", { + enumerable: true, + get: function get() { + return _directives.GraphQLSpecifiedByDirective; + } + }); + Object.defineProperty(exports2, "DEFAULT_DEPRECATION_REASON", { + enumerable: true, + get: function get() { + return _directives.DEFAULT_DEPRECATION_REASON; + } + }); + Object.defineProperty(exports2, "isSpecifiedScalarType", { + enumerable: true, + get: function get() { + return _scalars.isSpecifiedScalarType; + } + }); + Object.defineProperty(exports2, "specifiedScalarTypes", { + enumerable: true, + get: function get() { + return _scalars.specifiedScalarTypes; + } + }); + Object.defineProperty(exports2, "GraphQLInt", { + enumerable: true, + get: function get() { + return _scalars.GraphQLInt; + } + }); + Object.defineProperty(exports2, "GraphQLFloat", { + enumerable: true, + get: function get() { + return _scalars.GraphQLFloat; + } + }); + Object.defineProperty(exports2, "GraphQLString", { + enumerable: true, + get: function get() { + return _scalars.GraphQLString; + } + }); + Object.defineProperty(exports2, "GraphQLBoolean", { + enumerable: true, + get: function get() { + return _scalars.GraphQLBoolean; + } + }); + Object.defineProperty(exports2, "GraphQLID", { + enumerable: true, + get: function get() { + return _scalars.GraphQLID; + } + }); + Object.defineProperty(exports2, "isIntrospectionType", { + enumerable: true, + get: function get() { + return _introspection.isIntrospectionType; + } + }); + Object.defineProperty(exports2, "introspectionTypes", { + enumerable: true, + get: function get() { + return _introspection.introspectionTypes; + } + }); + Object.defineProperty(exports2, "__Schema", { + enumerable: true, + get: function get() { + return _introspection.__Schema; + } + }); + Object.defineProperty(exports2, "__Directive", { + enumerable: true, + get: function get() { + return _introspection.__Directive; + } + }); + Object.defineProperty(exports2, "__DirectiveLocation", { + enumerable: true, + get: function get() { + return _introspection.__DirectiveLocation; + } + }); + Object.defineProperty(exports2, "__Type", { + enumerable: true, + get: function get() { + return _introspection.__Type; + } + }); + Object.defineProperty(exports2, "__Field", { + enumerable: true, + get: function get() { + return _introspection.__Field; + } + }); + Object.defineProperty(exports2, "__InputValue", { + enumerable: true, + get: function get() { + return _introspection.__InputValue; + } + }); + Object.defineProperty(exports2, "__EnumValue", { + enumerable: true, + get: function get() { + return _introspection.__EnumValue; + } + }); + Object.defineProperty(exports2, "__TypeKind", { + enumerable: true, + get: function get() { + return _introspection.__TypeKind; + } + }); + Object.defineProperty(exports2, "TypeKind", { + enumerable: true, + get: function get() { + return _introspection.TypeKind; + } + }); + Object.defineProperty(exports2, "SchemaMetaFieldDef", { + enumerable: true, + get: function get() { + return _introspection.SchemaMetaFieldDef; + } + }); + Object.defineProperty(exports2, "TypeMetaFieldDef", { + enumerable: true, + get: function get() { + return _introspection.TypeMetaFieldDef; + } + }); + Object.defineProperty(exports2, "TypeNameMetaFieldDef", { + enumerable: true, + get: function get() { + return _introspection.TypeNameMetaFieldDef; + } + }); + Object.defineProperty(exports2, "validateSchema", { + enumerable: true, + get: function get() { + return _validate.validateSchema; + } + }); + Object.defineProperty(exports2, "assertValidSchema", { + enumerable: true, + get: function get() { + return _validate.assertValidSchema; + } + }); + var _schema = require_schema(); + var _definition = require_definition(); + var _directives = require_directives(); + var _scalars = require_scalars(); + var _introspection = require_introspection(); + var _validate = require_validate(); + } +}); + +// node_modules/graphql/language/index.js +var require_language = __commonJS({ + "node_modules/graphql/language/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "Source", { + enumerable: true, + get: function get() { + return _source.Source; + } + }); + Object.defineProperty(exports2, "getLocation", { + enumerable: true, + get: function get() { + return _location.getLocation; + } + }); + Object.defineProperty(exports2, "printLocation", { + enumerable: true, + get: function get() { + return _printLocation.printLocation; + } + }); + Object.defineProperty(exports2, "printSourceLocation", { + enumerable: true, + get: function get() { + return _printLocation.printSourceLocation; + } + }); + Object.defineProperty(exports2, "Kind", { + enumerable: true, + get: function get() { + return _kinds.Kind; + } + }); + Object.defineProperty(exports2, "TokenKind", { + enumerable: true, + get: function get() { + return _tokenKind.TokenKind; + } + }); + Object.defineProperty(exports2, "Lexer", { + enumerable: true, + get: function get() { + return _lexer.Lexer; + } + }); + Object.defineProperty(exports2, "parse", { + enumerable: true, + get: function get() { + return _parser.parse; + } + }); + Object.defineProperty(exports2, "parseValue", { + enumerable: true, + get: function get() { + return _parser.parseValue; + } + }); + Object.defineProperty(exports2, "parseType", { + enumerable: true, + get: function get() { + return _parser.parseType; + } + }); + Object.defineProperty(exports2, "print", { + enumerable: true, + get: function get() { + return _printer.print; + } + }); + Object.defineProperty(exports2, "visit", { + enumerable: true, + get: function get() { + return _visitor.visit; + } + }); + Object.defineProperty(exports2, "visitInParallel", { + enumerable: true, + get: function get() { + return _visitor.visitInParallel; + } + }); + Object.defineProperty(exports2, "getVisitFn", { + enumerable: true, + get: function get() { + return _visitor.getVisitFn; + } + }); + Object.defineProperty(exports2, "BREAK", { + enumerable: true, + get: function get() { + return _visitor.BREAK; + } + }); + Object.defineProperty(exports2, "Location", { + enumerable: true, + get: function get() { + return _ast.Location; + } + }); + Object.defineProperty(exports2, "Token", { + enumerable: true, + get: function get() { + return _ast.Token; + } + }); + Object.defineProperty(exports2, "isDefinitionNode", { + enumerable: true, + get: function get() { + return _predicates.isDefinitionNode; + } + }); + Object.defineProperty(exports2, "isExecutableDefinitionNode", { + enumerable: true, + get: function get() { + return _predicates.isExecutableDefinitionNode; + } + }); + Object.defineProperty(exports2, "isSelectionNode", { + enumerable: true, + get: function get() { + return _predicates.isSelectionNode; + } + }); + Object.defineProperty(exports2, "isValueNode", { + enumerable: true, + get: function get() { + return _predicates.isValueNode; + } + }); + Object.defineProperty(exports2, "isTypeNode", { + enumerable: true, + get: function get() { + return _predicates.isTypeNode; + } + }); + Object.defineProperty(exports2, "isTypeSystemDefinitionNode", { + enumerable: true, + get: function get() { + return _predicates.isTypeSystemDefinitionNode; + } + }); + Object.defineProperty(exports2, "isTypeDefinitionNode", { + enumerable: true, + get: function get() { + return _predicates.isTypeDefinitionNode; + } + }); + Object.defineProperty(exports2, "isTypeSystemExtensionNode", { + enumerable: true, + get: function get() { + return _predicates.isTypeSystemExtensionNode; + } + }); + Object.defineProperty(exports2, "isTypeExtensionNode", { + enumerable: true, + get: function get() { + return _predicates.isTypeExtensionNode; + } + }); + Object.defineProperty(exports2, "DirectiveLocation", { + enumerable: true, + get: function get() { + return _directiveLocation.DirectiveLocation; + } + }); + var _source = require_source(); + var _location = require_location(); + var _printLocation = require_printLocation(); + var _kinds = require_kinds(); + var _tokenKind = require_tokenKind(); + var _lexer = require_lexer(); + var _parser = require_parser(); + var _printer = require_printer(); + var _visitor = require_visitor(); + var _ast = require_ast(); + var _predicates = require_predicates(); + var _directiveLocation = require_directiveLocation(); + } +}); + +// node_modules/graphql/execution/index.js +var require_execution = __commonJS({ + "node_modules/graphql/execution/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "responsePathAsArray", { + enumerable: true, + get: function get() { + return _Path.pathToArray; + } + }); + Object.defineProperty(exports2, "execute", { + enumerable: true, + get: function get() { + return _execute.execute; + } + }); + Object.defineProperty(exports2, "executeSync", { + enumerable: true, + get: function get() { + return _execute.executeSync; + } + }); + Object.defineProperty(exports2, "defaultFieldResolver", { + enumerable: true, + get: function get() { + return _execute.defaultFieldResolver; + } + }); + Object.defineProperty(exports2, "defaultTypeResolver", { + enumerable: true, + get: function get() { + return _execute.defaultTypeResolver; + } + }); + Object.defineProperty(exports2, "getDirectiveValues", { + enumerable: true, + get: function get() { + return _values.getDirectiveValues; + } + }); + var _Path = require_Path(); + var _execute = require_execute(); + var _values = require_values(); + } +}); + +// node_modules/graphql/jsutils/isAsyncIterable.js +var require_isAsyncIterable = __commonJS({ + "node_modules/graphql/jsutils/isAsyncIterable.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = isAsyncIterable; + var _symbols = require_symbols(); + function isAsyncIterable(maybeAsyncIterable) { + return typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0 ? void 0 : maybeAsyncIterable[_symbols.SYMBOL_ASYNC_ITERATOR]) === "function"; + } + } +}); + +// node_modules/graphql/subscription/mapAsyncIterator.js +var require_mapAsyncIterator = __commonJS({ + "node_modules/graphql/subscription/mapAsyncIterator.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = mapAsyncIterator; + var _symbols = require_symbols(); + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function mapAsyncIterator(iterable, callback, rejectCallback) { + var iteratorMethod = iterable[_symbols.SYMBOL_ASYNC_ITERATOR]; + var iterator = iteratorMethod.call(iterable); + var $return; + var abruptClose; + if (typeof iterator.return === "function") { + $return = iterator.return; + abruptClose = function abruptClose2(error) { + var rethrow = function rethrow2() { + return Promise.reject(error); + }; + return $return.call(iterator).then(rethrow, rethrow); + }; + } + function mapResult(result) { + return result.done ? result : asyncMapValue(result.value, callback).then(iteratorResult, abruptClose); + } + var mapReject; + if (rejectCallback) { + var reject = rejectCallback; + mapReject = function mapReject2(error) { + return asyncMapValue(error, reject).then(iteratorResult, abruptClose); + }; + } + return _defineProperty({ + next: function next() { + return iterator.next().then(mapResult, mapReject); + }, + return: function _return() { + return $return ? $return.call(iterator).then(mapResult, mapReject) : Promise.resolve({ + value: void 0, + done: true + }); + }, + throw: function _throw(error) { + if (typeof iterator.throw === "function") { + return iterator.throw(error).then(mapResult, mapReject); + } + return Promise.reject(error).catch(abruptClose); + } + }, _symbols.SYMBOL_ASYNC_ITERATOR, function() { + return this; + }); + } + function asyncMapValue(value, callback) { + return new Promise(function(resolve) { + return resolve(callback(value)); + }); + } + function iteratorResult(value) { + return { + value, + done: false + }; + } + } +}); + +// node_modules/graphql/subscription/subscribe.js +var require_subscribe = __commonJS({ + "node_modules/graphql/subscription/subscribe.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.subscribe = subscribe; + exports2.createSourceEventStream = createSourceEventStream; + var _inspect = _interopRequireDefault(require_inspect()); + var _isAsyncIterable = _interopRequireDefault(require_isAsyncIterable()); + var _Path = require_Path(); + var _GraphQLError = require_GraphQLError(); + var _locatedError = require_locatedError(); + var _values = require_values(); + var _execute = require_execute(); + var _getOperationRootType = require_getOperationRootType(); + var _mapAsyncIterator = _interopRequireDefault(require_mapAsyncIterator()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function subscribe(argsOrSchema, document2, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) { + return arguments.length === 1 ? subscribeImpl(argsOrSchema) : subscribeImpl({ + schema: argsOrSchema, + document: document2, + rootValue, + contextValue, + variableValues, + operationName, + fieldResolver, + subscribeFieldResolver + }); + } + function reportGraphQLError(error) { + if (error instanceof _GraphQLError.GraphQLError) { + return { + errors: [error] + }; + } + throw error; + } + function subscribeImpl(args) { + var schema2 = args.schema, document2 = args.document, rootValue = args.rootValue, contextValue = args.contextValue, variableValues = args.variableValues, operationName = args.operationName, fieldResolver = args.fieldResolver, subscribeFieldResolver = args.subscribeFieldResolver; + var sourcePromise = createSourceEventStream(schema2, document2, rootValue, contextValue, variableValues, operationName, subscribeFieldResolver); + var mapSourceToResponse = function mapSourceToResponse2(payload) { + return (0, _execute.execute)({ + schema: schema2, + document: document2, + rootValue: payload, + contextValue, + variableValues, + operationName, + fieldResolver + }); + }; + return sourcePromise.then(function(resultOrStream) { + return (0, _isAsyncIterable.default)(resultOrStream) ? (0, _mapAsyncIterator.default)(resultOrStream, mapSourceToResponse, reportGraphQLError) : resultOrStream; + }); + } + function createSourceEventStream(schema2, document2, rootValue, contextValue, variableValues, operationName, fieldResolver) { + (0, _execute.assertValidExecutionArguments)(schema2, document2, variableValues); + return new Promise(function(resolve) { + var exeContext = (0, _execute.buildExecutionContext)(schema2, document2, rootValue, contextValue, variableValues, operationName, fieldResolver); + resolve(Array.isArray(exeContext) ? { + errors: exeContext + } : executeSubscription(exeContext)); + }).catch(reportGraphQLError); + } + function executeSubscription(exeContext) { + var schema2 = exeContext.schema, operation = exeContext.operation, variableValues = exeContext.variableValues, rootValue = exeContext.rootValue; + var type = (0, _getOperationRootType.getOperationRootType)(schema2, operation); + var fields = (0, _execute.collectFields)(exeContext, type, operation.selectionSet, Object.create(null), Object.create(null)); + var responseNames = Object.keys(fields); + var responseName = responseNames[0]; + var fieldNodes = fields[responseName]; + var fieldNode = fieldNodes[0]; + var fieldName = fieldNode.name.value; + var fieldDef = (0, _execute.getFieldDef)(schema2, type, fieldName); + if (!fieldDef) { + throw new _GraphQLError.GraphQLError('The subscription field "'.concat(fieldName, '" is not defined.'), fieldNodes); + } + var path = (0, _Path.addPath)(void 0, responseName, type.name); + var info = (0, _execute.buildResolveInfo)(exeContext, fieldDef, fieldNodes, type, path); + return new Promise(function(resolveResult) { + var _fieldDef$subscribe; + var args = (0, _values.getArgumentValues)(fieldDef, fieldNodes[0], variableValues); + var contextValue = exeContext.contextValue; + var resolveFn = (_fieldDef$subscribe = fieldDef.subscribe) !== null && _fieldDef$subscribe !== void 0 ? _fieldDef$subscribe : exeContext.fieldResolver; + resolveResult(resolveFn(rootValue, args, contextValue, info)); + }).then(function(eventStream) { + if (eventStream instanceof Error) { + throw (0, _locatedError.locatedError)(eventStream, fieldNodes, (0, _Path.pathToArray)(path)); + } + if (!(0, _isAsyncIterable.default)(eventStream)) { + throw new Error("Subscription field must return Async Iterable. " + "Received: ".concat((0, _inspect.default)(eventStream), ".")); + } + return eventStream; + }, function(error) { + throw (0, _locatedError.locatedError)(error, fieldNodes, (0, _Path.pathToArray)(path)); + }); + } + } +}); + +// node_modules/graphql/subscription/index.js +var require_subscription = __commonJS({ + "node_modules/graphql/subscription/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "subscribe", { + enumerable: true, + get: function get() { + return _subscribe.subscribe; + } + }); + Object.defineProperty(exports2, "createSourceEventStream", { + enumerable: true, + get: function get() { + return _subscribe.createSourceEventStream; + } + }); + var _subscribe = require_subscribe(); + } +}); + +// node_modules/graphql/validation/rules/custom/NoDeprecatedCustomRule.js +var require_NoDeprecatedCustomRule = __commonJS({ + "node_modules/graphql/validation/rules/custom/NoDeprecatedCustomRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.NoDeprecatedCustomRule = NoDeprecatedCustomRule; + var _invariant = _interopRequireDefault(require_invariant()); + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function NoDeprecatedCustomRule(context) { + return { + Field: function Field(node) { + var fieldDef = context.getFieldDef(); + var deprecationReason = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.deprecationReason; + if (fieldDef && deprecationReason != null) { + var parentType = context.getParentType(); + parentType != null || (0, _invariant.default)(0); + context.reportError(new _GraphQLError.GraphQLError("The field ".concat(parentType.name, ".").concat(fieldDef.name, " is deprecated. ").concat(deprecationReason), node)); + } + }, + Argument: function Argument(node) { + var argDef = context.getArgument(); + var deprecationReason = argDef === null || argDef === void 0 ? void 0 : argDef.deprecationReason; + if (argDef && deprecationReason != null) { + var directiveDef = context.getDirective(); + if (directiveDef != null) { + context.reportError(new _GraphQLError.GraphQLError('Directive "@'.concat(directiveDef.name, '" argument "').concat(argDef.name, '" is deprecated. ').concat(deprecationReason), node)); + } else { + var parentType = context.getParentType(); + var fieldDef = context.getFieldDef(); + parentType != null && fieldDef != null || (0, _invariant.default)(0); + context.reportError(new _GraphQLError.GraphQLError('Field "'.concat(parentType.name, ".").concat(fieldDef.name, '" argument "').concat(argDef.name, '" is deprecated. ').concat(deprecationReason), node)); + } + } + }, + ObjectField: function ObjectField(node) { + var inputObjectDef = (0, _definition.getNamedType)(context.getParentInputType()); + if ((0, _definition.isInputObjectType)(inputObjectDef)) { + var inputFieldDef = inputObjectDef.getFields()[node.name.value]; + var deprecationReason = inputFieldDef === null || inputFieldDef === void 0 ? void 0 : inputFieldDef.deprecationReason; + if (deprecationReason != null) { + context.reportError(new _GraphQLError.GraphQLError("The input field ".concat(inputObjectDef.name, ".").concat(inputFieldDef.name, " is deprecated. ").concat(deprecationReason), node)); + } + } + }, + EnumValue: function EnumValue(node) { + var enumValueDef = context.getEnumValue(); + var deprecationReason = enumValueDef === null || enumValueDef === void 0 ? void 0 : enumValueDef.deprecationReason; + if (enumValueDef && deprecationReason != null) { + var enumTypeDef = (0, _definition.getNamedType)(context.getInputType()); + enumTypeDef != null || (0, _invariant.default)(0); + context.reportError(new _GraphQLError.GraphQLError('The enum value "'.concat(enumTypeDef.name, ".").concat(enumValueDef.name, '" is deprecated. ').concat(deprecationReason), node)); + } + } + }; + } + } +}); + +// node_modules/graphql/validation/rules/custom/NoSchemaIntrospectionCustomRule.js +var require_NoSchemaIntrospectionCustomRule = __commonJS({ + "node_modules/graphql/validation/rules/custom/NoSchemaIntrospectionCustomRule.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.NoSchemaIntrospectionCustomRule = NoSchemaIntrospectionCustomRule; + var _GraphQLError = require_GraphQLError(); + var _definition = require_definition(); + var _introspection = require_introspection(); + function NoSchemaIntrospectionCustomRule(context) { + return { + Field: function Field(node) { + var type = (0, _definition.getNamedType)(context.getType()); + if (type && (0, _introspection.isIntrospectionType)(type)) { + context.reportError(new _GraphQLError.GraphQLError('GraphQL introspection has been disabled, but the requested query contained the field "'.concat(node.name.value, '".'), node)); + } + } + }; + } + } +}); + +// node_modules/graphql/validation/index.js +var require_validation = __commonJS({ + "node_modules/graphql/validation/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "validate", { + enumerable: true, + get: function get() { + return _validate.validate; + } + }); + Object.defineProperty(exports2, "ValidationContext", { + enumerable: true, + get: function get() { + return _ValidationContext.ValidationContext; + } + }); + Object.defineProperty(exports2, "specifiedRules", { + enumerable: true, + get: function get() { + return _specifiedRules.specifiedRules; + } + }); + Object.defineProperty(exports2, "ExecutableDefinitionsRule", { + enumerable: true, + get: function get() { + return _ExecutableDefinitionsRule.ExecutableDefinitionsRule; + } + }); + Object.defineProperty(exports2, "FieldsOnCorrectTypeRule", { + enumerable: true, + get: function get() { + return _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule; + } + }); + Object.defineProperty(exports2, "FragmentsOnCompositeTypesRule", { + enumerable: true, + get: function get() { + return _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule; + } + }); + Object.defineProperty(exports2, "KnownArgumentNamesRule", { + enumerable: true, + get: function get() { + return _KnownArgumentNamesRule.KnownArgumentNamesRule; + } + }); + Object.defineProperty(exports2, "KnownDirectivesRule", { + enumerable: true, + get: function get() { + return _KnownDirectivesRule.KnownDirectivesRule; + } + }); + Object.defineProperty(exports2, "KnownFragmentNamesRule", { + enumerable: true, + get: function get() { + return _KnownFragmentNamesRule.KnownFragmentNamesRule; + } + }); + Object.defineProperty(exports2, "KnownTypeNamesRule", { + enumerable: true, + get: function get() { + return _KnownTypeNamesRule.KnownTypeNamesRule; + } + }); + Object.defineProperty(exports2, "LoneAnonymousOperationRule", { + enumerable: true, + get: function get() { + return _LoneAnonymousOperationRule.LoneAnonymousOperationRule; + } + }); + Object.defineProperty(exports2, "NoFragmentCyclesRule", { + enumerable: true, + get: function get() { + return _NoFragmentCyclesRule.NoFragmentCyclesRule; + } + }); + Object.defineProperty(exports2, "NoUndefinedVariablesRule", { + enumerable: true, + get: function get() { + return _NoUndefinedVariablesRule.NoUndefinedVariablesRule; + } + }); + Object.defineProperty(exports2, "NoUnusedFragmentsRule", { + enumerable: true, + get: function get() { + return _NoUnusedFragmentsRule.NoUnusedFragmentsRule; + } + }); + Object.defineProperty(exports2, "NoUnusedVariablesRule", { + enumerable: true, + get: function get() { + return _NoUnusedVariablesRule.NoUnusedVariablesRule; + } + }); + Object.defineProperty(exports2, "OverlappingFieldsCanBeMergedRule", { + enumerable: true, + get: function get() { + return _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule; + } + }); + Object.defineProperty(exports2, "PossibleFragmentSpreadsRule", { + enumerable: true, + get: function get() { + return _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule; + } + }); + Object.defineProperty(exports2, "ProvidedRequiredArgumentsRule", { + enumerable: true, + get: function get() { + return _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule; + } + }); + Object.defineProperty(exports2, "ScalarLeafsRule", { + enumerable: true, + get: function get() { + return _ScalarLeafsRule.ScalarLeafsRule; + } + }); + Object.defineProperty(exports2, "SingleFieldSubscriptionsRule", { + enumerable: true, + get: function get() { + return _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule; + } + }); + Object.defineProperty(exports2, "UniqueArgumentNamesRule", { + enumerable: true, + get: function get() { + return _UniqueArgumentNamesRule.UniqueArgumentNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueDirectivesPerLocationRule", { + enumerable: true, + get: function get() { + return _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule; + } + }); + Object.defineProperty(exports2, "UniqueFragmentNamesRule", { + enumerable: true, + get: function get() { + return _UniqueFragmentNamesRule.UniqueFragmentNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueInputFieldNamesRule", { + enumerable: true, + get: function get() { + return _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueOperationNamesRule", { + enumerable: true, + get: function get() { + return _UniqueOperationNamesRule.UniqueOperationNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueVariableNamesRule", { + enumerable: true, + get: function get() { + return _UniqueVariableNamesRule.UniqueVariableNamesRule; + } + }); + Object.defineProperty(exports2, "ValuesOfCorrectTypeRule", { + enumerable: true, + get: function get() { + return _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule; + } + }); + Object.defineProperty(exports2, "VariablesAreInputTypesRule", { + enumerable: true, + get: function get() { + return _VariablesAreInputTypesRule.VariablesAreInputTypesRule; + } + }); + Object.defineProperty(exports2, "VariablesInAllowedPositionRule", { + enumerable: true, + get: function get() { + return _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule; + } + }); + Object.defineProperty(exports2, "LoneSchemaDefinitionRule", { + enumerable: true, + get: function get() { + return _LoneSchemaDefinitionRule.LoneSchemaDefinitionRule; + } + }); + Object.defineProperty(exports2, "UniqueOperationTypesRule", { + enumerable: true, + get: function get() { + return _UniqueOperationTypesRule.UniqueOperationTypesRule; + } + }); + Object.defineProperty(exports2, "UniqueTypeNamesRule", { + enumerable: true, + get: function get() { + return _UniqueTypeNamesRule.UniqueTypeNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueEnumValueNamesRule", { + enumerable: true, + get: function get() { + return _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueFieldDefinitionNamesRule", { + enumerable: true, + get: function get() { + return _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueDirectiveNamesRule", { + enumerable: true, + get: function get() { + return _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule; + } + }); + Object.defineProperty(exports2, "PossibleTypeExtensionsRule", { + enumerable: true, + get: function get() { + return _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule; + } + }); + Object.defineProperty(exports2, "NoDeprecatedCustomRule", { + enumerable: true, + get: function get() { + return _NoDeprecatedCustomRule.NoDeprecatedCustomRule; + } + }); + Object.defineProperty(exports2, "NoSchemaIntrospectionCustomRule", { + enumerable: true, + get: function get() { + return _NoSchemaIntrospectionCustomRule.NoSchemaIntrospectionCustomRule; + } + }); + var _validate = require_validate2(); + var _ValidationContext = require_ValidationContext(); + var _specifiedRules = require_specifiedRules(); + var _ExecutableDefinitionsRule = require_ExecutableDefinitionsRule(); + var _FieldsOnCorrectTypeRule = require_FieldsOnCorrectTypeRule(); + var _FragmentsOnCompositeTypesRule = require_FragmentsOnCompositeTypesRule(); + var _KnownArgumentNamesRule = require_KnownArgumentNamesRule(); + var _KnownDirectivesRule = require_KnownDirectivesRule(); + var _KnownFragmentNamesRule = require_KnownFragmentNamesRule(); + var _KnownTypeNamesRule = require_KnownTypeNamesRule(); + var _LoneAnonymousOperationRule = require_LoneAnonymousOperationRule(); + var _NoFragmentCyclesRule = require_NoFragmentCyclesRule(); + var _NoUndefinedVariablesRule = require_NoUndefinedVariablesRule(); + var _NoUnusedFragmentsRule = require_NoUnusedFragmentsRule(); + var _NoUnusedVariablesRule = require_NoUnusedVariablesRule(); + var _OverlappingFieldsCanBeMergedRule = require_OverlappingFieldsCanBeMergedRule(); + var _PossibleFragmentSpreadsRule = require_PossibleFragmentSpreadsRule(); + var _ProvidedRequiredArgumentsRule = require_ProvidedRequiredArgumentsRule(); + var _ScalarLeafsRule = require_ScalarLeafsRule(); + var _SingleFieldSubscriptionsRule = require_SingleFieldSubscriptionsRule(); + var _UniqueArgumentNamesRule = require_UniqueArgumentNamesRule(); + var _UniqueDirectivesPerLocationRule = require_UniqueDirectivesPerLocationRule(); + var _UniqueFragmentNamesRule = require_UniqueFragmentNamesRule(); + var _UniqueInputFieldNamesRule = require_UniqueInputFieldNamesRule(); + var _UniqueOperationNamesRule = require_UniqueOperationNamesRule(); + var _UniqueVariableNamesRule = require_UniqueVariableNamesRule(); + var _ValuesOfCorrectTypeRule = require_ValuesOfCorrectTypeRule(); + var _VariablesAreInputTypesRule = require_VariablesAreInputTypesRule(); + var _VariablesInAllowedPositionRule = require_VariablesInAllowedPositionRule(); + var _LoneSchemaDefinitionRule = require_LoneSchemaDefinitionRule(); + var _UniqueOperationTypesRule = require_UniqueOperationTypesRule(); + var _UniqueTypeNamesRule = require_UniqueTypeNamesRule(); + var _UniqueEnumValueNamesRule = require_UniqueEnumValueNamesRule(); + var _UniqueFieldDefinitionNamesRule = require_UniqueFieldDefinitionNamesRule(); + var _UniqueDirectiveNamesRule = require_UniqueDirectiveNamesRule(); + var _PossibleTypeExtensionsRule = require_PossibleTypeExtensionsRule(); + var _NoDeprecatedCustomRule = require_NoDeprecatedCustomRule(); + var _NoSchemaIntrospectionCustomRule = require_NoSchemaIntrospectionCustomRule(); + } +}); + +// node_modules/graphql/error/formatError.js +var require_formatError = __commonJS({ + "node_modules/graphql/error/formatError.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.formatError = formatError; + var _devAssert = _interopRequireDefault(require_devAssert()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function formatError(error) { + var _error$message; + error || (0, _devAssert.default)(0, "Received null or undefined error."); + var message = (_error$message = error.message) !== null && _error$message !== void 0 ? _error$message : "An unknown error occurred."; + var locations = error.locations; + var path = error.path; + var extensions = error.extensions; + return extensions && Object.keys(extensions).length > 0 ? { + message, + locations, + path, + extensions + } : { + message, + locations, + path + }; + } + } +}); + +// node_modules/graphql/error/index.js +var require_error = __commonJS({ + "node_modules/graphql/error/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "GraphQLError", { + enumerable: true, + get: function get() { + return _GraphQLError.GraphQLError; + } + }); + Object.defineProperty(exports2, "printError", { + enumerable: true, + get: function get() { + return _GraphQLError.printError; + } + }); + Object.defineProperty(exports2, "syntaxError", { + enumerable: true, + get: function get() { + return _syntaxError.syntaxError; + } + }); + Object.defineProperty(exports2, "locatedError", { + enumerable: true, + get: function get() { + return _locatedError.locatedError; + } + }); + Object.defineProperty(exports2, "formatError", { + enumerable: true, + get: function get() { + return _formatError.formatError; + } + }); + var _GraphQLError = require_GraphQLError(); + var _syntaxError = require_syntaxError(); + var _locatedError = require_locatedError(); + var _formatError = require_formatError(); + } +}); + +// node_modules/graphql/utilities/getIntrospectionQuery.js +var require_getIntrospectionQuery = __commonJS({ + "node_modules/graphql/utilities/getIntrospectionQuery.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.getIntrospectionQuery = getIntrospectionQuery; + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function getIntrospectionQuery(options) { + var optionsWithDefault = _objectSpread({ + descriptions: true, + specifiedByUrl: false, + directiveIsRepeatable: false, + schemaDescription: false, + inputValueDeprecation: false + }, options); + var descriptions = optionsWithDefault.descriptions ? "description" : ""; + var specifiedByUrl = optionsWithDefault.specifiedByUrl ? "specifiedByUrl" : ""; + var directiveIsRepeatable = optionsWithDefault.directiveIsRepeatable ? "isRepeatable" : ""; + var schemaDescription = optionsWithDefault.schemaDescription ? descriptions : ""; + function inputDeprecation(str) { + return optionsWithDefault.inputValueDeprecation ? str : ""; + } + return "\n query IntrospectionQuery {\n __schema {\n ".concat(schemaDescription, "\n queryType { name }\n mutationType { name }\n subscriptionType { name }\n types {\n ...FullType\n }\n directives {\n name\n ").concat(descriptions, "\n ").concat(directiveIsRepeatable, "\n locations\n args").concat(inputDeprecation("(includeDeprecated: true)"), " {\n ...InputValue\n }\n }\n }\n }\n\n fragment FullType on __Type {\n kind\n name\n ").concat(descriptions, "\n ").concat(specifiedByUrl, "\n fields(includeDeprecated: true) {\n name\n ").concat(descriptions, "\n args").concat(inputDeprecation("(includeDeprecated: true)"), " {\n ...InputValue\n }\n type {\n ...TypeRef\n }\n isDeprecated\n deprecationReason\n }\n inputFields").concat(inputDeprecation("(includeDeprecated: true)"), " {\n ...InputValue\n }\n interfaces {\n ...TypeRef\n }\n enumValues(includeDeprecated: true) {\n name\n ").concat(descriptions, "\n isDeprecated\n deprecationReason\n }\n possibleTypes {\n ...TypeRef\n }\n }\n\n fragment InputValue on __InputValue {\n name\n ").concat(descriptions, "\n type { ...TypeRef }\n defaultValue\n ").concat(inputDeprecation("isDeprecated"), "\n ").concat(inputDeprecation("deprecationReason"), "\n }\n\n fragment TypeRef on __Type {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n }\n }\n }\n }\n }\n }\n }\n }\n "); + } + } +}); + +// node_modules/graphql/utilities/getOperationAST.js +var require_getOperationAST = __commonJS({ + "node_modules/graphql/utilities/getOperationAST.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.getOperationAST = getOperationAST; + var _kinds = require_kinds(); + function getOperationAST(documentAST, operationName) { + var operation = null; + for (var _i2 = 0, _documentAST$definiti2 = documentAST.definitions; _i2 < _documentAST$definiti2.length; _i2++) { + var definition = _documentAST$definiti2[_i2]; + if (definition.kind === _kinds.Kind.OPERATION_DEFINITION) { + var _definition$name; + if (operationName == null) { + if (operation) { + return null; + } + operation = definition; + } else if (((_definition$name = definition.name) === null || _definition$name === void 0 ? void 0 : _definition$name.value) === operationName) { + return definition; + } + } + } + return operation; + } + } +}); + +// node_modules/graphql/utilities/introspectionFromSchema.js +var require_introspectionFromSchema = __commonJS({ + "node_modules/graphql/utilities/introspectionFromSchema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.introspectionFromSchema = introspectionFromSchema; + var _invariant = _interopRequireDefault(require_invariant()); + var _parser = require_parser(); + var _execute = require_execute(); + var _getIntrospectionQuery = require_getIntrospectionQuery(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function introspectionFromSchema(schema2, options) { + var optionsWithDefaults = _objectSpread({ + specifiedByUrl: true, + directiveIsRepeatable: true, + schemaDescription: true, + inputValueDeprecation: true + }, options); + var document2 = (0, _parser.parse)((0, _getIntrospectionQuery.getIntrospectionQuery)(optionsWithDefaults)); + var result = (0, _execute.executeSync)({ + schema: schema2, + document: document2 + }); + !result.errors && result.data || (0, _invariant.default)(0); + return result.data; + } + } +}); + +// node_modules/graphql/utilities/buildClientSchema.js +var require_buildClientSchema = __commonJS({ + "node_modules/graphql/utilities/buildClientSchema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.buildClientSchema = buildClientSchema; + var _objectValues = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _keyValMap = _interopRequireDefault(require_keyValMap()); + var _isObjectLike = _interopRequireDefault(require_isObjectLike()); + var _parser = require_parser(); + var _schema = require_schema(); + var _directives = require_directives(); + var _scalars = require_scalars(); + var _introspection = require_introspection(); + var _definition = require_definition(); + var _valueFromAST = require_valueFromAST(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function buildClientSchema(introspection, options) { + (0, _isObjectLike.default)(introspection) && (0, _isObjectLike.default)(introspection.__schema) || (0, _devAssert.default)(0, 'Invalid or incomplete introspection result. Ensure that you are passing "data" property of introspection response and no "errors" was returned alongside: '.concat((0, _inspect.default)(introspection), ".")); + var schemaIntrospection = introspection.__schema; + var typeMap = (0, _keyValMap.default)(schemaIntrospection.types, function(typeIntrospection) { + return typeIntrospection.name; + }, function(typeIntrospection) { + return buildType(typeIntrospection); + }); + for (var _i2 = 0, _ref2 = [].concat(_scalars.specifiedScalarTypes, _introspection.introspectionTypes); _i2 < _ref2.length; _i2++) { + var stdType = _ref2[_i2]; + if (typeMap[stdType.name]) { + typeMap[stdType.name] = stdType; + } + } + var queryType = schemaIntrospection.queryType ? getObjectType(schemaIntrospection.queryType) : null; + var mutationType = schemaIntrospection.mutationType ? getObjectType(schemaIntrospection.mutationType) : null; + var subscriptionType = schemaIntrospection.subscriptionType ? getObjectType(schemaIntrospection.subscriptionType) : null; + var directives = schemaIntrospection.directives ? schemaIntrospection.directives.map(buildDirective) : []; + return new _schema.GraphQLSchema({ + description: schemaIntrospection.description, + query: queryType, + mutation: mutationType, + subscription: subscriptionType, + types: (0, _objectValues.default)(typeMap), + directives, + assumeValid: options === null || options === void 0 ? void 0 : options.assumeValid + }); + function getType(typeRef) { + if (typeRef.kind === _introspection.TypeKind.LIST) { + var itemRef = typeRef.ofType; + if (!itemRef) { + throw new Error("Decorated type deeper than introspection query."); + } + return new _definition.GraphQLList(getType(itemRef)); + } + if (typeRef.kind === _introspection.TypeKind.NON_NULL) { + var nullableRef = typeRef.ofType; + if (!nullableRef) { + throw new Error("Decorated type deeper than introspection query."); + } + var nullableType = getType(nullableRef); + return new _definition.GraphQLNonNull((0, _definition.assertNullableType)(nullableType)); + } + return getNamedType(typeRef); + } + function getNamedType(typeRef) { + var typeName = typeRef.name; + if (!typeName) { + throw new Error("Unknown type reference: ".concat((0, _inspect.default)(typeRef), ".")); + } + var type = typeMap[typeName]; + if (!type) { + throw new Error("Invalid or incomplete schema, unknown type: ".concat(typeName, ". Ensure that a full introspection query is used in order to build a client schema.")); + } + return type; + } + function getObjectType(typeRef) { + return (0, _definition.assertObjectType)(getNamedType(typeRef)); + } + function getInterfaceType(typeRef) { + return (0, _definition.assertInterfaceType)(getNamedType(typeRef)); + } + function buildType(type) { + if (type != null && type.name != null && type.kind != null) { + switch (type.kind) { + case _introspection.TypeKind.SCALAR: + return buildScalarDef(type); + case _introspection.TypeKind.OBJECT: + return buildObjectDef(type); + case _introspection.TypeKind.INTERFACE: + return buildInterfaceDef(type); + case _introspection.TypeKind.UNION: + return buildUnionDef(type); + case _introspection.TypeKind.ENUM: + return buildEnumDef(type); + case _introspection.TypeKind.INPUT_OBJECT: + return buildInputObjectDef(type); + } + } + var typeStr = (0, _inspect.default)(type); + throw new Error("Invalid or incomplete introspection result. Ensure that a full introspection query is used in order to build a client schema: ".concat(typeStr, ".")); + } + function buildScalarDef(scalarIntrospection) { + return new _definition.GraphQLScalarType({ + name: scalarIntrospection.name, + description: scalarIntrospection.description, + specifiedByUrl: scalarIntrospection.specifiedByUrl + }); + } + function buildImplementationsList(implementingIntrospection) { + if (implementingIntrospection.interfaces === null && implementingIntrospection.kind === _introspection.TypeKind.INTERFACE) { + return []; + } + if (!implementingIntrospection.interfaces) { + var implementingIntrospectionStr = (0, _inspect.default)(implementingIntrospection); + throw new Error("Introspection result missing interfaces: ".concat(implementingIntrospectionStr, ".")); + } + return implementingIntrospection.interfaces.map(getInterfaceType); + } + function buildObjectDef(objectIntrospection) { + return new _definition.GraphQLObjectType({ + name: objectIntrospection.name, + description: objectIntrospection.description, + interfaces: function interfaces() { + return buildImplementationsList(objectIntrospection); + }, + fields: function fields() { + return buildFieldDefMap(objectIntrospection); + } + }); + } + function buildInterfaceDef(interfaceIntrospection) { + return new _definition.GraphQLInterfaceType({ + name: interfaceIntrospection.name, + description: interfaceIntrospection.description, + interfaces: function interfaces() { + return buildImplementationsList(interfaceIntrospection); + }, + fields: function fields() { + return buildFieldDefMap(interfaceIntrospection); + } + }); + } + function buildUnionDef(unionIntrospection) { + if (!unionIntrospection.possibleTypes) { + var unionIntrospectionStr = (0, _inspect.default)(unionIntrospection); + throw new Error("Introspection result missing possibleTypes: ".concat(unionIntrospectionStr, ".")); + } + return new _definition.GraphQLUnionType({ + name: unionIntrospection.name, + description: unionIntrospection.description, + types: function types() { + return unionIntrospection.possibleTypes.map(getObjectType); + } + }); + } + function buildEnumDef(enumIntrospection) { + if (!enumIntrospection.enumValues) { + var enumIntrospectionStr = (0, _inspect.default)(enumIntrospection); + throw new Error("Introspection result missing enumValues: ".concat(enumIntrospectionStr, ".")); + } + return new _definition.GraphQLEnumType({ + name: enumIntrospection.name, + description: enumIntrospection.description, + values: (0, _keyValMap.default)(enumIntrospection.enumValues, function(valueIntrospection) { + return valueIntrospection.name; + }, function(valueIntrospection) { + return { + description: valueIntrospection.description, + deprecationReason: valueIntrospection.deprecationReason + }; + }) + }); + } + function buildInputObjectDef(inputObjectIntrospection) { + if (!inputObjectIntrospection.inputFields) { + var inputObjectIntrospectionStr = (0, _inspect.default)(inputObjectIntrospection); + throw new Error("Introspection result missing inputFields: ".concat(inputObjectIntrospectionStr, ".")); + } + return new _definition.GraphQLInputObjectType({ + name: inputObjectIntrospection.name, + description: inputObjectIntrospection.description, + fields: function fields() { + return buildInputValueDefMap(inputObjectIntrospection.inputFields); + } + }); + } + function buildFieldDefMap(typeIntrospection) { + if (!typeIntrospection.fields) { + throw new Error("Introspection result missing fields: ".concat((0, _inspect.default)(typeIntrospection), ".")); + } + return (0, _keyValMap.default)(typeIntrospection.fields, function(fieldIntrospection) { + return fieldIntrospection.name; + }, buildField); + } + function buildField(fieldIntrospection) { + var type = getType(fieldIntrospection.type); + if (!(0, _definition.isOutputType)(type)) { + var typeStr = (0, _inspect.default)(type); + throw new Error("Introspection must provide output type for fields, but received: ".concat(typeStr, ".")); + } + if (!fieldIntrospection.args) { + var fieldIntrospectionStr = (0, _inspect.default)(fieldIntrospection); + throw new Error("Introspection result missing field args: ".concat(fieldIntrospectionStr, ".")); + } + return { + description: fieldIntrospection.description, + deprecationReason: fieldIntrospection.deprecationReason, + type, + args: buildInputValueDefMap(fieldIntrospection.args) + }; + } + function buildInputValueDefMap(inputValueIntrospections) { + return (0, _keyValMap.default)(inputValueIntrospections, function(inputValue) { + return inputValue.name; + }, buildInputValue); + } + function buildInputValue(inputValueIntrospection) { + var type = getType(inputValueIntrospection.type); + if (!(0, _definition.isInputType)(type)) { + var typeStr = (0, _inspect.default)(type); + throw new Error("Introspection must provide input type for arguments, but received: ".concat(typeStr, ".")); + } + var defaultValue = inputValueIntrospection.defaultValue != null ? (0, _valueFromAST.valueFromAST)((0, _parser.parseValue)(inputValueIntrospection.defaultValue), type) : void 0; + return { + description: inputValueIntrospection.description, + type, + defaultValue, + deprecationReason: inputValueIntrospection.deprecationReason + }; + } + function buildDirective(directiveIntrospection) { + if (!directiveIntrospection.args) { + var directiveIntrospectionStr = (0, _inspect.default)(directiveIntrospection); + throw new Error("Introspection result missing directive args: ".concat(directiveIntrospectionStr, ".")); + } + if (!directiveIntrospection.locations) { + var _directiveIntrospectionStr = (0, _inspect.default)(directiveIntrospection); + throw new Error("Introspection result missing directive locations: ".concat(_directiveIntrospectionStr, ".")); + } + return new _directives.GraphQLDirective({ + name: directiveIntrospection.name, + description: directiveIntrospection.description, + isRepeatable: directiveIntrospection.isRepeatable, + locations: directiveIntrospection.locations.slice(), + args: buildInputValueDefMap(directiveIntrospection.args) + }); + } + } + } +}); + +// node_modules/graphql/utilities/extendSchema.js +var require_extendSchema = __commonJS({ + "node_modules/graphql/utilities/extendSchema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.extendSchema = extendSchema; + exports2.extendSchemaImpl = extendSchemaImpl; + exports2.getDescription = getDescription; + var _objectValues = _interopRequireDefault(require_objectValues()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _inspect = _interopRequireDefault(require_inspect()); + var _mapValue = _interopRequireDefault(require_mapValue()); + var _invariant = _interopRequireDefault(require_invariant()); + var _devAssert = _interopRequireDefault(require_devAssert()); + var _kinds = require_kinds(); + var _tokenKind = require_tokenKind(); + var _blockString = require_blockString(); + var _predicates = require_predicates(); + var _validate = require_validate2(); + var _values = require_values(); + var _schema = require_schema(); + var _scalars = require_scalars(); + var _introspection = require_introspection(); + var _directives = require_directives(); + var _definition = require_definition(); + var _valueFromAST = require_valueFromAST(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function extendSchema(schema2, documentAST, options) { + (0, _schema.assertSchema)(schema2); + documentAST != null && documentAST.kind === _kinds.Kind.DOCUMENT || (0, _devAssert.default)(0, "Must provide valid Document AST."); + if ((options === null || options === void 0 ? void 0 : options.assumeValid) !== true && (options === null || options === void 0 ? void 0 : options.assumeValidSDL) !== true) { + (0, _validate.assertValidSDLExtension)(documentAST, schema2); + } + var schemaConfig = schema2.toConfig(); + var extendedConfig = extendSchemaImpl(schemaConfig, documentAST, options); + return schemaConfig === extendedConfig ? schema2 : new _schema.GraphQLSchema(extendedConfig); + } + function extendSchemaImpl(schemaConfig, documentAST, options) { + var _schemaDef, _schemaDef$descriptio, _schemaDef2, _options$assumeValid; + var typeDefs2 = []; + var typeExtensionsMap = Object.create(null); + var directiveDefs = []; + var schemaDef; + var schemaExtensions = []; + for (var _i2 = 0, _documentAST$definiti2 = documentAST.definitions; _i2 < _documentAST$definiti2.length; _i2++) { + var def = _documentAST$definiti2[_i2]; + if (def.kind === _kinds.Kind.SCHEMA_DEFINITION) { + schemaDef = def; + } else if (def.kind === _kinds.Kind.SCHEMA_EXTENSION) { + schemaExtensions.push(def); + } else if ((0, _predicates.isTypeDefinitionNode)(def)) { + typeDefs2.push(def); + } else if ((0, _predicates.isTypeExtensionNode)(def)) { + var extendedTypeName = def.name.value; + var existingTypeExtensions = typeExtensionsMap[extendedTypeName]; + typeExtensionsMap[extendedTypeName] = existingTypeExtensions ? existingTypeExtensions.concat([def]) : [def]; + } else if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) { + directiveDefs.push(def); + } + } + if (Object.keys(typeExtensionsMap).length === 0 && typeDefs2.length === 0 && directiveDefs.length === 0 && schemaExtensions.length === 0 && schemaDef == null) { + return schemaConfig; + } + var typeMap = Object.create(null); + for (var _i4 = 0, _schemaConfig$types2 = schemaConfig.types; _i4 < _schemaConfig$types2.length; _i4++) { + var existingType = _schemaConfig$types2[_i4]; + typeMap[existingType.name] = extendNamedType(existingType); + } + for (var _i6 = 0; _i6 < typeDefs2.length; _i6++) { + var _stdTypeMap$name; + var typeNode = typeDefs2[_i6]; + var name = typeNode.name.value; + typeMap[name] = (_stdTypeMap$name = stdTypeMap[name]) !== null && _stdTypeMap$name !== void 0 ? _stdTypeMap$name : buildType(typeNode); + } + var operationTypes = _objectSpread(_objectSpread({ + query: schemaConfig.query && replaceNamedType(schemaConfig.query), + mutation: schemaConfig.mutation && replaceNamedType(schemaConfig.mutation), + subscription: schemaConfig.subscription && replaceNamedType(schemaConfig.subscription) + }, schemaDef && getOperationTypes([schemaDef])), getOperationTypes(schemaExtensions)); + return _objectSpread(_objectSpread({ + description: (_schemaDef = schemaDef) === null || _schemaDef === void 0 ? void 0 : (_schemaDef$descriptio = _schemaDef.description) === null || _schemaDef$descriptio === void 0 ? void 0 : _schemaDef$descriptio.value + }, operationTypes), {}, { + types: (0, _objectValues.default)(typeMap), + directives: [].concat(schemaConfig.directives.map(replaceDirective), directiveDefs.map(buildDirective)), + extensions: void 0, + astNode: (_schemaDef2 = schemaDef) !== null && _schemaDef2 !== void 0 ? _schemaDef2 : schemaConfig.astNode, + extensionASTNodes: schemaConfig.extensionASTNodes.concat(schemaExtensions), + assumeValid: (_options$assumeValid = options === null || options === void 0 ? void 0 : options.assumeValid) !== null && _options$assumeValid !== void 0 ? _options$assumeValid : false + }); + function replaceType(type) { + if ((0, _definition.isListType)(type)) { + return new _definition.GraphQLList(replaceType(type.ofType)); + } + if ((0, _definition.isNonNullType)(type)) { + return new _definition.GraphQLNonNull(replaceType(type.ofType)); + } + return replaceNamedType(type); + } + function replaceNamedType(type) { + return typeMap[type.name]; + } + function replaceDirective(directive) { + var config = directive.toConfig(); + return new _directives.GraphQLDirective(_objectSpread(_objectSpread({}, config), {}, { + args: (0, _mapValue.default)(config.args, extendArg) + })); + } + function extendNamedType(type) { + if ((0, _introspection.isIntrospectionType)(type) || (0, _scalars.isSpecifiedScalarType)(type)) { + return type; + } + if ((0, _definition.isScalarType)(type)) { + return extendScalarType(type); + } + if ((0, _definition.isObjectType)(type)) { + return extendObjectType(type); + } + if ((0, _definition.isInterfaceType)(type)) { + return extendInterfaceType(type); + } + if ((0, _definition.isUnionType)(type)) { + return extendUnionType(type); + } + if ((0, _definition.isEnumType)(type)) { + return extendEnumType(type); + } + if ((0, _definition.isInputObjectType)(type)) { + return extendInputObjectType(type); + } + (0, _invariant.default)(0, "Unexpected type: " + (0, _inspect.default)(type)); + } + function extendInputObjectType(type) { + var _typeExtensionsMap$co; + var config = type.toConfig(); + var extensions = (_typeExtensionsMap$co = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co !== void 0 ? _typeExtensionsMap$co : []; + return new _definition.GraphQLInputObjectType(_objectSpread(_objectSpread({}, config), {}, { + fields: function fields() { + return _objectSpread(_objectSpread({}, (0, _mapValue.default)(config.fields, function(field) { + return _objectSpread(_objectSpread({}, field), {}, { + type: replaceType(field.type) + }); + })), buildInputFieldMap(extensions)); + }, + extensionASTNodes: config.extensionASTNodes.concat(extensions) + })); + } + function extendEnumType(type) { + var _typeExtensionsMap$ty; + var config = type.toConfig(); + var extensions = (_typeExtensionsMap$ty = typeExtensionsMap[type.name]) !== null && _typeExtensionsMap$ty !== void 0 ? _typeExtensionsMap$ty : []; + return new _definition.GraphQLEnumType(_objectSpread(_objectSpread({}, config), {}, { + values: _objectSpread(_objectSpread({}, config.values), buildEnumValueMap(extensions)), + extensionASTNodes: config.extensionASTNodes.concat(extensions) + })); + } + function extendScalarType(type) { + var _typeExtensionsMap$co2; + var config = type.toConfig(); + var extensions = (_typeExtensionsMap$co2 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co2 !== void 0 ? _typeExtensionsMap$co2 : []; + var specifiedByUrl = config.specifiedByUrl; + for (var _i8 = 0; _i8 < extensions.length; _i8++) { + var _getSpecifiedByUrl; + var extensionNode = extensions[_i8]; + specifiedByUrl = (_getSpecifiedByUrl = getSpecifiedByUrl(extensionNode)) !== null && _getSpecifiedByUrl !== void 0 ? _getSpecifiedByUrl : specifiedByUrl; + } + return new _definition.GraphQLScalarType(_objectSpread(_objectSpread({}, config), {}, { + specifiedByUrl, + extensionASTNodes: config.extensionASTNodes.concat(extensions) + })); + } + function extendObjectType(type) { + var _typeExtensionsMap$co3; + var config = type.toConfig(); + var extensions = (_typeExtensionsMap$co3 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co3 !== void 0 ? _typeExtensionsMap$co3 : []; + return new _definition.GraphQLObjectType(_objectSpread(_objectSpread({}, config), {}, { + interfaces: function interfaces() { + return [].concat(type.getInterfaces().map(replaceNamedType), buildInterfaces(extensions)); + }, + fields: function fields() { + return _objectSpread(_objectSpread({}, (0, _mapValue.default)(config.fields, extendField)), buildFieldMap(extensions)); + }, + extensionASTNodes: config.extensionASTNodes.concat(extensions) + })); + } + function extendInterfaceType(type) { + var _typeExtensionsMap$co4; + var config = type.toConfig(); + var extensions = (_typeExtensionsMap$co4 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co4 !== void 0 ? _typeExtensionsMap$co4 : []; + return new _definition.GraphQLInterfaceType(_objectSpread(_objectSpread({}, config), {}, { + interfaces: function interfaces() { + return [].concat(type.getInterfaces().map(replaceNamedType), buildInterfaces(extensions)); + }, + fields: function fields() { + return _objectSpread(_objectSpread({}, (0, _mapValue.default)(config.fields, extendField)), buildFieldMap(extensions)); + }, + extensionASTNodes: config.extensionASTNodes.concat(extensions) + })); + } + function extendUnionType(type) { + var _typeExtensionsMap$co5; + var config = type.toConfig(); + var extensions = (_typeExtensionsMap$co5 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co5 !== void 0 ? _typeExtensionsMap$co5 : []; + return new _definition.GraphQLUnionType(_objectSpread(_objectSpread({}, config), {}, { + types: function types() { + return [].concat(type.getTypes().map(replaceNamedType), buildUnionTypes(extensions)); + }, + extensionASTNodes: config.extensionASTNodes.concat(extensions) + })); + } + function extendField(field) { + return _objectSpread(_objectSpread({}, field), {}, { + type: replaceType(field.type), + args: (0, _mapValue.default)(field.args, extendArg) + }); + } + function extendArg(arg) { + return _objectSpread(_objectSpread({}, arg), {}, { + type: replaceType(arg.type) + }); + } + function getOperationTypes(nodes) { + var opTypes = {}; + for (var _i10 = 0; _i10 < nodes.length; _i10++) { + var _node$operationTypes; + var node = nodes[_i10]; + var operationTypesNodes = (_node$operationTypes = node.operationTypes) !== null && _node$operationTypes !== void 0 ? _node$operationTypes : []; + for (var _i12 = 0; _i12 < operationTypesNodes.length; _i12++) { + var operationType = operationTypesNodes[_i12]; + opTypes[operationType.operation] = getNamedType(operationType.type); + } + } + return opTypes; + } + function getNamedType(node) { + var _stdTypeMap$name2; + var name2 = node.name.value; + var type = (_stdTypeMap$name2 = stdTypeMap[name2]) !== null && _stdTypeMap$name2 !== void 0 ? _stdTypeMap$name2 : typeMap[name2]; + if (type === void 0) { + throw new Error('Unknown type: "'.concat(name2, '".')); + } + return type; + } + function getWrappedType(node) { + if (node.kind === _kinds.Kind.LIST_TYPE) { + return new _definition.GraphQLList(getWrappedType(node.type)); + } + if (node.kind === _kinds.Kind.NON_NULL_TYPE) { + return new _definition.GraphQLNonNull(getWrappedType(node.type)); + } + return getNamedType(node); + } + function buildDirective(node) { + var locations = node.locations.map(function(_ref) { + var value = _ref.value; + return value; + }); + return new _directives.GraphQLDirective({ + name: node.name.value, + description: getDescription(node, options), + locations, + isRepeatable: node.repeatable, + args: buildArgumentMap(node.arguments), + astNode: node + }); + } + function buildFieldMap(nodes) { + var fieldConfigMap = Object.create(null); + for (var _i14 = 0; _i14 < nodes.length; _i14++) { + var _node$fields; + var node = nodes[_i14]; + var nodeFields = (_node$fields = node.fields) !== null && _node$fields !== void 0 ? _node$fields : []; + for (var _i16 = 0; _i16 < nodeFields.length; _i16++) { + var field = nodeFields[_i16]; + fieldConfigMap[field.name.value] = { + type: getWrappedType(field.type), + description: getDescription(field, options), + args: buildArgumentMap(field.arguments), + deprecationReason: getDeprecationReason(field), + astNode: field + }; + } + } + return fieldConfigMap; + } + function buildArgumentMap(args) { + var argsNodes = args !== null && args !== void 0 ? args : []; + var argConfigMap = Object.create(null); + for (var _i18 = 0; _i18 < argsNodes.length; _i18++) { + var arg = argsNodes[_i18]; + var type = getWrappedType(arg.type); + argConfigMap[arg.name.value] = { + type, + description: getDescription(arg, options), + defaultValue: (0, _valueFromAST.valueFromAST)(arg.defaultValue, type), + deprecationReason: getDeprecationReason(arg), + astNode: arg + }; + } + return argConfigMap; + } + function buildInputFieldMap(nodes) { + var inputFieldMap = Object.create(null); + for (var _i20 = 0; _i20 < nodes.length; _i20++) { + var _node$fields2; + var node = nodes[_i20]; + var fieldsNodes = (_node$fields2 = node.fields) !== null && _node$fields2 !== void 0 ? _node$fields2 : []; + for (var _i22 = 0; _i22 < fieldsNodes.length; _i22++) { + var field = fieldsNodes[_i22]; + var type = getWrappedType(field.type); + inputFieldMap[field.name.value] = { + type, + description: getDescription(field, options), + defaultValue: (0, _valueFromAST.valueFromAST)(field.defaultValue, type), + deprecationReason: getDeprecationReason(field), + astNode: field + }; + } + } + return inputFieldMap; + } + function buildEnumValueMap(nodes) { + var enumValueMap = Object.create(null); + for (var _i24 = 0; _i24 < nodes.length; _i24++) { + var _node$values; + var node = nodes[_i24]; + var valuesNodes = (_node$values = node.values) !== null && _node$values !== void 0 ? _node$values : []; + for (var _i26 = 0; _i26 < valuesNodes.length; _i26++) { + var value = valuesNodes[_i26]; + enumValueMap[value.name.value] = { + description: getDescription(value, options), + deprecationReason: getDeprecationReason(value), + astNode: value + }; + } + } + return enumValueMap; + } + function buildInterfaces(nodes) { + var interfaces = []; + for (var _i28 = 0; _i28 < nodes.length; _i28++) { + var _node$interfaces; + var node = nodes[_i28]; + var interfacesNodes = (_node$interfaces = node.interfaces) !== null && _node$interfaces !== void 0 ? _node$interfaces : []; + for (var _i30 = 0; _i30 < interfacesNodes.length; _i30++) { + var type = interfacesNodes[_i30]; + interfaces.push(getNamedType(type)); + } + } + return interfaces; + } + function buildUnionTypes(nodes) { + var types = []; + for (var _i32 = 0; _i32 < nodes.length; _i32++) { + var _node$types; + var node = nodes[_i32]; + var typeNodes = (_node$types = node.types) !== null && _node$types !== void 0 ? _node$types : []; + for (var _i34 = 0; _i34 < typeNodes.length; _i34++) { + var type = typeNodes[_i34]; + types.push(getNamedType(type)); + } + } + return types; + } + function buildType(astNode) { + var _typeExtensionsMap$na; + var name2 = astNode.name.value; + var description = getDescription(astNode, options); + var extensionNodes = (_typeExtensionsMap$na = typeExtensionsMap[name2]) !== null && _typeExtensionsMap$na !== void 0 ? _typeExtensionsMap$na : []; + switch (astNode.kind) { + case _kinds.Kind.OBJECT_TYPE_DEFINITION: { + var extensionASTNodes = extensionNodes; + var allNodes = [astNode].concat(extensionASTNodes); + return new _definition.GraphQLObjectType({ + name: name2, + description, + interfaces: function interfaces() { + return buildInterfaces(allNodes); + }, + fields: function fields() { + return buildFieldMap(allNodes); + }, + astNode, + extensionASTNodes + }); + } + case _kinds.Kind.INTERFACE_TYPE_DEFINITION: { + var _extensionASTNodes = extensionNodes; + var _allNodes = [astNode].concat(_extensionASTNodes); + return new _definition.GraphQLInterfaceType({ + name: name2, + description, + interfaces: function interfaces() { + return buildInterfaces(_allNodes); + }, + fields: function fields() { + return buildFieldMap(_allNodes); + }, + astNode, + extensionASTNodes: _extensionASTNodes + }); + } + case _kinds.Kind.ENUM_TYPE_DEFINITION: { + var _extensionASTNodes2 = extensionNodes; + var _allNodes2 = [astNode].concat(_extensionASTNodes2); + return new _definition.GraphQLEnumType({ + name: name2, + description, + values: buildEnumValueMap(_allNodes2), + astNode, + extensionASTNodes: _extensionASTNodes2 + }); + } + case _kinds.Kind.UNION_TYPE_DEFINITION: { + var _extensionASTNodes3 = extensionNodes; + var _allNodes3 = [astNode].concat(_extensionASTNodes3); + return new _definition.GraphQLUnionType({ + name: name2, + description, + types: function types() { + return buildUnionTypes(_allNodes3); + }, + astNode, + extensionASTNodes: _extensionASTNodes3 + }); + } + case _kinds.Kind.SCALAR_TYPE_DEFINITION: { + var _extensionASTNodes4 = extensionNodes; + return new _definition.GraphQLScalarType({ + name: name2, + description, + specifiedByUrl: getSpecifiedByUrl(astNode), + astNode, + extensionASTNodes: _extensionASTNodes4 + }); + } + case _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION: { + var _extensionASTNodes5 = extensionNodes; + var _allNodes4 = [astNode].concat(_extensionASTNodes5); + return new _definition.GraphQLInputObjectType({ + name: name2, + description, + fields: function fields() { + return buildInputFieldMap(_allNodes4); + }, + astNode, + extensionASTNodes: _extensionASTNodes5 + }); + } + } + (0, _invariant.default)(0, "Unexpected type definition node: " + (0, _inspect.default)(astNode)); + } + } + var stdTypeMap = (0, _keyMap.default)(_scalars.specifiedScalarTypes.concat(_introspection.introspectionTypes), function(type) { + return type.name; + }); + function getDeprecationReason(node) { + var deprecated = (0, _values.getDirectiveValues)(_directives.GraphQLDeprecatedDirective, node); + return deprecated === null || deprecated === void 0 ? void 0 : deprecated.reason; + } + function getSpecifiedByUrl(node) { + var specifiedBy = (0, _values.getDirectiveValues)(_directives.GraphQLSpecifiedByDirective, node); + return specifiedBy === null || specifiedBy === void 0 ? void 0 : specifiedBy.url; + } + function getDescription(node, options) { + if (node.description) { + return node.description.value; + } + if ((options === null || options === void 0 ? void 0 : options.commentDescriptions) === true) { + var rawValue = getLeadingCommentBlock(node); + if (rawValue !== void 0) { + return (0, _blockString.dedentBlockStringValue)("\n" + rawValue); + } + } + } + function getLeadingCommentBlock(node) { + var loc = node.loc; + if (!loc) { + return; + } + var comments = []; + var token = loc.startToken.prev; + while (token != null && token.kind === _tokenKind.TokenKind.COMMENT && token.next && token.prev && token.line + 1 === token.next.line && token.line !== token.prev.line) { + var value = String(token.value); + comments.push(value); + token = token.prev; + } + return comments.length > 0 ? comments.reverse().join("\n") : void 0; + } + } +}); + +// node_modules/graphql/utilities/buildASTSchema.js +var require_buildASTSchema = __commonJS({ + "node_modules/graphql/utilities/buildASTSchema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.buildASTSchema = buildASTSchema; + exports2.buildSchema = buildSchema; + var _devAssert = _interopRequireDefault(require_devAssert()); + var _kinds = require_kinds(); + var _parser = require_parser(); + var _validate = require_validate2(); + var _schema = require_schema(); + var _directives = require_directives(); + var _extendSchema = require_extendSchema(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function buildASTSchema(documentAST, options) { + documentAST != null && documentAST.kind === _kinds.Kind.DOCUMENT || (0, _devAssert.default)(0, "Must provide valid Document AST."); + if ((options === null || options === void 0 ? void 0 : options.assumeValid) !== true && (options === null || options === void 0 ? void 0 : options.assumeValidSDL) !== true) { + (0, _validate.assertValidSDL)(documentAST); + } + var emptySchemaConfig = { + description: void 0, + types: [], + directives: [], + extensions: void 0, + extensionASTNodes: [], + assumeValid: false + }; + var config = (0, _extendSchema.extendSchemaImpl)(emptySchemaConfig, documentAST, options); + if (config.astNode == null) { + for (var _i2 = 0, _config$types2 = config.types; _i2 < _config$types2.length; _i2++) { + var type = _config$types2[_i2]; + switch (type.name) { + case "Query": + config.query = type; + break; + case "Mutation": + config.mutation = type; + break; + case "Subscription": + config.subscription = type; + break; + } + } + } + var directives = config.directives; + var _loop = function _loop2(_i42) { + var stdDirective = _directives.specifiedDirectives[_i42]; + if (directives.every(function(directive) { + return directive.name !== stdDirective.name; + })) { + directives.push(stdDirective); + } + }; + for (var _i4 = 0; _i4 < _directives.specifiedDirectives.length; _i4++) { + _loop(_i4); + } + return new _schema.GraphQLSchema(config); + } + function buildSchema(source, options) { + var document2 = (0, _parser.parse)(source, { + noLocation: options === null || options === void 0 ? void 0 : options.noLocation, + allowLegacySDLEmptyFields: options === null || options === void 0 ? void 0 : options.allowLegacySDLEmptyFields, + allowLegacySDLImplementsInterfaces: options === null || options === void 0 ? void 0 : options.allowLegacySDLImplementsInterfaces, + experimentalFragmentVariables: options === null || options === void 0 ? void 0 : options.experimentalFragmentVariables + }); + return buildASTSchema(document2, { + commentDescriptions: options === null || options === void 0 ? void 0 : options.commentDescriptions, + assumeValidSDL: options === null || options === void 0 ? void 0 : options.assumeValidSDL, + assumeValid: options === null || options === void 0 ? void 0 : options.assumeValid + }); + } + } +}); + +// node_modules/graphql/utilities/lexicographicSortSchema.js +var require_lexicographicSortSchema = __commonJS({ + "node_modules/graphql/utilities/lexicographicSortSchema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.lexicographicSortSchema = lexicographicSortSchema; + var _objectValues = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _keyValMap = _interopRequireDefault(require_keyValMap()); + var _naturalCompare = _interopRequireDefault(require_naturalCompare()); + var _schema = require_schema(); + var _directives = require_directives(); + var _introspection = require_introspection(); + var _definition = require_definition(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + function lexicographicSortSchema(schema2) { + var schemaConfig = schema2.toConfig(); + var typeMap = (0, _keyValMap.default)(sortByName(schemaConfig.types), function(type) { + return type.name; + }, sortNamedType); + return new _schema.GraphQLSchema(_objectSpread(_objectSpread({}, schemaConfig), {}, { + types: (0, _objectValues.default)(typeMap), + directives: sortByName(schemaConfig.directives).map(sortDirective), + query: replaceMaybeType(schemaConfig.query), + mutation: replaceMaybeType(schemaConfig.mutation), + subscription: replaceMaybeType(schemaConfig.subscription) + })); + function replaceType(type) { + if ((0, _definition.isListType)(type)) { + return new _definition.GraphQLList(replaceType(type.ofType)); + } else if ((0, _definition.isNonNullType)(type)) { + return new _definition.GraphQLNonNull(replaceType(type.ofType)); + } + return replaceNamedType(type); + } + function replaceNamedType(type) { + return typeMap[type.name]; + } + function replaceMaybeType(maybeType) { + return maybeType && replaceNamedType(maybeType); + } + function sortDirective(directive) { + var config = directive.toConfig(); + return new _directives.GraphQLDirective(_objectSpread(_objectSpread({}, config), {}, { + locations: sortBy(config.locations, function(x) { + return x; + }), + args: sortArgs(config.args) + })); + } + function sortArgs(args) { + return sortObjMap(args, function(arg) { + return _objectSpread(_objectSpread({}, arg), {}, { + type: replaceType(arg.type) + }); + }); + } + function sortFields(fieldsMap) { + return sortObjMap(fieldsMap, function(field) { + return _objectSpread(_objectSpread({}, field), {}, { + type: replaceType(field.type), + args: sortArgs(field.args) + }); + }); + } + function sortInputFields(fieldsMap) { + return sortObjMap(fieldsMap, function(field) { + return _objectSpread(_objectSpread({}, field), {}, { + type: replaceType(field.type) + }); + }); + } + function sortTypes(arr) { + return sortByName(arr).map(replaceNamedType); + } + function sortNamedType(type) { + if ((0, _definition.isScalarType)(type) || (0, _introspection.isIntrospectionType)(type)) { + return type; + } + if ((0, _definition.isObjectType)(type)) { + var config = type.toConfig(); + return new _definition.GraphQLObjectType(_objectSpread(_objectSpread({}, config), {}, { + interfaces: function interfaces() { + return sortTypes(config.interfaces); + }, + fields: function fields() { + return sortFields(config.fields); + } + })); + } + if ((0, _definition.isInterfaceType)(type)) { + var _config = type.toConfig(); + return new _definition.GraphQLInterfaceType(_objectSpread(_objectSpread({}, _config), {}, { + interfaces: function interfaces() { + return sortTypes(_config.interfaces); + }, + fields: function fields() { + return sortFields(_config.fields); + } + })); + } + if ((0, _definition.isUnionType)(type)) { + var _config2 = type.toConfig(); + return new _definition.GraphQLUnionType(_objectSpread(_objectSpread({}, _config2), {}, { + types: function types() { + return sortTypes(_config2.types); + } + })); + } + if ((0, _definition.isEnumType)(type)) { + var _config3 = type.toConfig(); + return new _definition.GraphQLEnumType(_objectSpread(_objectSpread({}, _config3), {}, { + values: sortObjMap(_config3.values) + })); + } + if ((0, _definition.isInputObjectType)(type)) { + var _config4 = type.toConfig(); + return new _definition.GraphQLInputObjectType(_objectSpread(_objectSpread({}, _config4), {}, { + fields: function fields() { + return sortInputFields(_config4.fields); + } + })); + } + (0, _invariant.default)(0, "Unexpected type: " + (0, _inspect.default)(type)); + } + } + function sortObjMap(map, sortValueFn) { + var sortedMap = Object.create(null); + var sortedKeys = sortBy(Object.keys(map), function(x) { + return x; + }); + for (var _i2 = 0; _i2 < sortedKeys.length; _i2++) { + var key = sortedKeys[_i2]; + var value = map[key]; + sortedMap[key] = sortValueFn ? sortValueFn(value) : value; + } + return sortedMap; + } + function sortByName(array) { + return sortBy(array, function(obj) { + return obj.name; + }); + } + function sortBy(array, mapToKey) { + return array.slice().sort(function(obj1, obj2) { + var key1 = mapToKey(obj1); + var key2 = mapToKey(obj2); + return (0, _naturalCompare.default)(key1, key2); + }); + } + } +}); + +// node_modules/graphql/utilities/printSchema.js +var require_printSchema = __commonJS({ + "node_modules/graphql/utilities/printSchema.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.printSchema = printSchema; + exports2.printIntrospectionSchema = printIntrospectionSchema; + exports2.printType = printType; + var _objectValues = _interopRequireDefault(require_objectValues()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _printer = require_printer(); + var _blockString = require_blockString(); + var _introspection = require_introspection(); + var _scalars = require_scalars(); + var _directives = require_directives(); + var _definition = require_definition(); + var _astFromValue = require_astFromValue(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function printSchema(schema2, options) { + return printFilteredSchema(schema2, function(n) { + return !(0, _directives.isSpecifiedDirective)(n); + }, isDefinedType, options); + } + function printIntrospectionSchema(schema2, options) { + return printFilteredSchema(schema2, _directives.isSpecifiedDirective, _introspection.isIntrospectionType, options); + } + function isDefinedType(type) { + return !(0, _scalars.isSpecifiedScalarType)(type) && !(0, _introspection.isIntrospectionType)(type); + } + function printFilteredSchema(schema2, directiveFilter, typeFilter, options) { + var directives = schema2.getDirectives().filter(directiveFilter); + var types = (0, _objectValues.default)(schema2.getTypeMap()).filter(typeFilter); + return [printSchemaDefinition(schema2)].concat(directives.map(function(directive) { + return printDirective(directive, options); + }), types.map(function(type) { + return printType(type, options); + })).filter(Boolean).join("\n\n") + "\n"; + } + function printSchemaDefinition(schema2) { + if (schema2.description == null && isSchemaOfCommonNames(schema2)) { + return; + } + var operationTypes = []; + var queryType = schema2.getQueryType(); + if (queryType) { + operationTypes.push(" query: ".concat(queryType.name)); + } + var mutationType = schema2.getMutationType(); + if (mutationType) { + operationTypes.push(" mutation: ".concat(mutationType.name)); + } + var subscriptionType = schema2.getSubscriptionType(); + if (subscriptionType) { + operationTypes.push(" subscription: ".concat(subscriptionType.name)); + } + return printDescription({}, schema2) + "schema {\n".concat(operationTypes.join("\n"), "\n}"); + } + function isSchemaOfCommonNames(schema2) { + var queryType = schema2.getQueryType(); + if (queryType && queryType.name !== "Query") { + return false; + } + var mutationType = schema2.getMutationType(); + if (mutationType && mutationType.name !== "Mutation") { + return false; + } + var subscriptionType = schema2.getSubscriptionType(); + if (subscriptionType && subscriptionType.name !== "Subscription") { + return false; + } + return true; + } + function printType(type, options) { + if ((0, _definition.isScalarType)(type)) { + return printScalar(type, options); + } + if ((0, _definition.isObjectType)(type)) { + return printObject(type, options); + } + if ((0, _definition.isInterfaceType)(type)) { + return printInterface(type, options); + } + if ((0, _definition.isUnionType)(type)) { + return printUnion(type, options); + } + if ((0, _definition.isEnumType)(type)) { + return printEnum(type, options); + } + if ((0, _definition.isInputObjectType)(type)) { + return printInputObject(type, options); + } + (0, _invariant.default)(0, "Unexpected type: " + (0, _inspect.default)(type)); + } + function printScalar(type, options) { + return printDescription(options, type) + "scalar ".concat(type.name) + printSpecifiedByUrl(type); + } + function printImplementedInterfaces(type) { + var interfaces = type.getInterfaces(); + return interfaces.length ? " implements " + interfaces.map(function(i) { + return i.name; + }).join(" & ") : ""; + } + function printObject(type, options) { + return printDescription(options, type) + "type ".concat(type.name) + printImplementedInterfaces(type) + printFields(options, type); + } + function printInterface(type, options) { + return printDescription(options, type) + "interface ".concat(type.name) + printImplementedInterfaces(type) + printFields(options, type); + } + function printUnion(type, options) { + var types = type.getTypes(); + var possibleTypes = types.length ? " = " + types.join(" | ") : ""; + return printDescription(options, type) + "union " + type.name + possibleTypes; + } + function printEnum(type, options) { + var values = type.getValues().map(function(value, i) { + return printDescription(options, value, " ", !i) + " " + value.name + printDeprecated(value.deprecationReason); + }); + return printDescription(options, type) + "enum ".concat(type.name) + printBlock(values); + } + function printInputObject(type, options) { + var fields = (0, _objectValues.default)(type.getFields()).map(function(f, i) { + return printDescription(options, f, " ", !i) + " " + printInputValue(f); + }); + return printDescription(options, type) + "input ".concat(type.name) + printBlock(fields); + } + function printFields(options, type) { + var fields = (0, _objectValues.default)(type.getFields()).map(function(f, i) { + return printDescription(options, f, " ", !i) + " " + f.name + printArgs(options, f.args, " ") + ": " + String(f.type) + printDeprecated(f.deprecationReason); + }); + return printBlock(fields); + } + function printBlock(items) { + return items.length !== 0 ? " {\n" + items.join("\n") + "\n}" : ""; + } + function printArgs(options, args) { + var indentation = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + if (args.length === 0) { + return ""; + } + if (args.every(function(arg) { + return !arg.description; + })) { + return "(" + args.map(printInputValue).join(", ") + ")"; + } + return "(\n" + args.map(function(arg, i) { + return printDescription(options, arg, " " + indentation, !i) + " " + indentation + printInputValue(arg); + }).join("\n") + "\n" + indentation + ")"; + } + function printInputValue(arg) { + var defaultAST = (0, _astFromValue.astFromValue)(arg.defaultValue, arg.type); + var argDecl = arg.name + ": " + String(arg.type); + if (defaultAST) { + argDecl += " = ".concat((0, _printer.print)(defaultAST)); + } + return argDecl + printDeprecated(arg.deprecationReason); + } + function printDirective(directive, options) { + return printDescription(options, directive) + "directive @" + directive.name + printArgs(options, directive.args) + (directive.isRepeatable ? " repeatable" : "") + " on " + directive.locations.join(" | "); + } + function printDeprecated(reason) { + if (reason == null) { + return ""; + } + var reasonAST = (0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString); + if (reasonAST && reason !== _directives.DEFAULT_DEPRECATION_REASON) { + return " @deprecated(reason: " + (0, _printer.print)(reasonAST) + ")"; + } + return " @deprecated"; + } + function printSpecifiedByUrl(scalar) { + if (scalar.specifiedByUrl == null) { + return ""; + } + var url = scalar.specifiedByUrl; + var urlAST = (0, _astFromValue.astFromValue)(url, _scalars.GraphQLString); + urlAST || (0, _invariant.default)(0, "Unexpected null value returned from `astFromValue` for specifiedByUrl"); + return " @specifiedBy(url: " + (0, _printer.print)(urlAST) + ")"; + } + function printDescription(options, def) { + var indentation = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + var firstInBlock = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true; + var description = def.description; + if (description == null) { + return ""; + } + if ((options === null || options === void 0 ? void 0 : options.commentDescriptions) === true) { + return printDescriptionWithComments(description, indentation, firstInBlock); + } + var preferMultipleLines = description.length > 70; + var blockString = (0, _blockString.printBlockString)(description, "", preferMultipleLines); + var prefix = indentation && !firstInBlock ? "\n" + indentation : indentation; + return prefix + blockString.replace(/\n/g, "\n" + indentation) + "\n"; + } + function printDescriptionWithComments(description, indentation, firstInBlock) { + var prefix = indentation && !firstInBlock ? "\n" : ""; + var comment = description.split("\n").map(function(line) { + return indentation + (line !== "" ? "# " + line : "#"); + }).join("\n"); + return prefix + comment + "\n"; + } + } +}); + +// node_modules/graphql/utilities/concatAST.js +var require_concatAST = __commonJS({ + "node_modules/graphql/utilities/concatAST.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.concatAST = concatAST; + function concatAST(documents) { + var definitions = []; + for (var _i2 = 0; _i2 < documents.length; _i2++) { + var doc = documents[_i2]; + definitions = definitions.concat(doc.definitions); + } + return { + kind: "Document", + definitions + }; + } + } +}); + +// node_modules/graphql/utilities/separateOperations.js +var require_separateOperations = __commonJS({ + "node_modules/graphql/utilities/separateOperations.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.separateOperations = separateOperations; + var _kinds = require_kinds(); + var _visitor = require_visitor(); + function separateOperations(documentAST) { + var operations = []; + var depGraph = Object.create(null); + for (var _i2 = 0, _documentAST$definiti2 = documentAST.definitions; _i2 < _documentAST$definiti2.length; _i2++) { + var definitionNode = _documentAST$definiti2[_i2]; + switch (definitionNode.kind) { + case _kinds.Kind.OPERATION_DEFINITION: + operations.push(definitionNode); + break; + case _kinds.Kind.FRAGMENT_DEFINITION: + depGraph[definitionNode.name.value] = collectDependencies(definitionNode.selectionSet); + break; + } + } + var separatedDocumentASTs = Object.create(null); + var _loop = function _loop2(_i42) { + var operation = operations[_i42]; + var dependencies = new Set(); + for (var _i6 = 0, _collectDependencies2 = collectDependencies(operation.selectionSet); _i6 < _collectDependencies2.length; _i6++) { + var fragmentName = _collectDependencies2[_i6]; + collectTransitiveDependencies(dependencies, depGraph, fragmentName); + } + var operationName = operation.name ? operation.name.value : ""; + separatedDocumentASTs[operationName] = { + kind: _kinds.Kind.DOCUMENT, + definitions: documentAST.definitions.filter(function(node) { + return node === operation || node.kind === _kinds.Kind.FRAGMENT_DEFINITION && dependencies.has(node.name.value); + }) + }; + }; + for (var _i4 = 0; _i4 < operations.length; _i4++) { + _loop(_i4); + } + return separatedDocumentASTs; + } + function collectTransitiveDependencies(collected, depGraph, fromName) { + if (!collected.has(fromName)) { + collected.add(fromName); + var immediateDeps = depGraph[fromName]; + if (immediateDeps !== void 0) { + for (var _i8 = 0; _i8 < immediateDeps.length; _i8++) { + var toName = immediateDeps[_i8]; + collectTransitiveDependencies(collected, depGraph, toName); + } + } + } + } + function collectDependencies(selectionSet) { + var dependencies = []; + (0, _visitor.visit)(selectionSet, { + FragmentSpread: function FragmentSpread(node) { + dependencies.push(node.name.value); + } + }); + return dependencies; + } + } +}); + +// node_modules/graphql/utilities/stripIgnoredCharacters.js +var require_stripIgnoredCharacters = __commonJS({ + "node_modules/graphql/utilities/stripIgnoredCharacters.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.stripIgnoredCharacters = stripIgnoredCharacters; + var _source = require_source(); + var _tokenKind = require_tokenKind(); + var _lexer = require_lexer(); + var _blockString = require_blockString(); + function stripIgnoredCharacters(source) { + var sourceObj = (0, _source.isSource)(source) ? source : new _source.Source(source); + var body = sourceObj.body; + var lexer = new _lexer.Lexer(sourceObj); + var strippedBody = ""; + var wasLastAddedTokenNonPunctuator = false; + while (lexer.advance().kind !== _tokenKind.TokenKind.EOF) { + var currentToken = lexer.token; + var tokenKind = currentToken.kind; + var isNonPunctuator = !(0, _lexer.isPunctuatorTokenKind)(currentToken.kind); + if (wasLastAddedTokenNonPunctuator) { + if (isNonPunctuator || currentToken.kind === _tokenKind.TokenKind.SPREAD) { + strippedBody += " "; + } + } + var tokenBody = body.slice(currentToken.start, currentToken.end); + if (tokenKind === _tokenKind.TokenKind.BLOCK_STRING) { + strippedBody += dedentBlockString(tokenBody); + } else { + strippedBody += tokenBody; + } + wasLastAddedTokenNonPunctuator = isNonPunctuator; + } + return strippedBody; + } + function dedentBlockString(blockStr) { + var rawStr = blockStr.slice(3, -3); + var body = (0, _blockString.dedentBlockStringValue)(rawStr); + if ((0, _blockString.getBlockStringIndentation)(body) > 0) { + body = "\n" + body; + } + var lastChar = body[body.length - 1]; + var hasTrailingQuote = lastChar === '"' && body.slice(-4) !== '\\"""'; + if (hasTrailingQuote || lastChar === "\\") { + body += "\n"; + } + return '"""' + body + '"""'; + } + } +}); + +// node_modules/graphql/utilities/findBreakingChanges.js +var require_findBreakingChanges = __commonJS({ + "node_modules/graphql/utilities/findBreakingChanges.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.findBreakingChanges = findBreakingChanges; + exports2.findDangerousChanges = findDangerousChanges; + exports2.DangerousChangeType = exports2.BreakingChangeType = void 0; + var _objectValues = _interopRequireDefault(require_objectValues()); + var _keyMap = _interopRequireDefault(require_keyMap()); + var _inspect = _interopRequireDefault(require_inspect()); + var _invariant = _interopRequireDefault(require_invariant()); + var _naturalCompare = _interopRequireDefault(require_naturalCompare()); + var _printer = require_printer(); + var _visitor = require_visitor(); + var _scalars = require_scalars(); + var _definition = require_definition(); + var _astFromValue = require_astFromValue(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) + symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key] = value; + } + return obj; + } + var BreakingChangeType = Object.freeze({ + TYPE_REMOVED: "TYPE_REMOVED", + TYPE_CHANGED_KIND: "TYPE_CHANGED_KIND", + TYPE_REMOVED_FROM_UNION: "TYPE_REMOVED_FROM_UNION", + VALUE_REMOVED_FROM_ENUM: "VALUE_REMOVED_FROM_ENUM", + REQUIRED_INPUT_FIELD_ADDED: "REQUIRED_INPUT_FIELD_ADDED", + IMPLEMENTED_INTERFACE_REMOVED: "IMPLEMENTED_INTERFACE_REMOVED", + FIELD_REMOVED: "FIELD_REMOVED", + FIELD_CHANGED_KIND: "FIELD_CHANGED_KIND", + REQUIRED_ARG_ADDED: "REQUIRED_ARG_ADDED", + ARG_REMOVED: "ARG_REMOVED", + ARG_CHANGED_KIND: "ARG_CHANGED_KIND", + DIRECTIVE_REMOVED: "DIRECTIVE_REMOVED", + DIRECTIVE_ARG_REMOVED: "DIRECTIVE_ARG_REMOVED", + REQUIRED_DIRECTIVE_ARG_ADDED: "REQUIRED_DIRECTIVE_ARG_ADDED", + DIRECTIVE_REPEATABLE_REMOVED: "DIRECTIVE_REPEATABLE_REMOVED", + DIRECTIVE_LOCATION_REMOVED: "DIRECTIVE_LOCATION_REMOVED" + }); + exports2.BreakingChangeType = BreakingChangeType; + var DangerousChangeType = Object.freeze({ + VALUE_ADDED_TO_ENUM: "VALUE_ADDED_TO_ENUM", + TYPE_ADDED_TO_UNION: "TYPE_ADDED_TO_UNION", + OPTIONAL_INPUT_FIELD_ADDED: "OPTIONAL_INPUT_FIELD_ADDED", + OPTIONAL_ARG_ADDED: "OPTIONAL_ARG_ADDED", + IMPLEMENTED_INTERFACE_ADDED: "IMPLEMENTED_INTERFACE_ADDED", + ARG_DEFAULT_VALUE_CHANGE: "ARG_DEFAULT_VALUE_CHANGE" + }); + exports2.DangerousChangeType = DangerousChangeType; + function findBreakingChanges(oldSchema, newSchema) { + var breakingChanges = findSchemaChanges(oldSchema, newSchema).filter(function(change) { + return change.type in BreakingChangeType; + }); + return breakingChanges; + } + function findDangerousChanges(oldSchema, newSchema) { + var dangerousChanges = findSchemaChanges(oldSchema, newSchema).filter(function(change) { + return change.type in DangerousChangeType; + }); + return dangerousChanges; + } + function findSchemaChanges(oldSchema, newSchema) { + return [].concat(findTypeChanges(oldSchema, newSchema), findDirectiveChanges(oldSchema, newSchema)); + } + function findDirectiveChanges(oldSchema, newSchema) { + var schemaChanges = []; + var directivesDiff = diff(oldSchema.getDirectives(), newSchema.getDirectives()); + for (var _i2 = 0, _directivesDiff$remov2 = directivesDiff.removed; _i2 < _directivesDiff$remov2.length; _i2++) { + var oldDirective = _directivesDiff$remov2[_i2]; + schemaChanges.push({ + type: BreakingChangeType.DIRECTIVE_REMOVED, + description: "".concat(oldDirective.name, " was removed.") + }); + } + for (var _i4 = 0, _directivesDiff$persi2 = directivesDiff.persisted; _i4 < _directivesDiff$persi2.length; _i4++) { + var _ref2 = _directivesDiff$persi2[_i4]; + var _oldDirective = _ref2[0]; + var newDirective = _ref2[1]; + var argsDiff = diff(_oldDirective.args, newDirective.args); + for (var _i6 = 0, _argsDiff$added2 = argsDiff.added; _i6 < _argsDiff$added2.length; _i6++) { + var newArg = _argsDiff$added2[_i6]; + if ((0, _definition.isRequiredArgument)(newArg)) { + schemaChanges.push({ + type: BreakingChangeType.REQUIRED_DIRECTIVE_ARG_ADDED, + description: "A required arg ".concat(newArg.name, " on directive ").concat(_oldDirective.name, " was added.") + }); + } + } + for (var _i8 = 0, _argsDiff$removed2 = argsDiff.removed; _i8 < _argsDiff$removed2.length; _i8++) { + var oldArg = _argsDiff$removed2[_i8]; + schemaChanges.push({ + type: BreakingChangeType.DIRECTIVE_ARG_REMOVED, + description: "".concat(oldArg.name, " was removed from ").concat(_oldDirective.name, ".") + }); + } + if (_oldDirective.isRepeatable && !newDirective.isRepeatable) { + schemaChanges.push({ + type: BreakingChangeType.DIRECTIVE_REPEATABLE_REMOVED, + description: "Repeatable flag was removed from ".concat(_oldDirective.name, ".") + }); + } + for (var _i10 = 0, _oldDirective$locatio2 = _oldDirective.locations; _i10 < _oldDirective$locatio2.length; _i10++) { + var location = _oldDirective$locatio2[_i10]; + if (newDirective.locations.indexOf(location) === -1) { + schemaChanges.push({ + type: BreakingChangeType.DIRECTIVE_LOCATION_REMOVED, + description: "".concat(location, " was removed from ").concat(_oldDirective.name, ".") + }); + } + } + } + return schemaChanges; + } + function findTypeChanges(oldSchema, newSchema) { + var schemaChanges = []; + var typesDiff = diff((0, _objectValues.default)(oldSchema.getTypeMap()), (0, _objectValues.default)(newSchema.getTypeMap())); + for (var _i12 = 0, _typesDiff$removed2 = typesDiff.removed; _i12 < _typesDiff$removed2.length; _i12++) { + var oldType = _typesDiff$removed2[_i12]; + schemaChanges.push({ + type: BreakingChangeType.TYPE_REMOVED, + description: (0, _scalars.isSpecifiedScalarType)(oldType) ? "Standard scalar ".concat(oldType.name, " was removed because it is not referenced anymore.") : "".concat(oldType.name, " was removed.") + }); + } + for (var _i14 = 0, _typesDiff$persisted2 = typesDiff.persisted; _i14 < _typesDiff$persisted2.length; _i14++) { + var _ref4 = _typesDiff$persisted2[_i14]; + var _oldType = _ref4[0]; + var newType = _ref4[1]; + if ((0, _definition.isEnumType)(_oldType) && (0, _definition.isEnumType)(newType)) { + schemaChanges.push.apply(schemaChanges, findEnumTypeChanges(_oldType, newType)); + } else if ((0, _definition.isUnionType)(_oldType) && (0, _definition.isUnionType)(newType)) { + schemaChanges.push.apply(schemaChanges, findUnionTypeChanges(_oldType, newType)); + } else if ((0, _definition.isInputObjectType)(_oldType) && (0, _definition.isInputObjectType)(newType)) { + schemaChanges.push.apply(schemaChanges, findInputObjectTypeChanges(_oldType, newType)); + } else if ((0, _definition.isObjectType)(_oldType) && (0, _definition.isObjectType)(newType)) { + schemaChanges.push.apply(schemaChanges, findFieldChanges(_oldType, newType).concat(findImplementedInterfacesChanges(_oldType, newType))); + } else if ((0, _definition.isInterfaceType)(_oldType) && (0, _definition.isInterfaceType)(newType)) { + schemaChanges.push.apply(schemaChanges, findFieldChanges(_oldType, newType).concat(findImplementedInterfacesChanges(_oldType, newType))); + } else if (_oldType.constructor !== newType.constructor) { + schemaChanges.push({ + type: BreakingChangeType.TYPE_CHANGED_KIND, + description: "".concat(_oldType.name, " changed from ") + "".concat(typeKindName(_oldType), " to ").concat(typeKindName(newType), ".") + }); + } + } + return schemaChanges; + } + function findInputObjectTypeChanges(oldType, newType) { + var schemaChanges = []; + var fieldsDiff = diff((0, _objectValues.default)(oldType.getFields()), (0, _objectValues.default)(newType.getFields())); + for (var _i16 = 0, _fieldsDiff$added2 = fieldsDiff.added; _i16 < _fieldsDiff$added2.length; _i16++) { + var newField = _fieldsDiff$added2[_i16]; + if ((0, _definition.isRequiredInputField)(newField)) { + schemaChanges.push({ + type: BreakingChangeType.REQUIRED_INPUT_FIELD_ADDED, + description: "A required field ".concat(newField.name, " on input type ").concat(oldType.name, " was added.") + }); + } else { + schemaChanges.push({ + type: DangerousChangeType.OPTIONAL_INPUT_FIELD_ADDED, + description: "An optional field ".concat(newField.name, " on input type ").concat(oldType.name, " was added.") + }); + } + } + for (var _i18 = 0, _fieldsDiff$removed2 = fieldsDiff.removed; _i18 < _fieldsDiff$removed2.length; _i18++) { + var oldField = _fieldsDiff$removed2[_i18]; + schemaChanges.push({ + type: BreakingChangeType.FIELD_REMOVED, + description: "".concat(oldType.name, ".").concat(oldField.name, " was removed.") + }); + } + for (var _i20 = 0, _fieldsDiff$persisted2 = fieldsDiff.persisted; _i20 < _fieldsDiff$persisted2.length; _i20++) { + var _ref6 = _fieldsDiff$persisted2[_i20]; + var _oldField = _ref6[0]; + var _newField = _ref6[1]; + var isSafe = isChangeSafeForInputObjectFieldOrFieldArg(_oldField.type, _newField.type); + if (!isSafe) { + schemaChanges.push({ + type: BreakingChangeType.FIELD_CHANGED_KIND, + description: "".concat(oldType.name, ".").concat(_oldField.name, " changed type from ") + "".concat(String(_oldField.type), " to ").concat(String(_newField.type), ".") + }); + } + } + return schemaChanges; + } + function findUnionTypeChanges(oldType, newType) { + var schemaChanges = []; + var possibleTypesDiff = diff(oldType.getTypes(), newType.getTypes()); + for (var _i22 = 0, _possibleTypesDiff$ad2 = possibleTypesDiff.added; _i22 < _possibleTypesDiff$ad2.length; _i22++) { + var newPossibleType = _possibleTypesDiff$ad2[_i22]; + schemaChanges.push({ + type: DangerousChangeType.TYPE_ADDED_TO_UNION, + description: "".concat(newPossibleType.name, " was added to union type ").concat(oldType.name, ".") + }); + } + for (var _i24 = 0, _possibleTypesDiff$re2 = possibleTypesDiff.removed; _i24 < _possibleTypesDiff$re2.length; _i24++) { + var oldPossibleType = _possibleTypesDiff$re2[_i24]; + schemaChanges.push({ + type: BreakingChangeType.TYPE_REMOVED_FROM_UNION, + description: "".concat(oldPossibleType.name, " was removed from union type ").concat(oldType.name, ".") + }); + } + return schemaChanges; + } + function findEnumTypeChanges(oldType, newType) { + var schemaChanges = []; + var valuesDiff = diff(oldType.getValues(), newType.getValues()); + for (var _i26 = 0, _valuesDiff$added2 = valuesDiff.added; _i26 < _valuesDiff$added2.length; _i26++) { + var newValue = _valuesDiff$added2[_i26]; + schemaChanges.push({ + type: DangerousChangeType.VALUE_ADDED_TO_ENUM, + description: "".concat(newValue.name, " was added to enum type ").concat(oldType.name, ".") + }); + } + for (var _i28 = 0, _valuesDiff$removed2 = valuesDiff.removed; _i28 < _valuesDiff$removed2.length; _i28++) { + var oldValue = _valuesDiff$removed2[_i28]; + schemaChanges.push({ + type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM, + description: "".concat(oldValue.name, " was removed from enum type ").concat(oldType.name, ".") + }); + } + return schemaChanges; + } + function findImplementedInterfacesChanges(oldType, newType) { + var schemaChanges = []; + var interfacesDiff = diff(oldType.getInterfaces(), newType.getInterfaces()); + for (var _i30 = 0, _interfacesDiff$added2 = interfacesDiff.added; _i30 < _interfacesDiff$added2.length; _i30++) { + var newInterface = _interfacesDiff$added2[_i30]; + schemaChanges.push({ + type: DangerousChangeType.IMPLEMENTED_INTERFACE_ADDED, + description: "".concat(newInterface.name, " added to interfaces implemented by ").concat(oldType.name, ".") + }); + } + for (var _i32 = 0, _interfacesDiff$remov2 = interfacesDiff.removed; _i32 < _interfacesDiff$remov2.length; _i32++) { + var oldInterface = _interfacesDiff$remov2[_i32]; + schemaChanges.push({ + type: BreakingChangeType.IMPLEMENTED_INTERFACE_REMOVED, + description: "".concat(oldType.name, " no longer implements interface ").concat(oldInterface.name, ".") + }); + } + return schemaChanges; + } + function findFieldChanges(oldType, newType) { + var schemaChanges = []; + var fieldsDiff = diff((0, _objectValues.default)(oldType.getFields()), (0, _objectValues.default)(newType.getFields())); + for (var _i34 = 0, _fieldsDiff$removed4 = fieldsDiff.removed; _i34 < _fieldsDiff$removed4.length; _i34++) { + var oldField = _fieldsDiff$removed4[_i34]; + schemaChanges.push({ + type: BreakingChangeType.FIELD_REMOVED, + description: "".concat(oldType.name, ".").concat(oldField.name, " was removed.") + }); + } + for (var _i36 = 0, _fieldsDiff$persisted4 = fieldsDiff.persisted; _i36 < _fieldsDiff$persisted4.length; _i36++) { + var _ref8 = _fieldsDiff$persisted4[_i36]; + var _oldField2 = _ref8[0]; + var newField = _ref8[1]; + schemaChanges.push.apply(schemaChanges, findArgChanges(oldType, _oldField2, newField)); + var isSafe = isChangeSafeForObjectOrInterfaceField(_oldField2.type, newField.type); + if (!isSafe) { + schemaChanges.push({ + type: BreakingChangeType.FIELD_CHANGED_KIND, + description: "".concat(oldType.name, ".").concat(_oldField2.name, " changed type from ") + "".concat(String(_oldField2.type), " to ").concat(String(newField.type), ".") + }); + } + } + return schemaChanges; + } + function findArgChanges(oldType, oldField, newField) { + var schemaChanges = []; + var argsDiff = diff(oldField.args, newField.args); + for (var _i38 = 0, _argsDiff$removed4 = argsDiff.removed; _i38 < _argsDiff$removed4.length; _i38++) { + var oldArg = _argsDiff$removed4[_i38]; + schemaChanges.push({ + type: BreakingChangeType.ARG_REMOVED, + description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(oldArg.name, " was removed.") + }); + } + for (var _i40 = 0, _argsDiff$persisted2 = argsDiff.persisted; _i40 < _argsDiff$persisted2.length; _i40++) { + var _ref10 = _argsDiff$persisted2[_i40]; + var _oldArg = _ref10[0]; + var newArg = _ref10[1]; + var isSafe = isChangeSafeForInputObjectFieldOrFieldArg(_oldArg.type, newArg.type); + if (!isSafe) { + schemaChanges.push({ + type: BreakingChangeType.ARG_CHANGED_KIND, + description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(_oldArg.name, " has changed type from ") + "".concat(String(_oldArg.type), " to ").concat(String(newArg.type), ".") + }); + } else if (_oldArg.defaultValue !== void 0) { + if (newArg.defaultValue === void 0) { + schemaChanges.push({ + type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE, + description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(_oldArg.name, " defaultValue was removed.") + }); + } else { + var oldValueStr = stringifyValue(_oldArg.defaultValue, _oldArg.type); + var newValueStr = stringifyValue(newArg.defaultValue, newArg.type); + if (oldValueStr !== newValueStr) { + schemaChanges.push({ + type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE, + description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(_oldArg.name, " has changed defaultValue from ").concat(oldValueStr, " to ").concat(newValueStr, ".") + }); + } + } + } + } + for (var _i42 = 0, _argsDiff$added4 = argsDiff.added; _i42 < _argsDiff$added4.length; _i42++) { + var _newArg = _argsDiff$added4[_i42]; + if ((0, _definition.isRequiredArgument)(_newArg)) { + schemaChanges.push({ + type: BreakingChangeType.REQUIRED_ARG_ADDED, + description: "A required arg ".concat(_newArg.name, " on ").concat(oldType.name, ".").concat(oldField.name, " was added.") + }); + } else { + schemaChanges.push({ + type: DangerousChangeType.OPTIONAL_ARG_ADDED, + description: "An optional arg ".concat(_newArg.name, " on ").concat(oldType.name, ".").concat(oldField.name, " was added.") + }); + } + } + return schemaChanges; + } + function isChangeSafeForObjectOrInterfaceField(oldType, newType) { + if ((0, _definition.isListType)(oldType)) { + return (0, _definition.isListType)(newType) && isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType) || (0, _definition.isNonNullType)(newType) && isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType); + } + if ((0, _definition.isNonNullType)(oldType)) { + return (0, _definition.isNonNullType)(newType) && isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType); + } + return (0, _definition.isNamedType)(newType) && oldType.name === newType.name || (0, _definition.isNonNullType)(newType) && isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType); + } + function isChangeSafeForInputObjectFieldOrFieldArg(oldType, newType) { + if ((0, _definition.isListType)(oldType)) { + return (0, _definition.isListType)(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType.ofType); + } + if ((0, _definition.isNonNullType)(oldType)) { + return (0, _definition.isNonNullType)(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType.ofType) || !(0, _definition.isNonNullType)(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType); + } + return (0, _definition.isNamedType)(newType) && oldType.name === newType.name; + } + function typeKindName(type) { + if ((0, _definition.isScalarType)(type)) { + return "a Scalar type"; + } + if ((0, _definition.isObjectType)(type)) { + return "an Object type"; + } + if ((0, _definition.isInterfaceType)(type)) { + return "an Interface type"; + } + if ((0, _definition.isUnionType)(type)) { + return "a Union type"; + } + if ((0, _definition.isEnumType)(type)) { + return "an Enum type"; + } + if ((0, _definition.isInputObjectType)(type)) { + return "an Input type"; + } + (0, _invariant.default)(0, "Unexpected type: " + (0, _inspect.default)(type)); + } + function stringifyValue(value, type) { + var ast = (0, _astFromValue.astFromValue)(value, type); + ast != null || (0, _invariant.default)(0); + var sortedAST = (0, _visitor.visit)(ast, { + ObjectValue: function ObjectValue(objectNode) { + var fields = [].concat(objectNode.fields); + fields.sort(function(fieldA, fieldB) { + return (0, _naturalCompare.default)(fieldA.name.value, fieldB.name.value); + }); + return _objectSpread(_objectSpread({}, objectNode), {}, { + fields + }); + } + }); + return (0, _printer.print)(sortedAST); + } + function diff(oldArray, newArray) { + var added = []; + var removed = []; + var persisted = []; + var oldMap = (0, _keyMap.default)(oldArray, function(_ref11) { + var name = _ref11.name; + return name; + }); + var newMap = (0, _keyMap.default)(newArray, function(_ref12) { + var name = _ref12.name; + return name; + }); + for (var _i44 = 0; _i44 < oldArray.length; _i44++) { + var oldItem = oldArray[_i44]; + var newItem = newMap[oldItem.name]; + if (newItem === void 0) { + removed.push(oldItem); + } else { + persisted.push([oldItem, newItem]); + } + } + for (var _i46 = 0; _i46 < newArray.length; _i46++) { + var _newItem = newArray[_i46]; + if (oldMap[_newItem.name] === void 0) { + added.push(_newItem); + } + } + return { + added, + persisted, + removed + }; + } + } +}); + +// node_modules/graphql/utilities/findDeprecatedUsages.js +var require_findDeprecatedUsages = __commonJS({ + "node_modules/graphql/utilities/findDeprecatedUsages.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.findDeprecatedUsages = findDeprecatedUsages; + var _validate = require_validate2(); + var _NoDeprecatedCustomRule = require_NoDeprecatedCustomRule(); + function findDeprecatedUsages(schema2, ast) { + return (0, _validate.validate)(schema2, ast, [_NoDeprecatedCustomRule.NoDeprecatedCustomRule]); + } + } +}); + +// node_modules/graphql/utilities/index.js +var require_utilities = __commonJS({ + "node_modules/graphql/utilities/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "getIntrospectionQuery", { + enumerable: true, + get: function get() { + return _getIntrospectionQuery.getIntrospectionQuery; + } + }); + Object.defineProperty(exports2, "getOperationAST", { + enumerable: true, + get: function get() { + return _getOperationAST.getOperationAST; + } + }); + Object.defineProperty(exports2, "getOperationRootType", { + enumerable: true, + get: function get() { + return _getOperationRootType.getOperationRootType; + } + }); + Object.defineProperty(exports2, "introspectionFromSchema", { + enumerable: true, + get: function get() { + return _introspectionFromSchema.introspectionFromSchema; + } + }); + Object.defineProperty(exports2, "buildClientSchema", { + enumerable: true, + get: function get() { + return _buildClientSchema.buildClientSchema; + } + }); + Object.defineProperty(exports2, "buildASTSchema", { + enumerable: true, + get: function get() { + return _buildASTSchema.buildASTSchema; + } + }); + Object.defineProperty(exports2, "buildSchema", { + enumerable: true, + get: function get() { + return _buildASTSchema.buildSchema; + } + }); + Object.defineProperty(exports2, "extendSchema", { + enumerable: true, + get: function get() { + return _extendSchema.extendSchema; + } + }); + Object.defineProperty(exports2, "getDescription", { + enumerable: true, + get: function get() { + return _extendSchema.getDescription; + } + }); + Object.defineProperty(exports2, "lexicographicSortSchema", { + enumerable: true, + get: function get() { + return _lexicographicSortSchema.lexicographicSortSchema; + } + }); + Object.defineProperty(exports2, "printSchema", { + enumerable: true, + get: function get() { + return _printSchema.printSchema; + } + }); + Object.defineProperty(exports2, "printType", { + enumerable: true, + get: function get() { + return _printSchema.printType; + } + }); + Object.defineProperty(exports2, "printIntrospectionSchema", { + enumerable: true, + get: function get() { + return _printSchema.printIntrospectionSchema; + } + }); + Object.defineProperty(exports2, "typeFromAST", { + enumerable: true, + get: function get() { + return _typeFromAST.typeFromAST; + } + }); + Object.defineProperty(exports2, "valueFromAST", { + enumerable: true, + get: function get() { + return _valueFromAST.valueFromAST; + } + }); + Object.defineProperty(exports2, "valueFromASTUntyped", { + enumerable: true, + get: function get() { + return _valueFromASTUntyped.valueFromASTUntyped; + } + }); + Object.defineProperty(exports2, "astFromValue", { + enumerable: true, + get: function get() { + return _astFromValue.astFromValue; + } + }); + Object.defineProperty(exports2, "TypeInfo", { + enumerable: true, + get: function get() { + return _TypeInfo.TypeInfo; + } + }); + Object.defineProperty(exports2, "visitWithTypeInfo", { + enumerable: true, + get: function get() { + return _TypeInfo.visitWithTypeInfo; + } + }); + Object.defineProperty(exports2, "coerceInputValue", { + enumerable: true, + get: function get() { + return _coerceInputValue.coerceInputValue; + } + }); + Object.defineProperty(exports2, "concatAST", { + enumerable: true, + get: function get() { + return _concatAST.concatAST; + } + }); + Object.defineProperty(exports2, "separateOperations", { + enumerable: true, + get: function get() { + return _separateOperations.separateOperations; + } + }); + Object.defineProperty(exports2, "stripIgnoredCharacters", { + enumerable: true, + get: function get() { + return _stripIgnoredCharacters.stripIgnoredCharacters; + } + }); + Object.defineProperty(exports2, "isEqualType", { + enumerable: true, + get: function get() { + return _typeComparators.isEqualType; + } + }); + Object.defineProperty(exports2, "isTypeSubTypeOf", { + enumerable: true, + get: function get() { + return _typeComparators.isTypeSubTypeOf; + } + }); + Object.defineProperty(exports2, "doTypesOverlap", { + enumerable: true, + get: function get() { + return _typeComparators.doTypesOverlap; + } + }); + Object.defineProperty(exports2, "assertValidName", { + enumerable: true, + get: function get() { + return _assertValidName.assertValidName; + } + }); + Object.defineProperty(exports2, "isValidNameError", { + enumerable: true, + get: function get() { + return _assertValidName.isValidNameError; + } + }); + Object.defineProperty(exports2, "BreakingChangeType", { + enumerable: true, + get: function get() { + return _findBreakingChanges.BreakingChangeType; + } + }); + Object.defineProperty(exports2, "DangerousChangeType", { + enumerable: true, + get: function get() { + return _findBreakingChanges.DangerousChangeType; + } + }); + Object.defineProperty(exports2, "findBreakingChanges", { + enumerable: true, + get: function get() { + return _findBreakingChanges.findBreakingChanges; + } + }); + Object.defineProperty(exports2, "findDangerousChanges", { + enumerable: true, + get: function get() { + return _findBreakingChanges.findDangerousChanges; + } + }); + Object.defineProperty(exports2, "findDeprecatedUsages", { + enumerable: true, + get: function get() { + return _findDeprecatedUsages.findDeprecatedUsages; + } + }); + var _getIntrospectionQuery = require_getIntrospectionQuery(); + var _getOperationAST = require_getOperationAST(); + var _getOperationRootType = require_getOperationRootType(); + var _introspectionFromSchema = require_introspectionFromSchema(); + var _buildClientSchema = require_buildClientSchema(); + var _buildASTSchema = require_buildASTSchema(); + var _extendSchema = require_extendSchema(); + var _lexicographicSortSchema = require_lexicographicSortSchema(); + var _printSchema = require_printSchema(); + var _typeFromAST = require_typeFromAST(); + var _valueFromAST = require_valueFromAST(); + var _valueFromASTUntyped = require_valueFromASTUntyped(); + var _astFromValue = require_astFromValue(); + var _TypeInfo = require_TypeInfo(); + var _coerceInputValue = require_coerceInputValue(); + var _concatAST = require_concatAST(); + var _separateOperations = require_separateOperations(); + var _stripIgnoredCharacters = require_stripIgnoredCharacters(); + var _typeComparators = require_typeComparators(); + var _assertValidName = require_assertValidName(); + var _findBreakingChanges = require_findBreakingChanges(); + var _findDeprecatedUsages = require_findDeprecatedUsages(); + } +}); + +// node_modules/graphql/index.js +var require_graphql2 = __commonJS({ + "node_modules/graphql/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "version", { + enumerable: true, + get: function get() { + return _version.version; + } + }); + Object.defineProperty(exports2, "versionInfo", { + enumerable: true, + get: function get() { + return _version.versionInfo; + } + }); + Object.defineProperty(exports2, "graphql", { + enumerable: true, + get: function get() { + return _graphql.graphql; + } + }); + Object.defineProperty(exports2, "graphqlSync", { + enumerable: true, + get: function get() { + return _graphql.graphqlSync; + } + }); + Object.defineProperty(exports2, "GraphQLSchema", { + enumerable: true, + get: function get() { + return _index.GraphQLSchema; + } + }); + Object.defineProperty(exports2, "GraphQLDirective", { + enumerable: true, + get: function get() { + return _index.GraphQLDirective; + } + }); + Object.defineProperty(exports2, "GraphQLScalarType", { + enumerable: true, + get: function get() { + return _index.GraphQLScalarType; + } + }); + Object.defineProperty(exports2, "GraphQLObjectType", { + enumerable: true, + get: function get() { + return _index.GraphQLObjectType; + } + }); + Object.defineProperty(exports2, "GraphQLInterfaceType", { + enumerable: true, + get: function get() { + return _index.GraphQLInterfaceType; + } + }); + Object.defineProperty(exports2, "GraphQLUnionType", { + enumerable: true, + get: function get() { + return _index.GraphQLUnionType; + } + }); + Object.defineProperty(exports2, "GraphQLEnumType", { + enumerable: true, + get: function get() { + return _index.GraphQLEnumType; + } + }); + Object.defineProperty(exports2, "GraphQLInputObjectType", { + enumerable: true, + get: function get() { + return _index.GraphQLInputObjectType; + } + }); + Object.defineProperty(exports2, "GraphQLList", { + enumerable: true, + get: function get() { + return _index.GraphQLList; + } + }); + Object.defineProperty(exports2, "GraphQLNonNull", { + enumerable: true, + get: function get() { + return _index.GraphQLNonNull; + } + }); + Object.defineProperty(exports2, "specifiedScalarTypes", { + enumerable: true, + get: function get() { + return _index.specifiedScalarTypes; + } + }); + Object.defineProperty(exports2, "GraphQLInt", { + enumerable: true, + get: function get() { + return _index.GraphQLInt; + } + }); + Object.defineProperty(exports2, "GraphQLFloat", { + enumerable: true, + get: function get() { + return _index.GraphQLFloat; + } + }); + Object.defineProperty(exports2, "GraphQLString", { + enumerable: true, + get: function get() { + return _index.GraphQLString; + } + }); + Object.defineProperty(exports2, "GraphQLBoolean", { + enumerable: true, + get: function get() { + return _index.GraphQLBoolean; + } + }); + Object.defineProperty(exports2, "GraphQLID", { + enumerable: true, + get: function get() { + return _index.GraphQLID; + } + }); + Object.defineProperty(exports2, "specifiedDirectives", { + enumerable: true, + get: function get() { + return _index.specifiedDirectives; + } + }); + Object.defineProperty(exports2, "GraphQLIncludeDirective", { + enumerable: true, + get: function get() { + return _index.GraphQLIncludeDirective; + } + }); + Object.defineProperty(exports2, "GraphQLSkipDirective", { + enumerable: true, + get: function get() { + return _index.GraphQLSkipDirective; + } + }); + Object.defineProperty(exports2, "GraphQLDeprecatedDirective", { + enumerable: true, + get: function get() { + return _index.GraphQLDeprecatedDirective; + } + }); + Object.defineProperty(exports2, "GraphQLSpecifiedByDirective", { + enumerable: true, + get: function get() { + return _index.GraphQLSpecifiedByDirective; + } + }); + Object.defineProperty(exports2, "TypeKind", { + enumerable: true, + get: function get() { + return _index.TypeKind; + } + }); + Object.defineProperty(exports2, "DEFAULT_DEPRECATION_REASON", { + enumerable: true, + get: function get() { + return _index.DEFAULT_DEPRECATION_REASON; + } + }); + Object.defineProperty(exports2, "introspectionTypes", { + enumerable: true, + get: function get() { + return _index.introspectionTypes; + } + }); + Object.defineProperty(exports2, "__Schema", { + enumerable: true, + get: function get() { + return _index.__Schema; + } + }); + Object.defineProperty(exports2, "__Directive", { + enumerable: true, + get: function get() { + return _index.__Directive; + } + }); + Object.defineProperty(exports2, "__DirectiveLocation", { + enumerable: true, + get: function get() { + return _index.__DirectiveLocation; + } + }); + Object.defineProperty(exports2, "__Type", { + enumerable: true, + get: function get() { + return _index.__Type; + } + }); + Object.defineProperty(exports2, "__Field", { + enumerable: true, + get: function get() { + return _index.__Field; + } + }); + Object.defineProperty(exports2, "__InputValue", { + enumerable: true, + get: function get() { + return _index.__InputValue; + } + }); + Object.defineProperty(exports2, "__EnumValue", { + enumerable: true, + get: function get() { + return _index.__EnumValue; + } + }); + Object.defineProperty(exports2, "__TypeKind", { + enumerable: true, + get: function get() { + return _index.__TypeKind; + } + }); + Object.defineProperty(exports2, "SchemaMetaFieldDef", { + enumerable: true, + get: function get() { + return _index.SchemaMetaFieldDef; + } + }); + Object.defineProperty(exports2, "TypeMetaFieldDef", { + enumerable: true, + get: function get() { + return _index.TypeMetaFieldDef; + } + }); + Object.defineProperty(exports2, "TypeNameMetaFieldDef", { + enumerable: true, + get: function get() { + return _index.TypeNameMetaFieldDef; + } + }); + Object.defineProperty(exports2, "isSchema", { + enumerable: true, + get: function get() { + return _index.isSchema; + } + }); + Object.defineProperty(exports2, "isDirective", { + enumerable: true, + get: function get() { + return _index.isDirective; + } + }); + Object.defineProperty(exports2, "isType", { + enumerable: true, + get: function get() { + return _index.isType; + } + }); + Object.defineProperty(exports2, "isScalarType", { + enumerable: true, + get: function get() { + return _index.isScalarType; + } + }); + Object.defineProperty(exports2, "isObjectType", { + enumerable: true, + get: function get() { + return _index.isObjectType; + } + }); + Object.defineProperty(exports2, "isInterfaceType", { + enumerable: true, + get: function get() { + return _index.isInterfaceType; + } + }); + Object.defineProperty(exports2, "isUnionType", { + enumerable: true, + get: function get() { + return _index.isUnionType; + } + }); + Object.defineProperty(exports2, "isEnumType", { + enumerable: true, + get: function get() { + return _index.isEnumType; + } + }); + Object.defineProperty(exports2, "isInputObjectType", { + enumerable: true, + get: function get() { + return _index.isInputObjectType; + } + }); + Object.defineProperty(exports2, "isListType", { + enumerable: true, + get: function get() { + return _index.isListType; + } + }); + Object.defineProperty(exports2, "isNonNullType", { + enumerable: true, + get: function get() { + return _index.isNonNullType; + } + }); + Object.defineProperty(exports2, "isInputType", { + enumerable: true, + get: function get() { + return _index.isInputType; + } + }); + Object.defineProperty(exports2, "isOutputType", { + enumerable: true, + get: function get() { + return _index.isOutputType; + } + }); + Object.defineProperty(exports2, "isLeafType", { + enumerable: true, + get: function get() { + return _index.isLeafType; + } + }); + Object.defineProperty(exports2, "isCompositeType", { + enumerable: true, + get: function get() { + return _index.isCompositeType; + } + }); + Object.defineProperty(exports2, "isAbstractType", { + enumerable: true, + get: function get() { + return _index.isAbstractType; + } + }); + Object.defineProperty(exports2, "isWrappingType", { + enumerable: true, + get: function get() { + return _index.isWrappingType; + } + }); + Object.defineProperty(exports2, "isNullableType", { + enumerable: true, + get: function get() { + return _index.isNullableType; + } + }); + Object.defineProperty(exports2, "isNamedType", { + enumerable: true, + get: function get() { + return _index.isNamedType; + } + }); + Object.defineProperty(exports2, "isRequiredArgument", { + enumerable: true, + get: function get() { + return _index.isRequiredArgument; + } + }); + Object.defineProperty(exports2, "isRequiredInputField", { + enumerable: true, + get: function get() { + return _index.isRequiredInputField; + } + }); + Object.defineProperty(exports2, "isSpecifiedScalarType", { + enumerable: true, + get: function get() { + return _index.isSpecifiedScalarType; + } + }); + Object.defineProperty(exports2, "isIntrospectionType", { + enumerable: true, + get: function get() { + return _index.isIntrospectionType; + } + }); + Object.defineProperty(exports2, "isSpecifiedDirective", { + enumerable: true, + get: function get() { + return _index.isSpecifiedDirective; + } + }); + Object.defineProperty(exports2, "assertSchema", { + enumerable: true, + get: function get() { + return _index.assertSchema; + } + }); + Object.defineProperty(exports2, "assertDirective", { + enumerable: true, + get: function get() { + return _index.assertDirective; + } + }); + Object.defineProperty(exports2, "assertType", { + enumerable: true, + get: function get() { + return _index.assertType; + } + }); + Object.defineProperty(exports2, "assertScalarType", { + enumerable: true, + get: function get() { + return _index.assertScalarType; + } + }); + Object.defineProperty(exports2, "assertObjectType", { + enumerable: true, + get: function get() { + return _index.assertObjectType; + } + }); + Object.defineProperty(exports2, "assertInterfaceType", { + enumerable: true, + get: function get() { + return _index.assertInterfaceType; + } + }); + Object.defineProperty(exports2, "assertUnionType", { + enumerable: true, + get: function get() { + return _index.assertUnionType; + } + }); + Object.defineProperty(exports2, "assertEnumType", { + enumerable: true, + get: function get() { + return _index.assertEnumType; + } + }); + Object.defineProperty(exports2, "assertInputObjectType", { + enumerable: true, + get: function get() { + return _index.assertInputObjectType; + } + }); + Object.defineProperty(exports2, "assertListType", { + enumerable: true, + get: function get() { + return _index.assertListType; + } + }); + Object.defineProperty(exports2, "assertNonNullType", { + enumerable: true, + get: function get() { + return _index.assertNonNullType; + } + }); + Object.defineProperty(exports2, "assertInputType", { + enumerable: true, + get: function get() { + return _index.assertInputType; + } + }); + Object.defineProperty(exports2, "assertOutputType", { + enumerable: true, + get: function get() { + return _index.assertOutputType; + } + }); + Object.defineProperty(exports2, "assertLeafType", { + enumerable: true, + get: function get() { + return _index.assertLeafType; + } + }); + Object.defineProperty(exports2, "assertCompositeType", { + enumerable: true, + get: function get() { + return _index.assertCompositeType; + } + }); + Object.defineProperty(exports2, "assertAbstractType", { + enumerable: true, + get: function get() { + return _index.assertAbstractType; + } + }); + Object.defineProperty(exports2, "assertWrappingType", { + enumerable: true, + get: function get() { + return _index.assertWrappingType; + } + }); + Object.defineProperty(exports2, "assertNullableType", { + enumerable: true, + get: function get() { + return _index.assertNullableType; + } + }); + Object.defineProperty(exports2, "assertNamedType", { + enumerable: true, + get: function get() { + return _index.assertNamedType; + } + }); + Object.defineProperty(exports2, "getNullableType", { + enumerable: true, + get: function get() { + return _index.getNullableType; + } + }); + Object.defineProperty(exports2, "getNamedType", { + enumerable: true, + get: function get() { + return _index.getNamedType; + } + }); + Object.defineProperty(exports2, "validateSchema", { + enumerable: true, + get: function get() { + return _index.validateSchema; + } + }); + Object.defineProperty(exports2, "assertValidSchema", { + enumerable: true, + get: function get() { + return _index.assertValidSchema; + } + }); + Object.defineProperty(exports2, "Token", { + enumerable: true, + get: function get() { + return _index2.Token; + } + }); + Object.defineProperty(exports2, "Source", { + enumerable: true, + get: function get() { + return _index2.Source; + } + }); + Object.defineProperty(exports2, "Location", { + enumerable: true, + get: function get() { + return _index2.Location; + } + }); + Object.defineProperty(exports2, "getLocation", { + enumerable: true, + get: function get() { + return _index2.getLocation; + } + }); + Object.defineProperty(exports2, "printLocation", { + enumerable: true, + get: function get() { + return _index2.printLocation; + } + }); + Object.defineProperty(exports2, "printSourceLocation", { + enumerable: true, + get: function get() { + return _index2.printSourceLocation; + } + }); + Object.defineProperty(exports2, "Lexer", { + enumerable: true, + get: function get() { + return _index2.Lexer; + } + }); + Object.defineProperty(exports2, "TokenKind", { + enumerable: true, + get: function get() { + return _index2.TokenKind; + } + }); + Object.defineProperty(exports2, "parse", { + enumerable: true, + get: function get() { + return _index2.parse; + } + }); + Object.defineProperty(exports2, "parseValue", { + enumerable: true, + get: function get() { + return _index2.parseValue; + } + }); + Object.defineProperty(exports2, "parseType", { + enumerable: true, + get: function get() { + return _index2.parseType; + } + }); + Object.defineProperty(exports2, "print", { + enumerable: true, + get: function get() { + return _index2.print; + } + }); + Object.defineProperty(exports2, "visit", { + enumerable: true, + get: function get() { + return _index2.visit; + } + }); + Object.defineProperty(exports2, "visitInParallel", { + enumerable: true, + get: function get() { + return _index2.visitInParallel; + } + }); + Object.defineProperty(exports2, "getVisitFn", { + enumerable: true, + get: function get() { + return _index2.getVisitFn; + } + }); + Object.defineProperty(exports2, "BREAK", { + enumerable: true, + get: function get() { + return _index2.BREAK; + } + }); + Object.defineProperty(exports2, "Kind", { + enumerable: true, + get: function get() { + return _index2.Kind; + } + }); + Object.defineProperty(exports2, "DirectiveLocation", { + enumerable: true, + get: function get() { + return _index2.DirectiveLocation; + } + }); + Object.defineProperty(exports2, "isDefinitionNode", { + enumerable: true, + get: function get() { + return _index2.isDefinitionNode; + } + }); + Object.defineProperty(exports2, "isExecutableDefinitionNode", { + enumerable: true, + get: function get() { + return _index2.isExecutableDefinitionNode; + } + }); + Object.defineProperty(exports2, "isSelectionNode", { + enumerable: true, + get: function get() { + return _index2.isSelectionNode; + } + }); + Object.defineProperty(exports2, "isValueNode", { + enumerable: true, + get: function get() { + return _index2.isValueNode; + } + }); + Object.defineProperty(exports2, "isTypeNode", { + enumerable: true, + get: function get() { + return _index2.isTypeNode; + } + }); + Object.defineProperty(exports2, "isTypeSystemDefinitionNode", { + enumerable: true, + get: function get() { + return _index2.isTypeSystemDefinitionNode; + } + }); + Object.defineProperty(exports2, "isTypeDefinitionNode", { + enumerable: true, + get: function get() { + return _index2.isTypeDefinitionNode; + } + }); + Object.defineProperty(exports2, "isTypeSystemExtensionNode", { + enumerable: true, + get: function get() { + return _index2.isTypeSystemExtensionNode; + } + }); + Object.defineProperty(exports2, "isTypeExtensionNode", { + enumerable: true, + get: function get() { + return _index2.isTypeExtensionNode; + } + }); + Object.defineProperty(exports2, "execute", { + enumerable: true, + get: function get() { + return _index3.execute; + } + }); + Object.defineProperty(exports2, "executeSync", { + enumerable: true, + get: function get() { + return _index3.executeSync; + } + }); + Object.defineProperty(exports2, "defaultFieldResolver", { + enumerable: true, + get: function get() { + return _index3.defaultFieldResolver; + } + }); + Object.defineProperty(exports2, "defaultTypeResolver", { + enumerable: true, + get: function get() { + return _index3.defaultTypeResolver; + } + }); + Object.defineProperty(exports2, "responsePathAsArray", { + enumerable: true, + get: function get() { + return _index3.responsePathAsArray; + } + }); + Object.defineProperty(exports2, "getDirectiveValues", { + enumerable: true, + get: function get() { + return _index3.getDirectiveValues; + } + }); + Object.defineProperty(exports2, "subscribe", { + enumerable: true, + get: function get() { + return _index4.subscribe; + } + }); + Object.defineProperty(exports2, "createSourceEventStream", { + enumerable: true, + get: function get() { + return _index4.createSourceEventStream; + } + }); + Object.defineProperty(exports2, "validate", { + enumerable: true, + get: function get() { + return _index5.validate; + } + }); + Object.defineProperty(exports2, "ValidationContext", { + enumerable: true, + get: function get() { + return _index5.ValidationContext; + } + }); + Object.defineProperty(exports2, "specifiedRules", { + enumerable: true, + get: function get() { + return _index5.specifiedRules; + } + }); + Object.defineProperty(exports2, "ExecutableDefinitionsRule", { + enumerable: true, + get: function get() { + return _index5.ExecutableDefinitionsRule; + } + }); + Object.defineProperty(exports2, "FieldsOnCorrectTypeRule", { + enumerable: true, + get: function get() { + return _index5.FieldsOnCorrectTypeRule; + } + }); + Object.defineProperty(exports2, "FragmentsOnCompositeTypesRule", { + enumerable: true, + get: function get() { + return _index5.FragmentsOnCompositeTypesRule; + } + }); + Object.defineProperty(exports2, "KnownArgumentNamesRule", { + enumerable: true, + get: function get() { + return _index5.KnownArgumentNamesRule; + } + }); + Object.defineProperty(exports2, "KnownDirectivesRule", { + enumerable: true, + get: function get() { + return _index5.KnownDirectivesRule; + } + }); + Object.defineProperty(exports2, "KnownFragmentNamesRule", { + enumerable: true, + get: function get() { + return _index5.KnownFragmentNamesRule; + } + }); + Object.defineProperty(exports2, "KnownTypeNamesRule", { + enumerable: true, + get: function get() { + return _index5.KnownTypeNamesRule; + } + }); + Object.defineProperty(exports2, "LoneAnonymousOperationRule", { + enumerable: true, + get: function get() { + return _index5.LoneAnonymousOperationRule; + } + }); + Object.defineProperty(exports2, "NoFragmentCyclesRule", { + enumerable: true, + get: function get() { + return _index5.NoFragmentCyclesRule; + } + }); + Object.defineProperty(exports2, "NoUndefinedVariablesRule", { + enumerable: true, + get: function get() { + return _index5.NoUndefinedVariablesRule; + } + }); + Object.defineProperty(exports2, "NoUnusedFragmentsRule", { + enumerable: true, + get: function get() { + return _index5.NoUnusedFragmentsRule; + } + }); + Object.defineProperty(exports2, "NoUnusedVariablesRule", { + enumerable: true, + get: function get() { + return _index5.NoUnusedVariablesRule; + } + }); + Object.defineProperty(exports2, "OverlappingFieldsCanBeMergedRule", { + enumerable: true, + get: function get() { + return _index5.OverlappingFieldsCanBeMergedRule; + } + }); + Object.defineProperty(exports2, "PossibleFragmentSpreadsRule", { + enumerable: true, + get: function get() { + return _index5.PossibleFragmentSpreadsRule; + } + }); + Object.defineProperty(exports2, "ProvidedRequiredArgumentsRule", { + enumerable: true, + get: function get() { + return _index5.ProvidedRequiredArgumentsRule; + } + }); + Object.defineProperty(exports2, "ScalarLeafsRule", { + enumerable: true, + get: function get() { + return _index5.ScalarLeafsRule; + } + }); + Object.defineProperty(exports2, "SingleFieldSubscriptionsRule", { + enumerable: true, + get: function get() { + return _index5.SingleFieldSubscriptionsRule; + } + }); + Object.defineProperty(exports2, "UniqueArgumentNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueArgumentNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueDirectivesPerLocationRule", { + enumerable: true, + get: function get() { + return _index5.UniqueDirectivesPerLocationRule; + } + }); + Object.defineProperty(exports2, "UniqueFragmentNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueFragmentNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueInputFieldNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueInputFieldNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueOperationNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueOperationNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueVariableNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueVariableNamesRule; + } + }); + Object.defineProperty(exports2, "ValuesOfCorrectTypeRule", { + enumerable: true, + get: function get() { + return _index5.ValuesOfCorrectTypeRule; + } + }); + Object.defineProperty(exports2, "VariablesAreInputTypesRule", { + enumerable: true, + get: function get() { + return _index5.VariablesAreInputTypesRule; + } + }); + Object.defineProperty(exports2, "VariablesInAllowedPositionRule", { + enumerable: true, + get: function get() { + return _index5.VariablesInAllowedPositionRule; + } + }); + Object.defineProperty(exports2, "LoneSchemaDefinitionRule", { + enumerable: true, + get: function get() { + return _index5.LoneSchemaDefinitionRule; + } + }); + Object.defineProperty(exports2, "UniqueOperationTypesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueOperationTypesRule; + } + }); + Object.defineProperty(exports2, "UniqueTypeNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueTypeNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueEnumValueNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueEnumValueNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueFieldDefinitionNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueFieldDefinitionNamesRule; + } + }); + Object.defineProperty(exports2, "UniqueDirectiveNamesRule", { + enumerable: true, + get: function get() { + return _index5.UniqueDirectiveNamesRule; + } + }); + Object.defineProperty(exports2, "PossibleTypeExtensionsRule", { + enumerable: true, + get: function get() { + return _index5.PossibleTypeExtensionsRule; + } + }); + Object.defineProperty(exports2, "NoDeprecatedCustomRule", { + enumerable: true, + get: function get() { + return _index5.NoDeprecatedCustomRule; + } + }); + Object.defineProperty(exports2, "NoSchemaIntrospectionCustomRule", { + enumerable: true, + get: function get() { + return _index5.NoSchemaIntrospectionCustomRule; + } + }); + Object.defineProperty(exports2, "GraphQLError", { + enumerable: true, + get: function get() { + return _index6.GraphQLError; + } + }); + Object.defineProperty(exports2, "syntaxError", { + enumerable: true, + get: function get() { + return _index6.syntaxError; + } + }); + Object.defineProperty(exports2, "locatedError", { + enumerable: true, + get: function get() { + return _index6.locatedError; + } + }); + Object.defineProperty(exports2, "printError", { + enumerable: true, + get: function get() { + return _index6.printError; + } + }); + Object.defineProperty(exports2, "formatError", { + enumerable: true, + get: function get() { + return _index6.formatError; + } + }); + Object.defineProperty(exports2, "getIntrospectionQuery", { + enumerable: true, + get: function get() { + return _index7.getIntrospectionQuery; + } + }); + Object.defineProperty(exports2, "getOperationAST", { + enumerable: true, + get: function get() { + return _index7.getOperationAST; + } + }); + Object.defineProperty(exports2, "getOperationRootType", { + enumerable: true, + get: function get() { + return _index7.getOperationRootType; + } + }); + Object.defineProperty(exports2, "introspectionFromSchema", { + enumerable: true, + get: function get() { + return _index7.introspectionFromSchema; + } + }); + Object.defineProperty(exports2, "buildClientSchema", { + enumerable: true, + get: function get() { + return _index7.buildClientSchema; + } + }); + Object.defineProperty(exports2, "buildASTSchema", { + enumerable: true, + get: function get() { + return _index7.buildASTSchema; + } + }); + Object.defineProperty(exports2, "buildSchema", { + enumerable: true, + get: function get() { + return _index7.buildSchema; + } + }); + Object.defineProperty(exports2, "getDescription", { + enumerable: true, + get: function get() { + return _index7.getDescription; + } + }); + Object.defineProperty(exports2, "extendSchema", { + enumerable: true, + get: function get() { + return _index7.extendSchema; + } + }); + Object.defineProperty(exports2, "lexicographicSortSchema", { + enumerable: true, + get: function get() { + return _index7.lexicographicSortSchema; + } + }); + Object.defineProperty(exports2, "printSchema", { + enumerable: true, + get: function get() { + return _index7.printSchema; + } + }); + Object.defineProperty(exports2, "printType", { + enumerable: true, + get: function get() { + return _index7.printType; + } + }); + Object.defineProperty(exports2, "printIntrospectionSchema", { + enumerable: true, + get: function get() { + return _index7.printIntrospectionSchema; + } + }); + Object.defineProperty(exports2, "typeFromAST", { + enumerable: true, + get: function get() { + return _index7.typeFromAST; + } + }); + Object.defineProperty(exports2, "valueFromAST", { + enumerable: true, + get: function get() { + return _index7.valueFromAST; + } + }); + Object.defineProperty(exports2, "valueFromASTUntyped", { + enumerable: true, + get: function get() { + return _index7.valueFromASTUntyped; + } + }); + Object.defineProperty(exports2, "astFromValue", { + enumerable: true, + get: function get() { + return _index7.astFromValue; + } + }); + Object.defineProperty(exports2, "TypeInfo", { + enumerable: true, + get: function get() { + return _index7.TypeInfo; + } + }); + Object.defineProperty(exports2, "visitWithTypeInfo", { + enumerable: true, + get: function get() { + return _index7.visitWithTypeInfo; + } + }); + Object.defineProperty(exports2, "coerceInputValue", { + enumerable: true, + get: function get() { + return _index7.coerceInputValue; + } + }); + Object.defineProperty(exports2, "concatAST", { + enumerable: true, + get: function get() { + return _index7.concatAST; + } + }); + Object.defineProperty(exports2, "separateOperations", { + enumerable: true, + get: function get() { + return _index7.separateOperations; + } + }); + Object.defineProperty(exports2, "stripIgnoredCharacters", { + enumerable: true, + get: function get() { + return _index7.stripIgnoredCharacters; + } + }); + Object.defineProperty(exports2, "isEqualType", { + enumerable: true, + get: function get() { + return _index7.isEqualType; + } + }); + Object.defineProperty(exports2, "isTypeSubTypeOf", { + enumerable: true, + get: function get() { + return _index7.isTypeSubTypeOf; + } + }); + Object.defineProperty(exports2, "doTypesOverlap", { + enumerable: true, + get: function get() { + return _index7.doTypesOverlap; + } + }); + Object.defineProperty(exports2, "assertValidName", { + enumerable: true, + get: function get() { + return _index7.assertValidName; + } + }); + Object.defineProperty(exports2, "isValidNameError", { + enumerable: true, + get: function get() { + return _index7.isValidNameError; + } + }); + Object.defineProperty(exports2, "BreakingChangeType", { + enumerable: true, + get: function get() { + return _index7.BreakingChangeType; + } + }); + Object.defineProperty(exports2, "DangerousChangeType", { + enumerable: true, + get: function get() { + return _index7.DangerousChangeType; + } + }); + Object.defineProperty(exports2, "findBreakingChanges", { + enumerable: true, + get: function get() { + return _index7.findBreakingChanges; + } + }); + Object.defineProperty(exports2, "findDangerousChanges", { + enumerable: true, + get: function get() { + return _index7.findDangerousChanges; + } + }); + Object.defineProperty(exports2, "findDeprecatedUsages", { + enumerable: true, + get: function get() { + return _index7.findDeprecatedUsages; + } + }); + var _version = require_version(); + var _graphql = require_graphql(); + var _index = require_type(); + var _index2 = require_language(); + var _index3 = require_execution(); + var _index4 = require_subscription(); + var _index5 = require_validation(); + var _index6 = require_error(); + var _index7 = require_utilities(); + } +}); + +// node_modules/apollo-server-errors/dist/index.js +var require_dist2 = __commonJS({ + "node_modules/apollo-server-errors/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.formatApolloErrors = exports2.UserInputError = exports2.PersistedQueryNotSupportedError = exports2.PersistedQueryNotFoundError = exports2.ForbiddenError = exports2.AuthenticationError = exports2.ValidationError = exports2.SyntaxError = exports2.fromGraphQLError = exports2.toApolloError = exports2.ApolloError = void 0; + var graphql_1 = require_graphql2(); + var ApolloError = class extends Error { + constructor(message, code, extensions) { + super(message); + if (!this.name) { + Object.defineProperty(this, "name", { value: "ApolloError" }); + } + if (extensions === null || extensions === void 0 ? void 0 : extensions.extensions) { + throw Error("Pass extensions directly as the third argument of the ApolloError constructor: `new ApolloError(message, code, {myExt: value})`, not `new ApolloError(message, code, {extensions: {myExt: value}})`"); + } + this.extensions = __spreadProps(__spreadValues({}, extensions), { code }); + } + toJSON() { + return (0, graphql_1.formatError)(toGraphQLError(this)); + } + toString() { + return (0, graphql_1.printError)(toGraphQLError(this)); + } + get [Symbol.toStringTag]() { + return this.name; + } + }; + exports2.ApolloError = ApolloError; + function toGraphQLError(error) { + return new graphql_1.GraphQLError(error.message, error.nodes, error.source, error.positions, error.path, error.originalError, error.extensions); + } + function enrichError(error, debug = false) { + var _a, _b, _c; + const expanded = Object.create(Object.getPrototypeOf(error), { + name: { + value: error.name + }, + message: { + value: error.message, + enumerable: true, + writable: true + }, + locations: { + value: error.locations || void 0, + enumerable: true + }, + path: { + value: error.path || void 0, + enumerable: true + }, + nodes: { + value: error.nodes || void 0 + }, + source: { + value: error.source || void 0 + }, + positions: { + value: error.positions || void 0 + }, + originalError: { + value: error.originalError + } + }); + expanded.extensions = __spreadProps(__spreadValues({}, error.extensions), { + code: ((_a = error.extensions) === null || _a === void 0 ? void 0 : _a.code) || "INTERNAL_SERVER_ERROR", + exception: __spreadValues(__spreadValues({}, (_b = error.extensions) === null || _b === void 0 ? void 0 : _b.exception), error.originalError) + }); + delete expanded.extensions.exception.extensions; + if (debug && !expanded.extensions.exception.stacktrace) { + const stack = ((_c = error.originalError) === null || _c === void 0 ? void 0 : _c.stack) || error.stack; + expanded.extensions.exception.stacktrace = stack === null || stack === void 0 ? void 0 : stack.split("\n"); + } + if (Object.keys(expanded.extensions.exception).length === 0) { + delete expanded.extensions.exception; + } + return expanded; + } + function toApolloError(error, code = "INTERNAL_SERVER_ERROR") { + let err = error; + if (err.extensions) { + err.extensions.code = code; + } else { + err.extensions = { code }; + } + return err; + } + exports2.toApolloError = toApolloError; + function fromGraphQLError(error, options) { + const copy = (options === null || options === void 0 ? void 0 : options.errorClass) ? new options.errorClass(error.message) : new ApolloError(error.message); + Object.entries(error).forEach(([key, value]) => { + if (key === "extensions") { + return; + } + copy[key] = value; + }); + copy.extensions = __spreadValues(__spreadValues({}, copy.extensions), error.extensions); + if (!copy.extensions.code) { + copy.extensions.code = (options === null || options === void 0 ? void 0 : options.code) || "INTERNAL_SERVER_ERROR"; + } + Object.defineProperty(copy, "originalError", { value: {} }); + Object.getOwnPropertyNames(error).forEach((key) => { + Object.defineProperty(copy.originalError, key, { + value: error[key] + }); + }); + return copy; + } + exports2.fromGraphQLError = fromGraphQLError; + var SyntaxError2 = class extends ApolloError { + constructor(message) { + super(message, "GRAPHQL_PARSE_FAILED"); + Object.defineProperty(this, "name", { value: "SyntaxError" }); + } + }; + exports2.SyntaxError = SyntaxError2; + var ValidationError = class extends ApolloError { + constructor(message) { + super(message, "GRAPHQL_VALIDATION_FAILED"); + Object.defineProperty(this, "name", { value: "ValidationError" }); + } + }; + exports2.ValidationError = ValidationError; + var AuthenticationError = class extends ApolloError { + constructor(message, extensions) { + super(message, "UNAUTHENTICATED", extensions); + Object.defineProperty(this, "name", { value: "AuthenticationError" }); + } + }; + exports2.AuthenticationError = AuthenticationError; + var ForbiddenError = class extends ApolloError { + constructor(message, extensions) { + super(message, "FORBIDDEN", extensions); + Object.defineProperty(this, "name", { value: "ForbiddenError" }); + } + }; + exports2.ForbiddenError = ForbiddenError; + var PersistedQueryNotFoundError = class extends ApolloError { + constructor() { + super("PersistedQueryNotFound", "PERSISTED_QUERY_NOT_FOUND"); + Object.defineProperty(this, "name", { + value: "PersistedQueryNotFoundError" + }); + } + }; + exports2.PersistedQueryNotFoundError = PersistedQueryNotFoundError; + var PersistedQueryNotSupportedError = class extends ApolloError { + constructor() { + super("PersistedQueryNotSupported", "PERSISTED_QUERY_NOT_SUPPORTED"); + Object.defineProperty(this, "name", { + value: "PersistedQueryNotSupportedError" + }); + } + }; + exports2.PersistedQueryNotSupportedError = PersistedQueryNotSupportedError; + var UserInputError = class extends ApolloError { + constructor(message, extensions) { + super(message, "BAD_USER_INPUT", extensions); + Object.defineProperty(this, "name", { value: "UserInputError" }); + } + }; + exports2.UserInputError = UserInputError; + function formatApolloErrors(errors, options) { + if (!options) { + return errors.map((error) => enrichError(error)); + } + const { formatter, debug } = options; + const enrichedErrors = errors.map((error) => enrichError(error, debug)); + const makePrintable = (error) => { + if (error instanceof Error) { + const graphQLError = error; + return __spreadValues(__spreadValues(__spreadValues({ + message: graphQLError.message + }, graphQLError.locations && { locations: graphQLError.locations }), graphQLError.path && { path: graphQLError.path }), graphQLError.extensions && { extensions: graphQLError.extensions }); + } + return error; + }; + if (!formatter) { + return enrichedErrors; + } + return enrichedErrors.map((error) => { + try { + return makePrintable(formatter(error)); + } catch (err) { + if (debug) { + return enrichError(err, debug); + } else { + const newError = fromGraphQLError(new graphql_1.GraphQLError("Internal server error")); + return enrichError(newError, debug); + } + } + }); + } + exports2.formatApolloErrors = formatApolloErrors; + } +}); + +// node_modules/apollo-server-core/dist/utils/schemaInstrumentation.js +var require_schemaInstrumentation = __commonJS({ + "node_modules/apollo-server-core/dist/utils/schemaInstrumentation.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.whenResultIsFinished = exports2.pluginsEnabledForSchemaResolvers = exports2.enablePluginsForSchemaResolvers = exports2.symbolUserFieldResolver = exports2.symbolExecutionDispatcherWillResolveField = void 0; + var type_1 = require_type(); + var execution_1 = require_execution(); + exports2.symbolExecutionDispatcherWillResolveField = Symbol("apolloServerExecutionDispatcherWillResolveField"); + exports2.symbolUserFieldResolver = Symbol("apolloServerUserFieldResolver"); + var symbolPluginsEnabled = Symbol("apolloServerPluginsEnabled"); + function enablePluginsForSchemaResolvers(schema2) { + if (pluginsEnabledForSchemaResolvers(schema2)) { + return schema2; + } + Object.defineProperty(schema2, symbolPluginsEnabled, { + value: true + }); + forEachField(schema2, wrapField); + return schema2; + } + exports2.enablePluginsForSchemaResolvers = enablePluginsForSchemaResolvers; + function pluginsEnabledForSchemaResolvers(schema2) { + return !!schema2[symbolPluginsEnabled]; + } + exports2.pluginsEnabledForSchemaResolvers = pluginsEnabledForSchemaResolvers; + function wrapField(field) { + const originalFieldResolve = field.resolve; + field.resolve = (source, args, context, info) => { + const parentPath = info.path.prev; + const willResolveField = context === null || context === void 0 ? void 0 : context[exports2.symbolExecutionDispatcherWillResolveField]; + const userFieldResolver = context === null || context === void 0 ? void 0 : context[exports2.symbolUserFieldResolver]; + const didResolveField = typeof willResolveField === "function" && willResolveField({ source, args, context, info }); + const resolveObject = info.parentType.resolveObject; + let whenObjectResolved; + if (parentPath && resolveObject) { + if (!parentPath.__fields) { + parentPath.__fields = {}; + } + parentPath.__fields[info.fieldName] = info.fieldNodes; + whenObjectResolved = parentPath.__whenObjectResolved; + if (!whenObjectResolved) { + whenObjectResolved = Promise.resolve().then(() => { + return resolveObject(source, parentPath.__fields, context, info); + }); + parentPath.__whenObjectResolved = whenObjectResolved; + } + } + const fieldResolver = originalFieldResolve || userFieldResolver || execution_1.defaultFieldResolver; + try { + let result; + if (whenObjectResolved) { + result = whenObjectResolved.then((resolvedObject) => { + return fieldResolver(resolvedObject, args, context, info); + }); + } else { + result = fieldResolver(source, args, context, info); + } + if (typeof didResolveField === "function") { + whenResultIsFinished(result, didResolveField); + } + return result; + } catch (error) { + if (typeof didResolveField === "function") { + didResolveField(error); + } + throw error; + } + }; + } + function isPromise(x) { + return x && typeof x.then === "function"; + } + function whenResultIsFinished(result, callback) { + if (isPromise(result)) { + result.then((r) => callback(null, r), (err) => callback(err)); + } else if (Array.isArray(result)) { + if (result.some(isPromise)) { + Promise.all(result).then((r) => callback(null, r), (err) => callback(err)); + } else { + callback(null, result); + } + } else { + callback(null, result); + } + } + exports2.whenResultIsFinished = whenResultIsFinished; + function forEachField(schema2, fn) { + const typeMap = schema2.getTypeMap(); + Object.entries(typeMap).forEach(([typeName, type]) => { + if (!(0, type_1.getNamedType)(type).name.startsWith("__") && type instanceof type_1.GraphQLObjectType) { + const fields = type.getFields(); + Object.entries(fields).forEach(([fieldName, field]) => { + fn(field, typeName, fieldName); + }); + } + }); + } + } +}); + +// node_modules/apollo-server-core/dist/utils/dispatcher.js +var require_dispatcher = __commonJS({ + "node_modules/apollo-server-core/dist/utils/dispatcher.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Dispatcher = void 0; + var Dispatcher = class { + constructor(targets) { + this.targets = targets; + } + callTargets(methodName, ...args) { + return this.targets.map((target) => { + const method = target[methodName]; + if (typeof method === "function") { + return method.apply(target, args); + } + }); + } + hasHook(methodName) { + return this.targets.some((target) => typeof target[methodName] === "function"); + } + async invokeHook(methodName, ...args) { + return Promise.all(this.callTargets(methodName, ...args)); + } + async invokeHooksUntilNonNull(methodName, ...args) { + for (const target of this.targets) { + const method = target[methodName]; + if (typeof method !== "function") { + continue; + } + const value = await method.apply(target, args); + if (value !== null) { + return value; + } + } + return null; + } + async invokeDidStartHook(methodName, ...args) { + const hookReturnValues = await Promise.all(this.callTargets(methodName, ...args)); + const didEndHooks = hookReturnValues.filter((hook) => !!hook); + didEndHooks.reverse(); + return async (...args2) => { + await Promise.all(didEndHooks.map((hook) => hook(...args2))); + }; + } + invokeSyncDidStartHook(methodName, ...args) { + const didEndHooks = []; + for (const target of this.targets) { + const method = target[methodName]; + if (typeof method === "function") { + const didEndHook = method.apply(target, args); + if (didEndHook) { + didEndHooks.push(didEndHook); + } + } + } + didEndHooks.reverse(); + return (...args2) => { + for (const didEndHook of didEndHooks) { + didEndHook(...args2); + } + }; + } + }; + exports2.Dispatcher = Dispatcher; + } +}); + +// node_modules/yallist/iterator.js +var require_iterator = __commonJS({ + "node_modules/yallist/iterator.js"(exports2, module2) { + "use strict"; + module2.exports = function(Yallist) { + Yallist.prototype[Symbol.iterator] = function* () { + for (let walker = this.head; walker; walker = walker.next) { + yield walker.value; + } + }; + }; + } +}); + +// node_modules/yallist/yallist.js +var require_yallist = __commonJS({ + "node_modules/yallist/yallist.js"(exports2, module2) { + "use strict"; + module2.exports = Yallist; + Yallist.Node = Node; + Yallist.create = Yallist; + function Yallist(list) { + var self2 = this; + if (!(self2 instanceof Yallist)) { + self2 = new Yallist(); + } + self2.tail = null; + self2.head = null; + self2.length = 0; + if (list && typeof list.forEach === "function") { + list.forEach(function(item) { + self2.push(item); + }); + } else if (arguments.length > 0) { + for (var i = 0, l = arguments.length; i < l; i++) { + self2.push(arguments[i]); + } + } + return self2; + } + Yallist.prototype.removeNode = function(node) { + if (node.list !== this) { + throw new Error("removing node which does not belong to this list"); + } + var next = node.next; + var prev = node.prev; + if (next) { + next.prev = prev; + } + if (prev) { + prev.next = next; + } + if (node === this.head) { + this.head = next; + } + if (node === this.tail) { + this.tail = prev; + } + node.list.length--; + node.next = null; + node.prev = null; + node.list = null; + return next; + }; + Yallist.prototype.unshiftNode = function(node) { + if (node === this.head) { + return; + } + if (node.list) { + node.list.removeNode(node); + } + var head = this.head; + node.list = this; + node.next = head; + if (head) { + head.prev = node; + } + this.head = node; + if (!this.tail) { + this.tail = node; + } + this.length++; + }; + Yallist.prototype.pushNode = function(node) { + if (node === this.tail) { + return; + } + if (node.list) { + node.list.removeNode(node); + } + var tail = this.tail; + node.list = this; + node.prev = tail; + if (tail) { + tail.next = node; + } + this.tail = node; + if (!this.head) { + this.head = node; + } + this.length++; + }; + Yallist.prototype.push = function() { + for (var i = 0, l = arguments.length; i < l; i++) { + push(this, arguments[i]); + } + return this.length; + }; + Yallist.prototype.unshift = function() { + for (var i = 0, l = arguments.length; i < l; i++) { + unshift(this, arguments[i]); + } + return this.length; + }; + Yallist.prototype.pop = function() { + if (!this.tail) { + return void 0; + } + var res = this.tail.value; + this.tail = this.tail.prev; + if (this.tail) { + this.tail.next = null; + } else { + this.head = null; + } + this.length--; + return res; + }; + Yallist.prototype.shift = function() { + if (!this.head) { + return void 0; + } + var res = this.head.value; + this.head = this.head.next; + if (this.head) { + this.head.prev = null; + } else { + this.tail = null; + } + this.length--; + return res; + }; + Yallist.prototype.forEach = function(fn, thisp) { + thisp = thisp || this; + for (var walker = this.head, i = 0; walker !== null; i++) { + fn.call(thisp, walker.value, i, this); + walker = walker.next; + } + }; + Yallist.prototype.forEachReverse = function(fn, thisp) { + thisp = thisp || this; + for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { + fn.call(thisp, walker.value, i, this); + walker = walker.prev; + } + }; + Yallist.prototype.get = function(n) { + for (var i = 0, walker = this.head; walker !== null && i < n; i++) { + walker = walker.next; + } + if (i === n && walker !== null) { + return walker.value; + } + }; + Yallist.prototype.getReverse = function(n) { + for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { + walker = walker.prev; + } + if (i === n && walker !== null) { + return walker.value; + } + }; + Yallist.prototype.map = function(fn, thisp) { + thisp = thisp || this; + var res = new Yallist(); + for (var walker = this.head; walker !== null; ) { + res.push(fn.call(thisp, walker.value, this)); + walker = walker.next; + } + return res; + }; + Yallist.prototype.mapReverse = function(fn, thisp) { + thisp = thisp || this; + var res = new Yallist(); + for (var walker = this.tail; walker !== null; ) { + res.push(fn.call(thisp, walker.value, this)); + walker = walker.prev; + } + return res; + }; + Yallist.prototype.reduce = function(fn, initial) { + var acc; + var walker = this.head; + if (arguments.length > 1) { + acc = initial; + } else if (this.head) { + walker = this.head.next; + acc = this.head.value; + } else { + throw new TypeError("Reduce of empty list with no initial value"); + } + for (var i = 0; walker !== null; i++) { + acc = fn(acc, walker.value, i); + walker = walker.next; + } + return acc; + }; + Yallist.prototype.reduceReverse = function(fn, initial) { + var acc; + var walker = this.tail; + if (arguments.length > 1) { + acc = initial; + } else if (this.tail) { + walker = this.tail.prev; + acc = this.tail.value; + } else { + throw new TypeError("Reduce of empty list with no initial value"); + } + for (var i = this.length - 1; walker !== null; i--) { + acc = fn(acc, walker.value, i); + walker = walker.prev; + } + return acc; + }; + Yallist.prototype.toArray = function() { + var arr = new Array(this.length); + for (var i = 0, walker = this.head; walker !== null; i++) { + arr[i] = walker.value; + walker = walker.next; + } + return arr; + }; + Yallist.prototype.toArrayReverse = function() { + var arr = new Array(this.length); + for (var i = 0, walker = this.tail; walker !== null; i++) { + arr[i] = walker.value; + walker = walker.prev; + } + return arr; + }; + Yallist.prototype.slice = function(from, to) { + to = to || this.length; + if (to < 0) { + to += this.length; + } + from = from || 0; + if (from < 0) { + from += this.length; + } + var ret = new Yallist(); + if (to < from || to < 0) { + return ret; + } + if (from < 0) { + from = 0; + } + if (to > this.length) { + to = this.length; + } + for (var i = 0, walker = this.head; walker !== null && i < from; i++) { + walker = walker.next; + } + for (; walker !== null && i < to; i++, walker = walker.next) { + ret.push(walker.value); + } + return ret; + }; + Yallist.prototype.sliceReverse = function(from, to) { + to = to || this.length; + if (to < 0) { + to += this.length; + } + from = from || 0; + if (from < 0) { + from += this.length; + } + var ret = new Yallist(); + if (to < from || to < 0) { + return ret; + } + if (from < 0) { + from = 0; + } + if (to > this.length) { + to = this.length; + } + for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { + walker = walker.prev; + } + for (; walker !== null && i > from; i--, walker = walker.prev) { + ret.push(walker.value); + } + return ret; + }; + Yallist.prototype.splice = function(start, deleteCount, ...nodes) { + if (start > this.length) { + start = this.length - 1; + } + if (start < 0) { + start = this.length + start; + } + for (var i = 0, walker = this.head; walker !== null && i < start; i++) { + walker = walker.next; + } + var ret = []; + for (var i = 0; walker && i < deleteCount; i++) { + ret.push(walker.value); + walker = this.removeNode(walker); + } + if (walker === null) { + walker = this.tail; + } + if (walker !== this.head && walker !== this.tail) { + walker = walker.prev; + } + for (var i = 0; i < nodes.length; i++) { + walker = insert(this, walker, nodes[i]); + } + return ret; + }; + Yallist.prototype.reverse = function() { + var head = this.head; + var tail = this.tail; + for (var walker = head; walker !== null; walker = walker.prev) { + var p = walker.prev; + walker.prev = walker.next; + walker.next = p; + } + this.head = tail; + this.tail = head; + return this; + }; + function insert(self2, node, value) { + var inserted = node === self2.head ? new Node(value, null, node, self2) : new Node(value, node, node.next, self2); + if (inserted.next === null) { + self2.tail = inserted; + } + if (inserted.prev === null) { + self2.head = inserted; + } + self2.length++; + return inserted; + } + function push(self2, item) { + self2.tail = new Node(item, self2.tail, null, self2); + if (!self2.head) { + self2.head = self2.tail; + } + self2.length++; + } + function unshift(self2, item) { + self2.head = new Node(item, null, self2.head, self2); + if (!self2.tail) { + self2.tail = self2.head; + } + self2.length++; + } + function Node(value, prev, next, list) { + if (!(this instanceof Node)) { + return new Node(value, prev, next, list); + } + this.list = list; + this.value = value; + if (prev) { + prev.next = this; + this.prev = prev; + } else { + this.prev = null; + } + if (next) { + next.prev = this; + this.next = next; + } else { + this.next = null; + } + } + try { + require_iterator()(Yallist); + } catch (er) { + } + } +}); + +// node_modules/lru-cache/index.js +var require_lru_cache = __commonJS({ + "node_modules/lru-cache/index.js"(exports2, module2) { + "use strict"; + var Yallist = require_yallist(); + var MAX = Symbol("max"); + var LENGTH = Symbol("length"); + var LENGTH_CALCULATOR = Symbol("lengthCalculator"); + var ALLOW_STALE = Symbol("allowStale"); + var MAX_AGE = Symbol("maxAge"); + var DISPOSE = Symbol("dispose"); + var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet"); + var LRU_LIST = Symbol("lruList"); + var CACHE = Symbol("cache"); + var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet"); + var naiveLength = () => 1; + var LRUCache = class { + constructor(options) { + if (typeof options === "number") + options = { max: options }; + if (!options) + options = {}; + if (options.max && (typeof options.max !== "number" || options.max < 0)) + throw new TypeError("max must be a non-negative number"); + const max = this[MAX] = options.max || Infinity; + const lc = options.length || naiveLength; + this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc; + this[ALLOW_STALE] = options.stale || false; + if (options.maxAge && typeof options.maxAge !== "number") + throw new TypeError("maxAge must be a number"); + this[MAX_AGE] = options.maxAge || 0; + this[DISPOSE] = options.dispose; + this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false; + this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false; + this.reset(); + } + set max(mL) { + if (typeof mL !== "number" || mL < 0) + throw new TypeError("max must be a non-negative number"); + this[MAX] = mL || Infinity; + trim(this); + } + get max() { + return this[MAX]; + } + set allowStale(allowStale) { + this[ALLOW_STALE] = !!allowStale; + } + get allowStale() { + return this[ALLOW_STALE]; + } + set maxAge(mA) { + if (typeof mA !== "number") + throw new TypeError("maxAge must be a non-negative number"); + this[MAX_AGE] = mA; + trim(this); + } + get maxAge() { + return this[MAX_AGE]; + } + set lengthCalculator(lC) { + if (typeof lC !== "function") + lC = naiveLength; + if (lC !== this[LENGTH_CALCULATOR]) { + this[LENGTH_CALCULATOR] = lC; + this[LENGTH] = 0; + this[LRU_LIST].forEach((hit) => { + hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key); + this[LENGTH] += hit.length; + }); + } + trim(this); + } + get lengthCalculator() { + return this[LENGTH_CALCULATOR]; + } + get length() { + return this[LENGTH]; + } + get itemCount() { + return this[LRU_LIST].length; + } + rforEach(fn, thisp) { + thisp = thisp || this; + for (let walker = this[LRU_LIST].tail; walker !== null; ) { + const prev = walker.prev; + forEachStep(this, fn, walker, thisp); + walker = prev; + } + } + forEach(fn, thisp) { + thisp = thisp || this; + for (let walker = this[LRU_LIST].head; walker !== null; ) { + const next = walker.next; + forEachStep(this, fn, walker, thisp); + walker = next; + } + } + keys() { + return this[LRU_LIST].toArray().map((k) => k.key); + } + values() { + return this[LRU_LIST].toArray().map((k) => k.value); + } + reset() { + if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) { + this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value)); + } + this[CACHE] = new Map(); + this[LRU_LIST] = new Yallist(); + this[LENGTH] = 0; + } + dump() { + return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : { + k: hit.key, + v: hit.value, + e: hit.now + (hit.maxAge || 0) + }).toArray().filter((h) => h); + } + dumpLru() { + return this[LRU_LIST]; + } + set(key, value, maxAge) { + maxAge = maxAge || this[MAX_AGE]; + if (maxAge && typeof maxAge !== "number") + throw new TypeError("maxAge must be a number"); + const now = maxAge ? Date.now() : 0; + const len = this[LENGTH_CALCULATOR](value, key); + if (this[CACHE].has(key)) { + if (len > this[MAX]) { + del(this, this[CACHE].get(key)); + return false; + } + const node = this[CACHE].get(key); + const item = node.value; + if (this[DISPOSE]) { + if (!this[NO_DISPOSE_ON_SET]) + this[DISPOSE](key, item.value); + } + item.now = now; + item.maxAge = maxAge; + item.value = value; + this[LENGTH] += len - item.length; + item.length = len; + this.get(key); + trim(this); + return true; + } + const hit = new Entry(key, value, len, now, maxAge); + if (hit.length > this[MAX]) { + if (this[DISPOSE]) + this[DISPOSE](key, value); + return false; + } + this[LENGTH] += hit.length; + this[LRU_LIST].unshift(hit); + this[CACHE].set(key, this[LRU_LIST].head); + trim(this); + return true; + } + has(key) { + if (!this[CACHE].has(key)) + return false; + const hit = this[CACHE].get(key).value; + return !isStale(this, hit); + } + get(key) { + return get(this, key, true); + } + peek(key) { + return get(this, key, false); + } + pop() { + const node = this[LRU_LIST].tail; + if (!node) + return null; + del(this, node); + return node.value; + } + del(key) { + del(this, this[CACHE].get(key)); + } + load(arr) { + this.reset(); + const now = Date.now(); + for (let l = arr.length - 1; l >= 0; l--) { + const hit = arr[l]; + const expiresAt = hit.e || 0; + if (expiresAt === 0) + this.set(hit.k, hit.v); + else { + const maxAge = expiresAt - now; + if (maxAge > 0) { + this.set(hit.k, hit.v, maxAge); + } + } + } + } + prune() { + this[CACHE].forEach((value, key) => get(this, key, false)); + } + }; + var get = (self2, key, doUse) => { + const node = self2[CACHE].get(key); + if (node) { + const hit = node.value; + if (isStale(self2, hit)) { + del(self2, node); + if (!self2[ALLOW_STALE]) + return void 0; + } else { + if (doUse) { + if (self2[UPDATE_AGE_ON_GET]) + node.value.now = Date.now(); + self2[LRU_LIST].unshiftNode(node); + } + } + return hit.value; + } + }; + var isStale = (self2, hit) => { + if (!hit || !hit.maxAge && !self2[MAX_AGE]) + return false; + const diff = Date.now() - hit.now; + return hit.maxAge ? diff > hit.maxAge : self2[MAX_AGE] && diff > self2[MAX_AGE]; + }; + var trim = (self2) => { + if (self2[LENGTH] > self2[MAX]) { + for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) { + const prev = walker.prev; + del(self2, walker); + walker = prev; + } + } + }; + var del = (self2, node) => { + if (node) { + const hit = node.value; + if (self2[DISPOSE]) + self2[DISPOSE](hit.key, hit.value); + self2[LENGTH] -= hit.length; + self2[CACHE].delete(hit.key); + self2[LRU_LIST].removeNode(node); + } + }; + var Entry = class { + constructor(key, value, length, now, maxAge) { + this.key = key; + this.value = value; + this.length = length; + this.now = now; + this.maxAge = maxAge || 0; + } + }; + var forEachStep = (self2, fn, node, thisp) => { + let hit = node.value; + if (isStale(self2, hit)) { + del(self2, node); + if (!self2[ALLOW_STALE]) + hit = void 0; + } + if (hit) + fn.call(thisp, hit.value, hit.key, self2); + }; + module2.exports = LRUCache; + } +}); + +// node_modules/apollo-server-caching/dist/InMemoryLRUCache.js +var require_InMemoryLRUCache = __commonJS({ + "node_modules/apollo-server-caching/dist/InMemoryLRUCache.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.InMemoryLRUCache = void 0; + var lru_cache_1 = __importDefault(require_lru_cache()); + function defaultLengthCalculation(item) { + if (Array.isArray(item) || typeof item === "string") { + return item.length; + } + return 1; + } + var InMemoryLRUCache = class { + constructor({ maxSize = Infinity, sizeCalculator = defaultLengthCalculation, onDispose } = {}) { + this.store = new lru_cache_1.default({ + max: maxSize, + length: sizeCalculator, + dispose: onDispose + }); + } + async get(key) { + return this.store.get(key); + } + async set(key, value, options) { + const maxAge = (options === null || options === void 0 ? void 0 : options.ttl) && options.ttl * 1e3; + this.store.set(key, value, maxAge); + } + async delete(key) { + this.store.del(key); + } + async flush() { + this.store.reset(); + } + async getTotalSize() { + return this.store.length; + } + static jsonBytesSizeCalculator(obj) { + return Buffer.byteLength(JSON.stringify(obj), "utf8"); + } + }; + exports2.InMemoryLRUCache = InMemoryLRUCache; + } +}); + +// node_modules/apollo-server-caching/dist/PrefixingKeyValueCache.js +var require_PrefixingKeyValueCache = __commonJS({ + "node_modules/apollo-server-caching/dist/PrefixingKeyValueCache.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.PrefixingKeyValueCache = void 0; + var PrefixingKeyValueCache = class { + constructor(wrapped, prefix) { + this.wrapped = wrapped; + this.prefix = prefix; + } + get(key) { + return this.wrapped.get(this.prefix + key); + } + set(key, value, options) { + return this.wrapped.set(this.prefix + key, value, options); + } + delete(key) { + return this.wrapped.delete(this.prefix + key); + } + }; + exports2.PrefixingKeyValueCache = PrefixingKeyValueCache; + } +}); + +// node_modules/apollo-server-caching/dist/testsuite.js +var require_testsuite = __commonJS({ + "node_modules/apollo-server-caching/dist/testsuite.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.runKeyValueCacheTests = void 0; + async function runKeyValueCacheTests(keyValueCache, tick) { + await keyValueCache.set("hello", "world"); + assertEqual(await keyValueCache.get("hello"), "world"); + assertEqual(await keyValueCache.get("missing"), void 0); + await keyValueCache.set("hello2", "world"); + assertEqual(await keyValueCache.get("hello2"), "world"); + await keyValueCache.delete("hello2"); + assertEqual(await keyValueCache.get("hello2"), void 0); + if (tick) { + await keyValueCache.set("short", "s", { ttl: 1 }); + await keyValueCache.set("long", "l", { ttl: 5 }); + assertEqual(await keyValueCache.get("short"), "s"); + assertEqual(await keyValueCache.get("long"), "l"); + tick(1500); + assertEqual(await keyValueCache.get("short"), void 0); + assertEqual(await keyValueCache.get("long"), "l"); + tick(4e3); + assertEqual(await keyValueCache.get("short"), void 0); + assertEqual(await keyValueCache.get("long"), void 0); + await keyValueCache.set("forever", "yours", { ttl: null }); + assertEqual(await keyValueCache.get("forever"), "yours"); + tick(1500); + assertEqual(await keyValueCache.get("forever"), "yours"); + tick(4e3); + assertEqual(await keyValueCache.get("forever"), "yours"); + } + } + exports2.runKeyValueCacheTests = runKeyValueCacheTests; + function assertEqual(actual, expected) { + if (actual === expected) { + return; + } + throw Error(`Expected ${actual} to equal ${expected}`); + } + } +}); + +// node_modules/apollo-server-caching/dist/index.js +var require_dist3 = __commonJS({ + "node_modules/apollo-server-caching/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.runKeyValueCacheTests = exports2.PrefixingKeyValueCache = exports2.InMemoryLRUCache = void 0; + var InMemoryLRUCache_1 = require_InMemoryLRUCache(); + Object.defineProperty(exports2, "InMemoryLRUCache", { enumerable: true, get: function() { + return InMemoryLRUCache_1.InMemoryLRUCache; + } }); + var PrefixingKeyValueCache_1 = require_PrefixingKeyValueCache(); + Object.defineProperty(exports2, "PrefixingKeyValueCache", { enumerable: true, get: function() { + return PrefixingKeyValueCache_1.PrefixingKeyValueCache; + } }); + var testsuite_1 = require_testsuite(); + Object.defineProperty(exports2, "runKeyValueCacheTests", { enumerable: true, get: function() { + return testsuite_1.runKeyValueCacheTests; + } }); + } +}); + +// node_modules/apollo-server-core/dist/utils/isNodeLike.js +var require_isNodeLike = __commonJS({ + "node_modules/apollo-server-core/dist/utils/isNodeLike.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.default = typeof process === "object" && process && process.release && process.versions && typeof process.versions.node === "string"; + } +}); + +// node_modules/inherits/inherits_browser.js +var require_inherits_browser = __commonJS({ + "node_modules/inherits/inherits_browser.js"(exports2, module2) { + if (typeof Object.create === "function") { + module2.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + } + }; + } else { + module2.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + }; + } + } +}); + +// node_modules/inherits/inherits.js +var require_inherits = __commonJS({ + "node_modules/inherits/inherits.js"(exports2, module2) { + try { + util = require("util"); + if (typeof util.inherits !== "function") + throw ""; + module2.exports = util.inherits; + } catch (e) { + module2.exports = require_inherits_browser(); + } + var util; + } +}); + +// node_modules/safe-buffer/index.js +var require_safe_buffer = __commonJS({ + "node_modules/safe-buffer/index.js"(exports2, module2) { + var buffer = require("buffer"); + var Buffer2 = buffer.Buffer; + function copyProps(src, dst) { + for (var key in src) { + dst[key] = src[key]; + } + } + if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) { + module2.exports = buffer; + } else { + copyProps(buffer, exports2); + exports2.Buffer = SafeBuffer; + } + function SafeBuffer(arg, encodingOrOffset, length) { + return Buffer2(arg, encodingOrOffset, length); + } + SafeBuffer.prototype = Object.create(Buffer2.prototype); + copyProps(Buffer2, SafeBuffer); + SafeBuffer.from = function(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + throw new TypeError("Argument must not be a number"); + } + return Buffer2(arg, encodingOrOffset, length); + }; + SafeBuffer.alloc = function(size, fill, encoding) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + var buf = Buffer2(size); + if (fill !== void 0) { + if (typeof encoding === "string") { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + } else { + buf.fill(0); + } + return buf; + }; + SafeBuffer.allocUnsafe = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return Buffer2(size); + }; + SafeBuffer.allocUnsafeSlow = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return buffer.SlowBuffer(size); + }; + } +}); + +// node_modules/sha.js/hash.js +var require_hash = __commonJS({ + "node_modules/sha.js/hash.js"(exports2, module2) { + var Buffer2 = require_safe_buffer().Buffer; + function Hash(blockSize, finalSize) { + this._block = Buffer2.alloc(blockSize); + this._finalSize = finalSize; + this._blockSize = blockSize; + this._len = 0; + } + Hash.prototype.update = function(data, enc) { + if (typeof data === "string") { + enc = enc || "utf8"; + data = Buffer2.from(data, enc); + } + var block = this._block; + var blockSize = this._blockSize; + var length = data.length; + var accum = this._len; + for (var offset = 0; offset < length; ) { + var assigned = accum % blockSize; + var remainder = Math.min(length - offset, blockSize - assigned); + for (var i = 0; i < remainder; i++) { + block[assigned + i] = data[offset + i]; + } + accum += remainder; + offset += remainder; + if (accum % blockSize === 0) { + this._update(block); + } + } + this._len += length; + return this; + }; + Hash.prototype.digest = function(enc) { + var rem = this._len % this._blockSize; + this._block[rem] = 128; + this._block.fill(0, rem + 1); + if (rem >= this._finalSize) { + this._update(this._block); + this._block.fill(0); + } + var bits = this._len * 8; + if (bits <= 4294967295) { + this._block.writeUInt32BE(bits, this._blockSize - 4); + } else { + var lowBits = (bits & 4294967295) >>> 0; + var highBits = (bits - lowBits) / 4294967296; + this._block.writeUInt32BE(highBits, this._blockSize - 8); + this._block.writeUInt32BE(lowBits, this._blockSize - 4); + } + this._update(this._block); + var hash = this._hash(); + return enc ? hash.toString(enc) : hash; + }; + Hash.prototype._update = function() { + throw new Error("_update must be implemented by subclass"); + }; + module2.exports = Hash; + } +}); + +// node_modules/sha.js/sha.js +var require_sha = __commonJS({ + "node_modules/sha.js/sha.js"(exports2, module2) { + var inherits = require_inherits(); + var Hash = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var K = [ + 1518500249, + 1859775393, + 2400959708 | 0, + 3395469782 | 0 + ]; + var W = new Array(80); + function Sha() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha, Hash); + Sha.prototype.init = function() { + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + this._e = 3285377520; + return this; + }; + function rotl5(num) { + return num << 5 | num >>> 27; + } + function rotl30(num) { + return num << 30 | num >>> 2; + } + function ft(s, b, c, d) { + if (s === 0) + return b & c | ~b & d; + if (s === 2) + return b & c | b & d | c & d; + return b ^ c ^ d; + } + Sha.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + for (var i = 0; i < 16; ++i) + W2[i] = M.readInt32BE(i * 4); + for (; i < 80; ++i) + W2[i] = W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]; + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20); + var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0; + e = d; + d = c; + c = rotl30(b); + b = a; + a = t; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + }; + Sha.prototype._hash = function() { + var H = Buffer2.allocUnsafe(20); + H.writeInt32BE(this._a | 0, 0); + H.writeInt32BE(this._b | 0, 4); + H.writeInt32BE(this._c | 0, 8); + H.writeInt32BE(this._d | 0, 12); + H.writeInt32BE(this._e | 0, 16); + return H; + }; + module2.exports = Sha; + } +}); + +// node_modules/sha.js/sha1.js +var require_sha1 = __commonJS({ + "node_modules/sha.js/sha1.js"(exports2, module2) { + var inherits = require_inherits(); + var Hash = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var K = [ + 1518500249, + 1859775393, + 2400959708 | 0, + 3395469782 | 0 + ]; + var W = new Array(80); + function Sha1() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha1, Hash); + Sha1.prototype.init = function() { + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + this._e = 3285377520; + return this; + }; + function rotl1(num) { + return num << 1 | num >>> 31; + } + function rotl5(num) { + return num << 5 | num >>> 27; + } + function rotl30(num) { + return num << 30 | num >>> 2; + } + function ft(s, b, c, d) { + if (s === 0) + return b & c | ~b & d; + if (s === 2) + return b & c | b & d | c & d; + return b ^ c ^ d; + } + Sha1.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + for (var i = 0; i < 16; ++i) + W2[i] = M.readInt32BE(i * 4); + for (; i < 80; ++i) + W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]); + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20); + var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0; + e = d; + d = c; + c = rotl30(b); + b = a; + a = t; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + }; + Sha1.prototype._hash = function() { + var H = Buffer2.allocUnsafe(20); + H.writeInt32BE(this._a | 0, 0); + H.writeInt32BE(this._b | 0, 4); + H.writeInt32BE(this._c | 0, 8); + H.writeInt32BE(this._d | 0, 12); + H.writeInt32BE(this._e | 0, 16); + return H; + }; + module2.exports = Sha1; + } +}); + +// node_modules/sha.js/sha256.js +var require_sha256 = __commonJS({ + "node_modules/sha.js/sha256.js"(exports2, module2) { + var inherits = require_inherits(); + var Hash = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var K = [ + 1116352408, + 1899447441, + 3049323471, + 3921009573, + 961987163, + 1508970993, + 2453635748, + 2870763221, + 3624381080, + 310598401, + 607225278, + 1426881987, + 1925078388, + 2162078206, + 2614888103, + 3248222580, + 3835390401, + 4022224774, + 264347078, + 604807628, + 770255983, + 1249150122, + 1555081692, + 1996064986, + 2554220882, + 2821834349, + 2952996808, + 3210313671, + 3336571891, + 3584528711, + 113926993, + 338241895, + 666307205, + 773529912, + 1294757372, + 1396182291, + 1695183700, + 1986661051, + 2177026350, + 2456956037, + 2730485921, + 2820302411, + 3259730800, + 3345764771, + 3516065817, + 3600352804, + 4094571909, + 275423344, + 430227734, + 506948616, + 659060556, + 883997877, + 958139571, + 1322822218, + 1537002063, + 1747873779, + 1955562222, + 2024104815, + 2227730452, + 2361852424, + 2428436474, + 2756734187, + 3204031479, + 3329325298 + ]; + var W = new Array(64); + function Sha256() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha256, Hash); + Sha256.prototype.init = function() { + this._a = 1779033703; + this._b = 3144134277; + this._c = 1013904242; + this._d = 2773480762; + this._e = 1359893119; + this._f = 2600822924; + this._g = 528734635; + this._h = 1541459225; + return this; + }; + function ch(x, y, z) { + return z ^ x & (y ^ z); + } + function maj(x, y, z) { + return x & y | z & (x | y); + } + function sigma0(x) { + return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10); + } + function sigma1(x) { + return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7); + } + function gamma0(x) { + return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3; + } + function gamma1(x) { + return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10; + } + Sha256.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + var f = this._f | 0; + var g = this._g | 0; + var h = this._h | 0; + for (var i = 0; i < 16; ++i) + W2[i] = M.readInt32BE(i * 4); + for (; i < 64; ++i) + W2[i] = gamma1(W2[i - 2]) + W2[i - 7] + gamma0(W2[i - 15]) + W2[i - 16] | 0; + for (var j = 0; j < 64; ++j) { + var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W2[j] | 0; + var T2 = sigma0(a) + maj(a, b, c) | 0; + h = g; + g = f; + f = e; + e = d + T1 | 0; + d = c; + c = b; + b = a; + a = T1 + T2 | 0; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + this._f = f + this._f | 0; + this._g = g + this._g | 0; + this._h = h + this._h | 0; + }; + Sha256.prototype._hash = function() { + var H = Buffer2.allocUnsafe(32); + H.writeInt32BE(this._a, 0); + H.writeInt32BE(this._b, 4); + H.writeInt32BE(this._c, 8); + H.writeInt32BE(this._d, 12); + H.writeInt32BE(this._e, 16); + H.writeInt32BE(this._f, 20); + H.writeInt32BE(this._g, 24); + H.writeInt32BE(this._h, 28); + return H; + }; + module2.exports = Sha256; + } +}); + +// node_modules/sha.js/sha224.js +var require_sha224 = __commonJS({ + "node_modules/sha.js/sha224.js"(exports2, module2) { + var inherits = require_inherits(); + var Sha256 = require_sha256(); + var Hash = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var W = new Array(64); + function Sha224() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha224, Sha256); + Sha224.prototype.init = function() { + this._a = 3238371032; + this._b = 914150663; + this._c = 812702999; + this._d = 4144912697; + this._e = 4290775857; + this._f = 1750603025; + this._g = 1694076839; + this._h = 3204075428; + return this; + }; + Sha224.prototype._hash = function() { + var H = Buffer2.allocUnsafe(28); + H.writeInt32BE(this._a, 0); + H.writeInt32BE(this._b, 4); + H.writeInt32BE(this._c, 8); + H.writeInt32BE(this._d, 12); + H.writeInt32BE(this._e, 16); + H.writeInt32BE(this._f, 20); + H.writeInt32BE(this._g, 24); + return H; + }; + module2.exports = Sha224; + } +}); + +// node_modules/sha.js/sha512.js +var require_sha512 = __commonJS({ + "node_modules/sha.js/sha512.js"(exports2, module2) { + var inherits = require_inherits(); + var Hash = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var K = [ + 1116352408, + 3609767458, + 1899447441, + 602891725, + 3049323471, + 3964484399, + 3921009573, + 2173295548, + 961987163, + 4081628472, + 1508970993, + 3053834265, + 2453635748, + 2937671579, + 2870763221, + 3664609560, + 3624381080, + 2734883394, + 310598401, + 1164996542, + 607225278, + 1323610764, + 1426881987, + 3590304994, + 1925078388, + 4068182383, + 2162078206, + 991336113, + 2614888103, + 633803317, + 3248222580, + 3479774868, + 3835390401, + 2666613458, + 4022224774, + 944711139, + 264347078, + 2341262773, + 604807628, + 2007800933, + 770255983, + 1495990901, + 1249150122, + 1856431235, + 1555081692, + 3175218132, + 1996064986, + 2198950837, + 2554220882, + 3999719339, + 2821834349, + 766784016, + 2952996808, + 2566594879, + 3210313671, + 3203337956, + 3336571891, + 1034457026, + 3584528711, + 2466948901, + 113926993, + 3758326383, + 338241895, + 168717936, + 666307205, + 1188179964, + 773529912, + 1546045734, + 1294757372, + 1522805485, + 1396182291, + 2643833823, + 1695183700, + 2343527390, + 1986661051, + 1014477480, + 2177026350, + 1206759142, + 2456956037, + 344077627, + 2730485921, + 1290863460, + 2820302411, + 3158454273, + 3259730800, + 3505952657, + 3345764771, + 106217008, + 3516065817, + 3606008344, + 3600352804, + 1432725776, + 4094571909, + 1467031594, + 275423344, + 851169720, + 430227734, + 3100823752, + 506948616, + 1363258195, + 659060556, + 3750685593, + 883997877, + 3785050280, + 958139571, + 3318307427, + 1322822218, + 3812723403, + 1537002063, + 2003034995, + 1747873779, + 3602036899, + 1955562222, + 1575990012, + 2024104815, + 1125592928, + 2227730452, + 2716904306, + 2361852424, + 442776044, + 2428436474, + 593698344, + 2756734187, + 3733110249, + 3204031479, + 2999351573, + 3329325298, + 3815920427, + 3391569614, + 3928383900, + 3515267271, + 566280711, + 3940187606, + 3454069534, + 4118630271, + 4000239992, + 116418474, + 1914138554, + 174292421, + 2731055270, + 289380356, + 3203993006, + 460393269, + 320620315, + 685471733, + 587496836, + 852142971, + 1086792851, + 1017036298, + 365543100, + 1126000580, + 2618297676, + 1288033470, + 3409855158, + 1501505948, + 4234509866, + 1607167915, + 987167468, + 1816402316, + 1246189591 + ]; + var W = new Array(160); + function Sha512() { + this.init(); + this._w = W; + Hash.call(this, 128, 112); + } + inherits(Sha512, Hash); + Sha512.prototype.init = function() { + this._ah = 1779033703; + this._bh = 3144134277; + this._ch = 1013904242; + this._dh = 2773480762; + this._eh = 1359893119; + this._fh = 2600822924; + this._gh = 528734635; + this._hh = 1541459225; + this._al = 4089235720; + this._bl = 2227873595; + this._cl = 4271175723; + this._dl = 1595750129; + this._el = 2917565137; + this._fl = 725511199; + this._gl = 4215389547; + this._hl = 327033209; + return this; + }; + function Ch(x, y, z) { + return z ^ x & (y ^ z); + } + function maj(x, y, z) { + return x & y | z & (x | y); + } + function sigma0(x, xl) { + return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25); + } + function sigma1(x, xl) { + return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23); + } + function Gamma0(x, xl) { + return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7; + } + function Gamma0l(x, xl) { + return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25); + } + function Gamma1(x, xl) { + return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6; + } + function Gamma1l(x, xl) { + return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26); + } + function getCarry(a, b) { + return a >>> 0 < b >>> 0 ? 1 : 0; + } + Sha512.prototype._update = function(M) { + var W2 = this._w; + var ah = this._ah | 0; + var bh = this._bh | 0; + var ch = this._ch | 0; + var dh = this._dh | 0; + var eh = this._eh | 0; + var fh = this._fh | 0; + var gh = this._gh | 0; + var hh = this._hh | 0; + var al = this._al | 0; + var bl = this._bl | 0; + var cl = this._cl | 0; + var dl = this._dl | 0; + var el = this._el | 0; + var fl = this._fl | 0; + var gl = this._gl | 0; + var hl = this._hl | 0; + for (var i = 0; i < 32; i += 2) { + W2[i] = M.readInt32BE(i * 4); + W2[i + 1] = M.readInt32BE(i * 4 + 4); + } + for (; i < 160; i += 2) { + var xh = W2[i - 15 * 2]; + var xl = W2[i - 15 * 2 + 1]; + var gamma0 = Gamma0(xh, xl); + var gamma0l = Gamma0l(xl, xh); + xh = W2[i - 2 * 2]; + xl = W2[i - 2 * 2 + 1]; + var gamma1 = Gamma1(xh, xl); + var gamma1l = Gamma1l(xl, xh); + var Wi7h = W2[i - 7 * 2]; + var Wi7l = W2[i - 7 * 2 + 1]; + var Wi16h = W2[i - 16 * 2]; + var Wi16l = W2[i - 16 * 2 + 1]; + var Wil = gamma0l + Wi7l | 0; + var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0; + Wil = Wil + gamma1l | 0; + Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0; + Wil = Wil + Wi16l | 0; + Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0; + W2[i] = Wih; + W2[i + 1] = Wil; + } + for (var j = 0; j < 160; j += 2) { + Wih = W2[j]; + Wil = W2[j + 1]; + var majh = maj(ah, bh, ch); + var majl = maj(al, bl, cl); + var sigma0h = sigma0(ah, al); + var sigma0l = sigma0(al, ah); + var sigma1h = sigma1(eh, el); + var sigma1l = sigma1(el, eh); + var Kih = K[j]; + var Kil = K[j + 1]; + var chh = Ch(eh, fh, gh); + var chl = Ch(el, fl, gl); + var t1l = hl + sigma1l | 0; + var t1h = hh + sigma1h + getCarry(t1l, hl) | 0; + t1l = t1l + chl | 0; + t1h = t1h + chh + getCarry(t1l, chl) | 0; + t1l = t1l + Kil | 0; + t1h = t1h + Kih + getCarry(t1l, Kil) | 0; + t1l = t1l + Wil | 0; + t1h = t1h + Wih + getCarry(t1l, Wil) | 0; + var t2l = sigma0l + majl | 0; + var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0; + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + el = dl + t1l | 0; + eh = dh + t1h + getCarry(el, dl) | 0; + dh = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + al = t1l + t2l | 0; + ah = t1h + t2h + getCarry(al, t1l) | 0; + } + this._al = this._al + al | 0; + this._bl = this._bl + bl | 0; + this._cl = this._cl + cl | 0; + this._dl = this._dl + dl | 0; + this._el = this._el + el | 0; + this._fl = this._fl + fl | 0; + this._gl = this._gl + gl | 0; + this._hl = this._hl + hl | 0; + this._ah = this._ah + ah + getCarry(this._al, al) | 0; + this._bh = this._bh + bh + getCarry(this._bl, bl) | 0; + this._ch = this._ch + ch + getCarry(this._cl, cl) | 0; + this._dh = this._dh + dh + getCarry(this._dl, dl) | 0; + this._eh = this._eh + eh + getCarry(this._el, el) | 0; + this._fh = this._fh + fh + getCarry(this._fl, fl) | 0; + this._gh = this._gh + gh + getCarry(this._gl, gl) | 0; + this._hh = this._hh + hh + getCarry(this._hl, hl) | 0; + }; + Sha512.prototype._hash = function() { + var H = Buffer2.allocUnsafe(64); + function writeInt64BE(h, l, offset) { + H.writeInt32BE(h, offset); + H.writeInt32BE(l, offset + 4); + } + writeInt64BE(this._ah, this._al, 0); + writeInt64BE(this._bh, this._bl, 8); + writeInt64BE(this._ch, this._cl, 16); + writeInt64BE(this._dh, this._dl, 24); + writeInt64BE(this._eh, this._el, 32); + writeInt64BE(this._fh, this._fl, 40); + writeInt64BE(this._gh, this._gl, 48); + writeInt64BE(this._hh, this._hl, 56); + return H; + }; + module2.exports = Sha512; + } +}); + +// node_modules/sha.js/sha384.js +var require_sha384 = __commonJS({ + "node_modules/sha.js/sha384.js"(exports2, module2) { + var inherits = require_inherits(); + var SHA512 = require_sha512(); + var Hash = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var W = new Array(160); + function Sha384() { + this.init(); + this._w = W; + Hash.call(this, 128, 112); + } + inherits(Sha384, SHA512); + Sha384.prototype.init = function() { + this._ah = 3418070365; + this._bh = 1654270250; + this._ch = 2438529370; + this._dh = 355462360; + this._eh = 1731405415; + this._fh = 2394180231; + this._gh = 3675008525; + this._hh = 1203062813; + this._al = 3238371032; + this._bl = 914150663; + this._cl = 812702999; + this._dl = 4144912697; + this._el = 4290775857; + this._fl = 1750603025; + this._gl = 1694076839; + this._hl = 3204075428; + return this; + }; + Sha384.prototype._hash = function() { + var H = Buffer2.allocUnsafe(48); + function writeInt64BE(h, l, offset) { + H.writeInt32BE(h, offset); + H.writeInt32BE(l, offset + 4); + } + writeInt64BE(this._ah, this._al, 0); + writeInt64BE(this._bh, this._bl, 8); + writeInt64BE(this._ch, this._cl, 16); + writeInt64BE(this._dh, this._dl, 24); + writeInt64BE(this._eh, this._el, 32); + writeInt64BE(this._fh, this._fl, 40); + return H; + }; + module2.exports = Sha384; + } +}); + +// node_modules/sha.js/index.js +var require_sha2 = __commonJS({ + "node_modules/sha.js/index.js"(exports2, module2) { + var exports2 = module2.exports = function SHA(algorithm) { + algorithm = algorithm.toLowerCase(); + var Algorithm = exports2[algorithm]; + if (!Algorithm) + throw new Error(algorithm + " is not supported (we accept pull requests)"); + return new Algorithm(); + }; + exports2.sha = require_sha(); + exports2.sha1 = require_sha1(); + exports2.sha224 = require_sha224(); + exports2.sha256 = require_sha256(); + exports2.sha384 = require_sha384(); + exports2.sha512 = require_sha512(); + } +}); + +// node_modules/apollo-server-core/dist/utils/createSHA.js +var require_createSHA = __commonJS({ + "node_modules/apollo-server-core/dist/utils/createSHA.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + var isNodeLike_1 = __importDefault(require_isNodeLike()); + function default_1(kind) { + if (isNodeLike_1.default) { + return require("crypto").createHash(kind); + } + return require_sha2()(kind); + } + exports2.default = default_1; + } +}); + +// node_modules/apollo-server-core/dist/requestPipeline.js +var require_requestPipeline = __commonJS({ + "node_modules/apollo-server-core/dist/requestPipeline.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.processGraphQLRequest = exports2.APQ_CACHE_PREFIX = void 0; + var graphql_1 = require_graphql2(); + var schemaInstrumentation_1 = require_schemaInstrumentation(); + var apollo_server_errors_1 = require_dist2(); + var dispatcher_1 = require_dispatcher(); + var apollo_server_caching_1 = require_dist3(); + var createSHA_1 = __importDefault(require_createSHA()); + var runHttpQuery_1 = require_runHttpQuery(); + var apollo_server_env_1 = require_dist(); + exports2.APQ_CACHE_PREFIX = "apq:"; + function computeQueryHash(query) { + return (0, createSHA_1.default)("sha256").update(query).digest("hex"); + } + function isBadUserInputGraphQLError(error) { + var _a; + return ((_a = error.nodes) === null || _a === void 0 ? void 0 : _a.length) === 1 && error.nodes[0].kind === graphql_1.Kind.VARIABLE_DEFINITION && (error.message.startsWith(`Variable "$${error.nodes[0].variable.name.value}" got invalid value `) || error.message.startsWith(`Variable "$${error.nodes[0].variable.name.value}" of required type `) || error.message.startsWith(`Variable "$${error.nodes[0].variable.name.value}" of non-null type `)); + } + async function processGraphQLRequest(config, requestContext) { + var _a, _b, _c; + const logger = requestContext.logger || console; + const metrics = requestContext.metrics = requestContext.metrics || Object.create(null); + const dispatcher = await initializeRequestListenerDispatcher(); + await initializeDataSources(); + const request = requestContext.request; + let { query, extensions } = request; + let queryHash; + let persistedQueryCache; + metrics.persistedQueryHit = false; + metrics.persistedQueryRegister = false; + if (extensions === null || extensions === void 0 ? void 0 : extensions.persistedQuery) { + if (!config.persistedQueries || !config.persistedQueries.cache) { + return await sendErrorResponse(new apollo_server_errors_1.PersistedQueryNotSupportedError()); + } else if (extensions.persistedQuery.version !== 1) { + return await sendErrorResponse(new graphql_1.GraphQLError("Unsupported persisted query version")); + } + persistedQueryCache = config.persistedQueries.cache; + if (!(persistedQueryCache instanceof apollo_server_caching_1.PrefixingKeyValueCache)) { + persistedQueryCache = new apollo_server_caching_1.PrefixingKeyValueCache(persistedQueryCache, exports2.APQ_CACHE_PREFIX); + } + queryHash = extensions.persistedQuery.sha256Hash; + if (query === void 0) { + query = await persistedQueryCache.get(queryHash); + if (query) { + metrics.persistedQueryHit = true; + } else { + return await sendErrorResponse(new apollo_server_errors_1.PersistedQueryNotFoundError()); + } + } else { + const computedQueryHash = computeQueryHash(query); + if (queryHash !== computedQueryHash) { + return await sendErrorResponse(new graphql_1.GraphQLError("provided sha does not match query")); + } + metrics.persistedQueryRegister = true; + } + } else if (query) { + queryHash = computeQueryHash(query); + } else { + return await sendErrorResponse(new graphql_1.GraphQLError("GraphQL operations must contain a non-empty `query` or a `persistedQuery` extension.")); + } + requestContext.queryHash = queryHash; + requestContext.source = query; + await dispatcher.invokeHook("didResolveSource", requestContext); + if (config.documentStore) { + try { + requestContext.document = await config.documentStore.get(queryHash); + } catch (err) { + logger.warn("An error occurred while attempting to read from the documentStore. " + ((_a = err) === null || _a === void 0 ? void 0 : _a.message) || err); + } + } + if (!requestContext.document) { + const parsingDidEnd = await dispatcher.invokeDidStartHook("parsingDidStart", requestContext); + try { + requestContext.document = parse(query, config.parseOptions); + parsingDidEnd(); + } catch (syntaxError) { + await parsingDidEnd(syntaxError); + return await sendErrorResponse(syntaxError, apollo_server_errors_1.SyntaxError); + } + const validationDidEnd = await dispatcher.invokeDidStartHook("validationDidStart", requestContext); + const validationErrors = validate(requestContext.document); + if (validationErrors.length === 0) { + await validationDidEnd(); + } else { + await validationDidEnd(validationErrors); + return await sendErrorResponse(validationErrors, apollo_server_errors_1.ValidationError); + } + if (config.documentStore) { + Promise.resolve(config.documentStore.set(queryHash, requestContext.document)).catch((err) => logger.warn("Could not store validated document. " + (err === null || err === void 0 ? void 0 : err.message) || err)); + } + } + const operation = (0, graphql_1.getOperationAST)(requestContext.document, request.operationName); + requestContext.operation = operation || void 0; + requestContext.operationName = ((_b = operation === null || operation === void 0 ? void 0 : operation.name) === null || _b === void 0 ? void 0 : _b.value) || null; + try { + await dispatcher.invokeHook("didResolveOperation", requestContext); + } catch (err) { + return await sendErrorResponse(err); + } + if (metrics.persistedQueryRegister && persistedQueryCache) { + Promise.resolve(persistedQueryCache.set(queryHash, query, config.persistedQueries && typeof config.persistedQueries.ttl !== "undefined" ? { + ttl: config.persistedQueries.ttl + } : Object.create(null))).catch(logger.warn); + } + let response = await dispatcher.invokeHooksUntilNonNull("responseForOperation", requestContext); + if (response == null) { + const executionListeners = []; + (await dispatcher.invokeHook("executionDidStart", requestContext)).forEach((executionListener) => { + if (executionListener) { + executionListeners.push(executionListener); + } + }); + executionListeners.reverse(); + const executionDispatcher = new dispatcher_1.Dispatcher(executionListeners); + if (executionDispatcher.hasHook("willResolveField")) { + const invokeWillResolveField = (...args) => executionDispatcher.invokeSyncDidStartHook("willResolveField", ...args); + Object.defineProperty(requestContext.context, schemaInstrumentation_1.symbolExecutionDispatcherWillResolveField, { value: invokeWillResolveField }); + if (config.fieldResolver) { + Object.defineProperty(requestContext.context, schemaInstrumentation_1.symbolUserFieldResolver, { + value: config.fieldResolver + }); + } + (0, schemaInstrumentation_1.enablePluginsForSchemaResolvers)(config.schema); + } + try { + const result = await execute(requestContext); + const resultErrors = (_c = result.errors) === null || _c === void 0 ? void 0 : _c.map((e) => { + if (isBadUserInputGraphQLError(e)) { + return (0, apollo_server_errors_1.fromGraphQLError)(e, { + errorClass: apollo_server_errors_1.UserInputError + }); + } + return e; + }); + if (resultErrors) { + await didEncounterErrors(resultErrors); + } + response = __spreadProps(__spreadValues({}, result), { + errors: resultErrors ? formatErrors(resultErrors) : void 0 + }); + await executionDispatcher.invokeHook("executionDidEnd"); + } catch (executionError) { + await executionDispatcher.invokeHook("executionDidEnd", executionError); + return await sendErrorResponse(executionError); + } + } + if (config.formatResponse) { + const formattedResponse = config.formatResponse(response, requestContext); + if (formattedResponse != null) { + response = formattedResponse; + } + } + return sendResponse(response); + function parse(query2, parseOptions) { + return (0, graphql_1.parse)(query2, parseOptions); + } + function validate(document2) { + let rules = graphql_1.specifiedRules; + if (config.validationRules) { + rules = rules.concat(config.validationRules); + } + return (0, graphql_1.validate)(config.schema, document2, rules); + } + async function execute(requestContext2) { + const { request: request2, document: document2 } = requestContext2; + const executionArgs = { + schema: config.schema, + document: document2, + rootValue: typeof config.rootValue === "function" ? config.rootValue(document2) : config.rootValue, + contextValue: requestContext2.context, + variableValues: request2.variables, + operationName: request2.operationName, + fieldResolver: config.fieldResolver + }; + if (config.executor) { + return await config.executor(requestContext2); + } else { + return await (0, graphql_1.execute)(executionArgs); + } + } + async function sendResponse(response2) { + requestContext.response = __spreadProps(__spreadValues({}, requestContext.response), { + errors: response2.errors, + data: response2.data, + extensions: response2.extensions + }); + if (response2.http) { + if (!requestContext.response.http) { + requestContext.response.http = { + headers: new apollo_server_env_1.Headers() + }; + } + if (response2.http.status) { + requestContext.response.http.status = response2.http.status; + } + for (const [name, value] of response2.http.headers) { + requestContext.response.http.headers.set(name, value); + } + } + await dispatcher.invokeHook("willSendResponse", requestContext); + return requestContext.response; + } + async function didEncounterErrors(errors) { + requestContext.errors = errors; + return await dispatcher.invokeHook("didEncounterErrors", requestContext); + } + async function sendErrorResponse(errorOrErrors, errorClass) { + const errors = Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors]; + await didEncounterErrors(errors); + const response2 = { + errors: formatErrors(errors.map((err) => err instanceof apollo_server_errors_1.ApolloError && !errorClass ? err : (0, apollo_server_errors_1.fromGraphQLError)(err, errorClass && { + errorClass + }))) + }; + if (errors.every((err) => err instanceof apollo_server_errors_1.PersistedQueryNotSupportedError || err instanceof apollo_server_errors_1.PersistedQueryNotFoundError)) { + response2.http = { + status: 200, + headers: new apollo_server_env_1.Headers({ + "Cache-Control": "private, no-cache, must-revalidate" + }) + }; + } else if (errors.length === 1 && errors[0] instanceof runHttpQuery_1.HttpQueryError) { + response2.http = { + status: errors[0].statusCode, + headers: new apollo_server_env_1.Headers(errors[0].headers) + }; + } + return sendResponse(response2); + } + function formatErrors(errors) { + return (0, apollo_server_errors_1.formatApolloErrors)(errors, { + formatter: config.formatError, + debug: requestContext.debug + }); + } + async function initializeRequestListenerDispatcher() { + const requestListeners = []; + if (config.plugins) { + for (const plugin of config.plugins) { + if (!plugin.requestDidStart) + continue; + const listener = await plugin.requestDidStart(requestContext); + if (listener) { + requestListeners.push(listener); + } + } + } + return new dispatcher_1.Dispatcher(requestListeners); + } + async function initializeDataSources() { + if (config.dataSources) { + const context = requestContext.context; + const dataSources = config.dataSources(); + const initializers = []; + for (const dataSource of Object.values(dataSources)) { + if (dataSource.initialize) { + initializers.push(dataSource.initialize({ + context, + cache: requestContext.cache + })); + } + } + await Promise.all(initializers); + if ("dataSources" in context) { + throw new Error("Please use the dataSources config option instead of putting dataSources on the context yourself."); + } + context.dataSources = dataSources; + } + } + } + exports2.processGraphQLRequest = processGraphQLRequest; + } +}); + +// node_modules/apollo-server-types/dist/index.js +var require_dist4 = __commonJS({ + "node_modules/apollo-server-types/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CacheScope = void 0; + var CacheScope; + (function(CacheScope2) { + CacheScope2["Public"] = "PUBLIC"; + CacheScope2["Private"] = "PRIVATE"; + })(CacheScope = exports2.CacheScope || (exports2.CacheScope = {})); + } +}); + +// node_modules/apollo-server-core/dist/cachePolicy.js +var require_cachePolicy = __commonJS({ + "node_modules/apollo-server-core/dist/cachePolicy.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.newCachePolicy = void 0; + var apollo_server_types_1 = require_dist4(); + function newCachePolicy() { + return { + maxAge: void 0, + scope: void 0, + restrict(hint) { + if (hint.maxAge !== void 0 && (this.maxAge === void 0 || hint.maxAge < this.maxAge)) { + this.maxAge = hint.maxAge; + } + if (hint.scope !== void 0 && this.scope !== apollo_server_types_1.CacheScope.Private) { + this.scope = hint.scope; + } + }, + replace(hint) { + if (hint.maxAge !== void 0) { + this.maxAge = hint.maxAge; + } + if (hint.scope !== void 0) { + this.scope = hint.scope; + } + }, + policyIfCacheable() { + var _a; + if (this.maxAge === void 0 || this.maxAge === 0) { + return null; + } + return { maxAge: this.maxAge, scope: (_a = this.scope) !== null && _a !== void 0 ? _a : apollo_server_types_1.CacheScope.Public }; + } + }; + } + exports2.newCachePolicy = newCachePolicy; + } +}); + +// node_modules/apollo-server-core/dist/runHttpQuery.js +var require_runHttpQuery = __commonJS({ + "node_modules/apollo-server-core/dist/runHttpQuery.js"(exports2) { + "use strict"; + var _a; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.cloneObject = exports2.processHTTPRequest = exports2.runHttpQuery = exports2.throwHttpGraphQLError = exports2.isHttpQueryError = exports2.HttpQueryError = void 0; + var apollo_server_env_1 = require_dist(); + var graphqlOptions_1 = require_graphqlOptions(); + var apollo_server_errors_1 = require_dist2(); + var requestPipeline_1 = require_requestPipeline(); + var cachePolicy_1 = require_cachePolicy(); + var HttpQueryError = class extends Error { + constructor(statusCode, message, isGraphQLError = false, headers) { + super(message); + this.name = "HttpQueryError"; + this.statusCode = statusCode; + this.isGraphQLError = isGraphQLError; + this.headers = headers; + } + }; + exports2.HttpQueryError = HttpQueryError; + function isHttpQueryError(e) { + var _a2; + return ((_a2 = e) === null || _a2 === void 0 ? void 0 : _a2.name) === "HttpQueryError"; + } + exports2.isHttpQueryError = isHttpQueryError; + function throwHttpGraphQLError(statusCode, errors, options, extensions, headers) { + const allHeaders = { + "Content-Type": "application/json" + }; + if (headers) { + for (const [name, value] of headers) { + allHeaders[name] = value; + } + } + const result = { + errors: options ? (0, apollo_server_errors_1.formatApolloErrors)(errors, { + debug: options.debug, + formatter: options.formatError + }) : errors + }; + if (extensions) { + result.extensions = extensions; + } + throw new HttpQueryError(statusCode, prettyJSONStringify(result), true, allHeaders); + } + exports2.throwHttpGraphQLError = throwHttpGraphQLError; + var NODE_ENV = (_a = process.env.NODE_ENV) !== null && _a !== void 0 ? _a : ""; + async function runHttpQuery(handlerArguments, request) { + function debugFromNodeEnv(nodeEnv = NODE_ENV) { + return nodeEnv !== "production" && nodeEnv !== "test"; + } + let options; + try { + options = await (0, graphqlOptions_1.resolveGraphqlOptions)(request.options, ...handlerArguments); + } catch (e) { + return throwHttpGraphQLError(500, [e], { + debug: debugFromNodeEnv() + }); + } + if (options.debug === void 0) { + options.debug = debugFromNodeEnv(options.nodeEnv); + } + if (typeof options.context === "function") { + try { + options.context(); + } catch (e) { + e.message = `Context creation failed: ${e.message}`; + if (e.extensions && e.extensions.code && e.extensions.code !== "INTERNAL_SERVER_ERROR") { + return throwHttpGraphQLError(400, [e], options); + } else { + return throwHttpGraphQLError(500, [e], options); + } + } + } + const config = { + schema: options.schema, + schemaHash: options.schemaHash, + logger: options.logger, + rootValue: options.rootValue, + context: options.context || {}, + validationRules: options.validationRules, + executor: options.executor, + fieldResolver: options.fieldResolver, + cache: options.cache, + dataSources: options.dataSources, + documentStore: options.documentStore, + persistedQueries: options.persistedQueries, + formatError: options.formatError, + formatResponse: options.formatResponse, + debug: options.debug, + plugins: options.plugins || [], + allowBatchedHttpRequests: options.allowBatchedHttpRequests + }; + return processHTTPRequest(config, request); + } + exports2.runHttpQuery = runHttpQuery; + async function processHTTPRequest(options, httpRequest) { + var _a2, _b; + let requestPayload; + switch (httpRequest.method) { + case "POST": + if (!httpRequest.query || typeof httpRequest.query === "string" || Buffer.isBuffer(httpRequest.query) || Object.keys(httpRequest.query).length === 0) { + throw new HttpQueryError(400, "POST body missing, invalid Content-Type, or JSON object has no keys."); + } + requestPayload = httpRequest.query; + break; + case "GET": + if (!httpRequest.query || Object.keys(httpRequest.query).length === 0) { + throw new HttpQueryError(400, "GET query missing."); + } + requestPayload = httpRequest.query; + break; + default: + throw new HttpQueryError(405, "Apollo Server supports only GET/POST requests.", false, { + Allow: "GET, POST" + }); + } + options = __spreadProps(__spreadValues({}, options), { + plugins: [checkOperationPlugin, ...options.plugins] + }); + function buildRequestContext(request) { + const context = cloneObject(options.context); + return { + logger: options.logger || console, + schema: options.schema, + schemaHash: options.schemaHash, + request, + response: { + http: { + headers: new apollo_server_env_1.Headers() + } + }, + context, + cache: options.cache, + debug: options.debug, + metrics: {}, + overallCachePolicy: (0, cachePolicy_1.newCachePolicy)() + }; + } + const responseInit = { + headers: { + "Content-Type": "application/json" + } + }; + let body; + try { + if (Array.isArray(requestPayload)) { + if (options.allowBatchedHttpRequests === false) { + return throwHttpGraphQLError(400, [new Error("Operation batching disabled.")], options); + } + const requests = requestPayload.map((requestParams) => parseGraphQLRequest(httpRequest.request, requestParams)); + const responses = await Promise.all(requests.map(async (request) => { + try { + const requestContext = buildRequestContext(request); + const response = await (0, requestPipeline_1.processGraphQLRequest)(options, requestContext); + if (response.http) { + for (const [name, value] of response.http.headers) { + responseInit.headers[name] = value; + } + if (response.http.status) { + responseInit.status = response.http.status; + } + } + return response; + } catch (error) { + return { + errors: (0, apollo_server_errors_1.formatApolloErrors)([error], options) + }; + } + })); + body = prettyJSONStringify(responses.map(serializeGraphQLResponse)); + } else { + const request = parseGraphQLRequest(httpRequest.request, requestPayload); + const requestContext = buildRequestContext(request); + const response = await (0, requestPipeline_1.processGraphQLRequest)(options, requestContext); + if (response.errors && typeof response.data === "undefined") { + return throwHttpGraphQLError(((_a2 = response.http) === null || _a2 === void 0 ? void 0 : _a2.status) || 400, response.errors, void 0, response.extensions, (_b = response.http) === null || _b === void 0 ? void 0 : _b.headers); + } + if (response.http) { + for (const [name, value] of response.http.headers) { + responseInit.headers[name] = value; + } + if (response.http.status) { + responseInit.status = response.http.status; + } + } + body = prettyJSONStringify(serializeGraphQLResponse(response)); + } + } catch (error) { + if (error instanceof HttpQueryError) { + throw error; + } + return throwHttpGraphQLError(500, [error], options); + } + responseInit.headers["Content-Length"] = Buffer.byteLength(body, "utf8").toString(); + return { + graphqlResponse: body, + responseInit + }; + } + exports2.processHTTPRequest = processHTTPRequest; + function parseGraphQLRequest(httpRequest, requestParams) { + let queryString = requestParams.query; + let extensions = requestParams.extensions; + if (typeof extensions === "string" && extensions !== "") { + try { + extensions = JSON.parse(extensions); + } catch (error) { + throw new HttpQueryError(400, "Extensions are invalid JSON."); + } + } + if (queryString && typeof queryString !== "string") { + if (queryString.kind === "Document") { + throw new HttpQueryError(400, "GraphQL queries must be strings. It looks like you're sending the internal graphql-js representation of a parsed query in your request instead of a request in the GraphQL query language. You can convert an AST to a string using the `print` function from `graphql`, or use a client like `apollo-client` which converts the internal representation to a string for you."); + } else { + throw new HttpQueryError(400, "GraphQL queries must be strings."); + } + } + const operationName = requestParams.operationName; + let variables = requestParams.variables; + if (typeof variables === "string" && variables !== "") { + try { + variables = JSON.parse(variables); + } catch (error) { + throw new HttpQueryError(400, "Variables are invalid JSON."); + } + } + return { + query: queryString, + operationName, + variables, + extensions, + http: httpRequest + }; + } + var checkOperationPlugin = { + async requestDidStart() { + return { + async didResolveOperation({ request, operation }) { + if (!request.http) + return; + if (request.http.method === "GET" && operation.operation !== "query") { + throw new HttpQueryError(405, `GET supports only query operation`, false, { + Allow: "POST" + }); + } + } + }; + } + }; + function serializeGraphQLResponse(response) { + return { + errors: response.errors, + data: response.data, + extensions: response.extensions + }; + } + function prettyJSONStringify(value) { + return JSON.stringify(value) + "\n"; + } + function cloneObject(object) { + return Object.assign(Object.create(Object.getPrototypeOf(object)), object); + } + exports2.cloneObject = cloneObject; + } +}); + +// node_modules/apollo-server-core/dist/nodeHttpToRequest.js +var require_nodeHttpToRequest = __commonJS({ + "node_modules/apollo-server-core/dist/nodeHttpToRequest.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.convertNodeHttpToRequest = void 0; + var apollo_server_env_1 = require_dist(); + function convertNodeHttpToRequest(req) { + const headers = new apollo_server_env_1.Headers(); + Object.keys(req.headers).forEach((key) => { + const values = req.headers[key]; + if (Array.isArray(values)) { + values.forEach((value) => headers.append(key, value)); + } else { + headers.append(key, values); + } + }); + return new apollo_server_env_1.Request(req.url, { + headers, + method: req.method + }); + } + exports2.convertNodeHttpToRequest = convertNodeHttpToRequest; + } +}); + +// node_modules/fast-json-stable-stringify/index.js +var require_fast_json_stable_stringify = __commonJS({ + "node_modules/fast-json-stable-stringify/index.js"(exports2, module2) { + "use strict"; + module2.exports = function(data, opts) { + if (!opts) + opts = {}; + if (typeof opts === "function") + opts = { cmp: opts }; + var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false; + var cmp = opts.cmp && function(f) { + return function(node) { + return function(a, b) { + var aobj = { key: a, value: node[a] }; + var bobj = { key: b, value: node[b] }; + return f(aobj, bobj); + }; + }; + }(opts.cmp); + var seen = []; + return function stringify(node) { + if (node && node.toJSON && typeof node.toJSON === "function") { + node = node.toJSON(); + } + if (node === void 0) + return; + if (typeof node == "number") + return isFinite(node) ? "" + node : "null"; + if (typeof node !== "object") + return JSON.stringify(node); + var i, out; + if (Array.isArray(node)) { + out = "["; + for (i = 0; i < node.length; i++) { + if (i) + out += ","; + out += stringify(node[i]) || "null"; + } + return out + "]"; + } + if (node === null) + return "null"; + if (seen.indexOf(node) !== -1) { + if (cycles) + return JSON.stringify("__cycle__"); + throw new TypeError("Converting circular structure to JSON"); + } + var seenIndex = seen.push(node) - 1; + var keys = Object.keys(node).sort(cmp && cmp(node)); + out = ""; + for (i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = stringify(node[key]); + if (!value) + continue; + if (out) + out += ","; + out += JSON.stringify(key) + ":" + value; + } + seen.splice(seenIndex, 1); + return "{" + out + "}"; + }(data); + }; + } +}); + +// node_modules/@graphql-tools/utils/index.js +var require_utils2 = __commonJS({ + "node_modules/@graphql-tools/utils/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var graphql = require_graphql2(); + var asArray = (fns) => Array.isArray(fns) ? fns : fns ? [fns] : []; + var invalidDocRegex = /\.[a-z0-9]+$/i; + function isDocumentString(str) { + if (typeof str !== "string") { + return false; + } + if (invalidDocRegex.test(str)) { + return false; + } + try { + graphql.parse(str); + return true; + } catch (e) { + } + return false; + } + var invalidPathRegex = /[‘“!%&^<=>`]/; + function isValidPath(str) { + return typeof str === "string" && !invalidPathRegex.test(str); + } + function compareStrings(a, b) { + if (String(a) < String(b)) { + return -1; + } + if (String(a) > String(b)) { + return 1; + } + return 0; + } + function nodeToString(a) { + var _a, _b; + let name; + if ("alias" in a) { + name = (_a = a.alias) === null || _a === void 0 ? void 0 : _a.value; + } + if (name == null && "name" in a) { + name = (_b = a.name) === null || _b === void 0 ? void 0 : _b.value; + } + if (name == null) { + name = a.kind; + } + return name; + } + function compareNodes(a, b, customFn) { + const aStr = nodeToString(a); + const bStr = nodeToString(b); + if (typeof customFn === "function") { + return customFn(aStr, bStr); + } + return compareStrings(aStr, bStr); + } + function isSome(input) { + return input != null; + } + function assertSome(input, message = "Value should be something") { + if (input == null) { + throw new Error(message); + } + } + if (typeof AggregateError === "undefined") { + class AggregateErrorClass extends Error { + constructor(errors, message = "") { + super(message); + this.errors = errors; + this.name = "AggregateError"; + Error.captureStackTrace(this, AggregateErrorClass); + } + } + exports2.AggregateError = function(errors, message) { + return new AggregateErrorClass(errors, message); + }; + } else { + exports2.AggregateError = AggregateError; + } + function isAggregateError(error) { + return "errors" in error && Array.isArray(error["errors"]); + } + var MAX_ARRAY_LENGTH = 10; + var MAX_RECURSIVE_DEPTH = 2; + function inspect(value) { + return formatValue(value, []); + } + function formatValue(value, seenValues) { + switch (typeof value) { + case "string": + return JSON.stringify(value); + case "function": + return value.name ? `[function ${value.name}]` : "[function]"; + case "object": + return formatObjectValue(value, seenValues); + default: + return String(value); + } + } + function formatError(value) { + if (value instanceof graphql.GraphQLError) { + return value.toString(); + } + return `${value.name}: ${value.message}; + ${value.stack}`; + } + function formatObjectValue(value, previouslySeenValues) { + if (value === null) { + return "null"; + } + if (value instanceof Error) { + if (isAggregateError(value)) { + return formatError(value) + "\n" + formatArray(value.errors, previouslySeenValues); + } + return formatError(value); + } + if (previouslySeenValues.includes(value)) { + return "[Circular]"; + } + const seenValues = [...previouslySeenValues, value]; + if (isJSONable(value)) { + const jsonValue = value.toJSON(); + if (jsonValue !== value) { + return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues); + } + } else if (Array.isArray(value)) { + return formatArray(value, seenValues); + } + return formatObject(value, seenValues); + } + function isJSONable(value) { + return typeof value.toJSON === "function"; + } + function formatObject(object, seenValues) { + const entries = Object.entries(object); + if (entries.length === 0) { + return "{}"; + } + if (seenValues.length > MAX_RECURSIVE_DEPTH) { + return "[" + getObjectTag(object) + "]"; + } + const properties = entries.map(([key, value]) => key + ": " + formatValue(value, seenValues)); + return "{ " + properties.join(", ") + " }"; + } + function formatArray(array, seenValues) { + if (array.length === 0) { + return "[]"; + } + if (seenValues.length > MAX_RECURSIVE_DEPTH) { + return "[Array]"; + } + const len = Math.min(MAX_ARRAY_LENGTH, array.length); + const remaining = array.length - len; + const items = []; + for (let i = 0; i < len; ++i) { + items.push(formatValue(array[i], seenValues)); + } + if (remaining === 1) { + items.push("... 1 more item"); + } else if (remaining > 1) { + items.push(`... ${remaining} more items`); + } + return "[" + items.join(", ") + "]"; + } + function getObjectTag(object) { + const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, ""); + if (tag === "Object" && typeof object.constructor === "function") { + const name = object.constructor.name; + if (typeof name === "string" && name !== "") { + return name; + } + } + return tag; + } + function getArgumentValues(def, node, variableValues = {}) { + var _a; + const variableMap = Object.entries(variableValues).reduce((prev, [key, value]) => __spreadProps(__spreadValues({}, prev), { + [key]: value + }), {}); + const coercedValues = {}; + const argumentNodes = (_a = node.arguments) !== null && _a !== void 0 ? _a : []; + const argNodeMap = argumentNodes.reduce((prev, arg) => __spreadProps(__spreadValues({}, prev), { + [arg.name.value]: arg + }), {}); + for (const { name, type: argType, defaultValue } of def.args) { + const argumentNode = argNodeMap[name]; + if (!argumentNode) { + if (defaultValue !== void 0) { + coercedValues[name] = defaultValue; + } else if (graphql.isNonNullType(argType)) { + throw new graphql.GraphQLError(`Argument "${name}" of required type "${inspect(argType)}" was not provided.`, node); + } + continue; + } + const valueNode = argumentNode.value; + let isNull = valueNode.kind === graphql.Kind.NULL; + if (valueNode.kind === graphql.Kind.VARIABLE) { + const variableName = valueNode.name.value; + if (variableValues == null || variableMap[variableName] == null) { + if (defaultValue !== void 0) { + coercedValues[name] = defaultValue; + } else if (graphql.isNonNullType(argType)) { + throw new graphql.GraphQLError(`Argument "${name}" of required type "${inspect(argType)}" was provided the variable "$${variableName}" which was not provided a runtime value.`, valueNode); + } + continue; + } + isNull = variableValues[variableName] == null; + } + if (isNull && graphql.isNonNullType(argType)) { + throw new graphql.GraphQLError(`Argument "${name}" of non-null type "${inspect(argType)}" must not be null.`, valueNode); + } + const coercedValue = graphql.valueFromAST(valueNode, argType, variableValues); + if (coercedValue === void 0) { + throw new graphql.GraphQLError(`Argument "${name}" has invalid value ${graphql.print(valueNode)}.`, valueNode); + } + coercedValues[name] = coercedValue; + } + return coercedValues; + } + function getDirectivesInExtensions(node, pathToDirectivesInExtensions = ["directives"]) { + return pathToDirectivesInExtensions.reduce((acc, pathSegment) => acc == null ? acc : acc[pathSegment], node === null || node === void 0 ? void 0 : node.extensions); + } + function _getDirectiveInExtensions(directivesInExtensions, directiveName) { + const directiveInExtensions = directivesInExtensions.filter((directiveAnnotation) => directiveAnnotation.name === directiveName); + if (!directiveInExtensions.length) { + return void 0; + } + return directiveInExtensions.map((directive) => { + var _a; + return (_a = directive.args) !== null && _a !== void 0 ? _a : {}; + }); + } + function getDirectiveInExtensions(node, directiveName, pathToDirectivesInExtensions = ["directives"]) { + const directivesInExtensions = pathToDirectivesInExtensions.reduce((acc, pathSegment) => acc == null ? acc : acc[pathSegment], node === null || node === void 0 ? void 0 : node.extensions); + if (directivesInExtensions === void 0) { + return void 0; + } + if (Array.isArray(directivesInExtensions)) { + return _getDirectiveInExtensions(directivesInExtensions, directiveName); + } + const reformattedDirectivesInExtensions = []; + for (const [name, argsOrArrayOfArgs] of Object.entries(directivesInExtensions)) { + if (Array.isArray(argsOrArrayOfArgs)) { + for (const args of argsOrArrayOfArgs) { + reformattedDirectivesInExtensions.push({ name, args }); + } + } else { + reformattedDirectivesInExtensions.push({ name, args: argsOrArrayOfArgs }); + } + } + return _getDirectiveInExtensions(reformattedDirectivesInExtensions, directiveName); + } + function getDirectives(schema2, node, pathToDirectivesInExtensions = ["directives"]) { + const directivesInExtensions = getDirectivesInExtensions(node, pathToDirectivesInExtensions); + if (directivesInExtensions != null && directivesInExtensions.length > 0) { + return directivesInExtensions; + } + const schemaDirectives = schema2 && schema2.getDirectives ? schema2.getDirectives() : []; + const schemaDirectiveMap = schemaDirectives.reduce((schemaDirectiveMap2, schemaDirective) => { + schemaDirectiveMap2[schemaDirective.name] = schemaDirective; + return schemaDirectiveMap2; + }, {}); + let astNodes = []; + if (node.astNode) { + astNodes.push(node.astNode); + } + if ("extensionASTNodes" in node && node.extensionASTNodes) { + astNodes = [...astNodes, ...node.extensionASTNodes]; + } + const result = []; + for (const astNode of astNodes) { + if (astNode.directives) { + for (const directiveNode of astNode.directives) { + const schemaDirective = schemaDirectiveMap[directiveNode.name.value]; + if (schemaDirective) { + result.push({ name: directiveNode.name.value, args: getArgumentValues(schemaDirective, directiveNode) }); + } + } + } + } + return result; + } + function getDirective(schema2, node, directiveName, pathToDirectivesInExtensions = ["directives"]) { + const directiveInExtensions = getDirectiveInExtensions(node, directiveName, pathToDirectivesInExtensions); + if (directiveInExtensions != null) { + return directiveInExtensions; + } + const schemaDirective = schema2 && schema2.getDirective ? schema2.getDirective(directiveName) : void 0; + if (schemaDirective == null) { + return void 0; + } + let astNodes = []; + if (node.astNode) { + astNodes.push(node.astNode); + } + if ("extensionASTNodes" in node && node.extensionASTNodes) { + astNodes = [...astNodes, ...node.extensionASTNodes]; + } + const result = []; + for (const astNode of astNodes) { + if (astNode.directives) { + for (const directiveNode of astNode.directives) { + if (directiveNode.name.value === directiveName) { + result.push(getArgumentValues(schemaDirective, directiveNode)); + } + } + } + } + if (!result.length) { + return void 0; + } + return result; + } + function parseDirectiveValue(value) { + switch (value.kind) { + case graphql.Kind.INT: + return parseInt(value.value); + case graphql.Kind.FLOAT: + return parseFloat(value.value); + case graphql.Kind.BOOLEAN: + return Boolean(value.value); + case graphql.Kind.STRING: + case graphql.Kind.ENUM: + return value.value; + case graphql.Kind.LIST: + return value.values.map((v) => parseDirectiveValue(v)); + case graphql.Kind.OBJECT: + return value.fields.reduce((prev, v) => __spreadProps(__spreadValues({}, prev), { [v.name.value]: parseDirectiveValue(v.value) }), {}); + case graphql.Kind.NULL: + return null; + default: + return null; + } + } + function getFieldsWithDirectives(documentNode, options = {}) { + const result = {}; + let selected = ["ObjectTypeDefinition", "ObjectTypeExtension"]; + if (options.includeInputTypes) { + selected = [...selected, "InputObjectTypeDefinition", "InputObjectTypeExtension"]; + } + const allTypes = documentNode.definitions.filter((obj) => selected.includes(obj.kind)); + for (const type of allTypes) { + const typeName = type.name.value; + if (type.fields == null) { + continue; + } + for (const field of type.fields) { + if (field.directives && field.directives.length > 0) { + const fieldName = field.name.value; + const key = `${typeName}.${fieldName}`; + const directives = field.directives.map((d) => ({ + name: d.name.value, + args: (d.arguments || []).reduce((prev, arg) => __spreadProps(__spreadValues({}, prev), { [arg.name.value]: parseDirectiveValue(arg.value) }), {}) + })); + result[key] = directives; + } + } + } + return result; + } + function getImplementingTypes(interfaceName, schema2) { + const allTypesMap = schema2.getTypeMap(); + const result = []; + for (const graphqlTypeName in allTypesMap) { + const graphqlType = allTypesMap[graphqlTypeName]; + if (graphql.isObjectType(graphqlType)) { + const allInterfaces = graphqlType.getInterfaces(); + if (allInterfaces.find((int) => int.name === interfaceName)) { + result.push(graphqlType.name); + } + } + } + return result; + } + function astFromType(type) { + if (graphql.isNonNullType(type)) { + const innerType = astFromType(type.ofType); + if (innerType.kind === graphql.Kind.NON_NULL_TYPE) { + throw new Error(`Invalid type node ${inspect(type)}. Inner type of non-null type cannot be a non-null type.`); + } + return { + kind: graphql.Kind.NON_NULL_TYPE, + type: innerType + }; + } else if (graphql.isListType(type)) { + return { + kind: graphql.Kind.LIST_TYPE, + type: astFromType(type.ofType) + }; + } + return { + kind: graphql.Kind.NAMED_TYPE, + name: { + kind: graphql.Kind.NAME, + value: type.name + } + }; + } + function astFromValueUntyped(value) { + if (value === null) { + return { kind: graphql.Kind.NULL }; + } + if (value === void 0) { + return null; + } + if (Array.isArray(value)) { + const valuesNodes = []; + for (const item of value) { + const itemNode = astFromValueUntyped(item); + if (itemNode != null) { + valuesNodes.push(itemNode); + } + } + return { kind: graphql.Kind.LIST, values: valuesNodes }; + } + if (typeof value === "object") { + const fieldNodes = []; + for (const fieldName in value) { + const fieldValue = value[fieldName]; + const ast = astFromValueUntyped(fieldValue); + if (ast) { + fieldNodes.push({ + kind: graphql.Kind.OBJECT_FIELD, + name: { kind: graphql.Kind.NAME, value: fieldName }, + value: ast + }); + } + } + return { kind: graphql.Kind.OBJECT, fields: fieldNodes }; + } + if (typeof value === "boolean") { + return { kind: graphql.Kind.BOOLEAN, value }; + } + if (typeof value === "number" && isFinite(value)) { + const stringNum = String(value); + return integerStringRegExp.test(stringNum) ? { kind: graphql.Kind.INT, value: stringNum } : { kind: graphql.Kind.FLOAT, value: stringNum }; + } + if (typeof value === "string") { + return { kind: graphql.Kind.STRING, value }; + } + throw new TypeError(`Cannot convert value to AST: ${value}.`); + } + var integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/; + function memoize1(fn) { + const memoize1cache = new WeakMap(); + return function memoized(a1) { + const cachedValue = memoize1cache.get(a1); + if (cachedValue === void 0) { + const newValue = fn(a1); + memoize1cache.set(a1, newValue); + return newValue; + } + return cachedValue; + }; + } + function memoize2(fn) { + const memoize2cache = new WeakMap(); + return function memoized(a1, a2) { + let cache2 = memoize2cache.get(a1); + if (!cache2) { + cache2 = new WeakMap(); + memoize2cache.set(a1, cache2); + const newValue = fn(a1, a2); + cache2.set(a2, newValue); + return newValue; + } + const cachedValue = cache2.get(a2); + if (cachedValue === void 0) { + const newValue = fn(a1, a2); + cache2.set(a2, newValue); + return newValue; + } + return cachedValue; + }; + } + function memoize3(fn) { + const memoize3Cache = new WeakMap(); + return function memoized(a1, a2, a3) { + let cache2 = memoize3Cache.get(a1); + if (!cache2) { + cache2 = new WeakMap(); + memoize3Cache.set(a1, cache2); + const cache32 = new WeakMap(); + cache2.set(a2, cache32); + const newValue = fn(a1, a2, a3); + cache32.set(a3, newValue); + return newValue; + } + let cache3 = cache2.get(a2); + if (!cache3) { + cache3 = new WeakMap(); + cache2.set(a2, cache3); + const newValue = fn(a1, a2, a3); + cache3.set(a3, newValue); + return newValue; + } + const cachedValue = cache3.get(a3); + if (cachedValue === void 0) { + const newValue = fn(a1, a2, a3); + cache3.set(a3, newValue); + return newValue; + } + return cachedValue; + }; + } + function memoize4(fn) { + const memoize4Cache = new WeakMap(); + return function memoized(a1, a2, a3, a4) { + let cache2 = memoize4Cache.get(a1); + if (!cache2) { + cache2 = new WeakMap(); + memoize4Cache.set(a1, cache2); + const cache32 = new WeakMap(); + cache2.set(a2, cache32); + const cache42 = new WeakMap(); + cache32.set(a3, cache42); + const newValue = fn(a1, a2, a3, a4); + cache42.set(a4, newValue); + return newValue; + } + let cache3 = cache2.get(a2); + if (!cache3) { + cache3 = new WeakMap(); + cache2.set(a2, cache3); + const cache42 = new WeakMap(); + cache3.set(a3, cache42); + const newValue = fn(a1, a2, a3, a4); + cache42.set(a4, newValue); + return newValue; + } + const cache4 = cache3.get(a3); + if (!cache4) { + const cache42 = new WeakMap(); + cache3.set(a3, cache42); + const newValue = fn(a1, a2, a3, a4); + cache42.set(a4, newValue); + return newValue; + } + const cachedValue = cache4.get(a4); + if (cachedValue === void 0) { + const newValue = fn(a1, a2, a3, a4); + cache4.set(a4, newValue); + return newValue; + } + return cachedValue; + }; + } + function memoize5(fn) { + const memoize5Cache = new WeakMap(); + return function memoized(a1, a2, a3, a4, a5) { + let cache2 = memoize5Cache.get(a1); + if (!cache2) { + cache2 = new WeakMap(); + memoize5Cache.set(a1, cache2); + const cache32 = new WeakMap(); + cache2.set(a2, cache32); + const cache42 = new WeakMap(); + cache32.set(a3, cache42); + const cache52 = new WeakMap(); + cache42.set(a4, cache52); + const newValue = fn(a1, a2, a3, a4, a5); + cache52.set(a5, newValue); + return newValue; + } + let cache3 = cache2.get(a2); + if (!cache3) { + cache3 = new WeakMap(); + cache2.set(a2, cache3); + const cache42 = new WeakMap(); + cache3.set(a3, cache42); + const cache52 = new WeakMap(); + cache42.set(a4, cache52); + const newValue = fn(a1, a2, a3, a4, a5); + cache52.set(a5, newValue); + return newValue; + } + let cache4 = cache3.get(a3); + if (!cache4) { + cache4 = new WeakMap(); + cache3.set(a3, cache4); + const cache52 = new WeakMap(); + cache4.set(a4, cache52); + const newValue = fn(a1, a2, a3, a4, a5); + cache52.set(a5, newValue); + return newValue; + } + let cache5 = cache4.get(a4); + if (!cache5) { + cache5 = new WeakMap(); + cache4.set(a4, cache5); + const newValue = fn(a1, a2, a3, a4, a5); + cache5.set(a5, newValue); + return newValue; + } + const cachedValue = cache5.get(a5); + if (cachedValue === void 0) { + const newValue = fn(a1, a2, a3, a4, a5); + cache5.set(a5, newValue); + return newValue; + } + return cachedValue; + }; + } + var memoize2of4cache = new WeakMap(); + function memoize2of4(fn) { + return function memoized(a1, a2, a3, a4) { + let cache2 = memoize2of4cache.get(a1); + if (!cache2) { + cache2 = new WeakMap(); + memoize2of4cache.set(a1, cache2); + const newValue = fn(a1, a2, a3, a4); + cache2.set(a2, newValue); + return newValue; + } + const cachedValue = cache2.get(a2); + if (cachedValue === void 0) { + const newValue = fn(a1, a2, a3, a4); + cache2.set(a2, newValue); + return newValue; + } + return cachedValue; + }; + } + function getDefinedRootType(schema2, operation) { + const rootTypeMap = getRootTypeMap(schema2); + const rootType = rootTypeMap.get(operation); + if (rootType == null) { + throw new Error(`Root type for operation "${operation}" not defined by the given schema.`); + } + return rootType; + } + var getRootTypeNames = memoize1(function getRootTypeNames2(schema2) { + const rootTypes = getRootTypes(schema2); + return new Set([...rootTypes].map((type) => type.name)); + }); + var getRootTypes = memoize1(function getRootTypes2(schema2) { + const rootTypeMap = getRootTypeMap(schema2); + return new Set(rootTypeMap.values()); + }); + var getRootTypeMap = memoize1(function getRootTypeMap2(schema2) { + const rootTypeMap = new Map(); + const queryType = schema2.getQueryType(); + if (queryType) { + rootTypeMap.set("query", queryType); + } + const mutationType = schema2.getMutationType(); + if (mutationType) { + rootTypeMap.set("mutation", mutationType); + } + const subscriptionType = schema2.getSubscriptionType(); + if (subscriptionType) { + rootTypeMap.set("subscription", subscriptionType); + } + return rootTypeMap; + }); + function getDocumentNodeFromSchema(schema2, options = {}) { + const pathToDirectivesInExtensions = options.pathToDirectivesInExtensions; + const typesMap = schema2.getTypeMap(); + const schemaNode = astFromSchema(schema2, pathToDirectivesInExtensions); + const definitions = schemaNode != null ? [schemaNode] : []; + const directives = schema2.getDirectives(); + for (const directive of directives) { + if (graphql.isSpecifiedDirective(directive)) { + continue; + } + definitions.push(astFromDirective(directive, schema2, pathToDirectivesInExtensions)); + } + for (const typeName in typesMap) { + const type = typesMap[typeName]; + const isPredefinedScalar = graphql.isSpecifiedScalarType(type); + const isIntrospection = graphql.isIntrospectionType(type); + if (isPredefinedScalar || isIntrospection) { + continue; + } + if (graphql.isObjectType(type)) { + definitions.push(astFromObjectType(type, schema2, pathToDirectivesInExtensions)); + } else if (graphql.isInterfaceType(type)) { + definitions.push(astFromInterfaceType(type, schema2, pathToDirectivesInExtensions)); + } else if (graphql.isUnionType(type)) { + definitions.push(astFromUnionType(type, schema2, pathToDirectivesInExtensions)); + } else if (graphql.isInputObjectType(type)) { + definitions.push(astFromInputObjectType(type, schema2, pathToDirectivesInExtensions)); + } else if (graphql.isEnumType(type)) { + definitions.push(astFromEnumType(type, schema2, pathToDirectivesInExtensions)); + } else if (graphql.isScalarType(type)) { + definitions.push(astFromScalarType(type, schema2, pathToDirectivesInExtensions)); + } else { + throw new Error(`Unknown type ${type}.`); + } + } + return { + kind: graphql.Kind.DOCUMENT, + definitions + }; + } + function printSchemaWithDirectives(schema2, options = {}) { + const documentNode = getDocumentNodeFromSchema(schema2, options); + return graphql.print(documentNode); + } + function astFromSchema(schema2, pathToDirectivesInExtensions) { + var _a, _b; + const operationTypeMap = new Map([ + ["query", void 0], + ["mutation", void 0], + ["subscription", void 0] + ]); + const nodes = []; + if (schema2.astNode != null) { + nodes.push(schema2.astNode); + } + if (schema2.extensionASTNodes != null) { + for (const extensionASTNode of schema2.extensionASTNodes) { + nodes.push(extensionASTNode); + } + } + for (const node of nodes) { + if (node.operationTypes) { + for (const operationTypeDefinitionNode of node.operationTypes) { + operationTypeMap.set(operationTypeDefinitionNode.operation, operationTypeDefinitionNode); + } + } + } + const rootTypeMap = getRootTypeMap(schema2); + for (const [operationTypeNode, operationTypeDefinitionNode] of operationTypeMap) { + const rootType = rootTypeMap.get(operationTypeNode); + if (rootType != null) { + const rootTypeAST = astFromType(rootType); + if (operationTypeDefinitionNode != null) { + operationTypeDefinitionNode.type = rootTypeAST; + } else { + operationTypeMap.set(operationTypeNode, { + kind: graphql.Kind.OPERATION_TYPE_DEFINITION, + operation: operationTypeNode, + type: rootTypeAST + }); + } + } + } + const operationTypes = [...operationTypeMap.values()].filter(isSome); + const directives = getDirectiveNodes(schema2, schema2, pathToDirectivesInExtensions); + if (!operationTypes.length && !directives.length) { + return null; + } + const schemaNode = { + kind: operationTypes != null ? graphql.Kind.SCHEMA_DEFINITION : graphql.Kind.SCHEMA_EXTENSION, + operationTypes, + directives + }; + schemaNode.description = ((_b = (_a = schema2.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : schema2.description != null) ? { + kind: graphql.Kind.STRING, + value: schema2.description, + block: true + } : void 0; + return schemaNode; + } + function astFromDirective(directive, schema2, pathToDirectivesInExtensions) { + var _a, _b, _c, _d; + return { + kind: graphql.Kind.DIRECTIVE_DEFINITION, + description: (_b = (_a = directive.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : directive.description ? { + kind: graphql.Kind.STRING, + value: directive.description + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: directive.name + }, + arguments: (_c = directive.args) === null || _c === void 0 ? void 0 : _c.map((arg) => astFromArg(arg, schema2, pathToDirectivesInExtensions)), + repeatable: directive.isRepeatable, + locations: ((_d = directive.locations) === null || _d === void 0 ? void 0 : _d.map((location) => ({ + kind: graphql.Kind.NAME, + value: location + }))) || [] + }; + } + function getDirectiveNodes(entity, schema2, pathToDirectivesInExtensions) { + const directivesInExtensions = getDirectivesInExtensions(entity, pathToDirectivesInExtensions); + let nodes = []; + if (entity.astNode != null) { + nodes.push(entity.astNode); + } + if ("extensionASTNodes" in entity && entity.extensionASTNodes != null) { + nodes = nodes.concat(entity.extensionASTNodes); + } + let directives; + if (directivesInExtensions != null) { + directives = makeDirectiveNodes(schema2, directivesInExtensions); + } else { + directives = []; + for (const node of nodes) { + if (node.directives) { + directives.push(...node.directives); + } + } + } + return directives; + } + function getDeprecatableDirectiveNodes(entity, schema2, pathToDirectivesInExtensions) { + var _a, _b; + let directiveNodesBesidesDeprecated = []; + let deprecatedDirectiveNode = null; + const directivesInExtensions = getDirectivesInExtensions(entity, pathToDirectivesInExtensions); + let directives; + if (directivesInExtensions != null) { + directives = makeDirectiveNodes(schema2, directivesInExtensions); + } else { + directives = (_a = entity.astNode) === null || _a === void 0 ? void 0 : _a.directives; + } + if (directives != null) { + directiveNodesBesidesDeprecated = directives.filter((directive) => directive.name.value !== "deprecated"); + if (entity.deprecationReason != null) { + deprecatedDirectiveNode = (_b = directives.filter((directive) => directive.name.value === "deprecated")) === null || _b === void 0 ? void 0 : _b[0]; + } + } + if (entity.deprecationReason != null && deprecatedDirectiveNode == null) { + deprecatedDirectiveNode = makeDeprecatedDirective(entity.deprecationReason); + } + return deprecatedDirectiveNode == null ? directiveNodesBesidesDeprecated : [deprecatedDirectiveNode].concat(directiveNodesBesidesDeprecated); + } + function astFromArg(arg, schema2, pathToDirectivesInExtensions) { + var _a, _b, _c; + return { + kind: graphql.Kind.INPUT_VALUE_DEFINITION, + description: (_b = (_a = arg.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : arg.description ? { + kind: graphql.Kind.STRING, + value: arg.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: arg.name + }, + type: astFromType(arg.type), + defaultValue: arg.defaultValue !== void 0 ? (_c = graphql.astFromValue(arg.defaultValue, arg.type)) !== null && _c !== void 0 ? _c : void 0 : void 0, + directives: getDeprecatableDirectiveNodes(arg, schema2, pathToDirectivesInExtensions) + }; + } + function astFromObjectType(type, schema2, pathToDirectivesInExtensions) { + var _a, _b; + return { + kind: graphql.Kind.OBJECT_TYPE_DEFINITION, + description: (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.description ? { + kind: graphql.Kind.STRING, + value: type.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: type.name + }, + fields: Object.values(type.getFields()).map((field) => astFromField(field, schema2, pathToDirectivesInExtensions)), + interfaces: Object.values(type.getInterfaces()).map((iFace) => astFromType(iFace)), + directives: getDirectiveNodes(type, schema2, pathToDirectivesInExtensions) + }; + } + function astFromInterfaceType(type, schema2, pathToDirectivesInExtensions) { + var _a, _b; + const node = { + kind: graphql.Kind.INTERFACE_TYPE_DEFINITION, + description: (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.description ? { + kind: graphql.Kind.STRING, + value: type.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: type.name + }, + fields: Object.values(type.getFields()).map((field) => astFromField(field, schema2, pathToDirectivesInExtensions)), + directives: getDirectiveNodes(type, schema2, pathToDirectivesInExtensions) + }; + if ("getInterfaces" in type) { + node.interfaces = Object.values(type.getInterfaces()).map((iFace) => astFromType(iFace)); + } + return node; + } + function astFromUnionType(type, schema2, pathToDirectivesInExtensions) { + var _a, _b; + return { + kind: graphql.Kind.UNION_TYPE_DEFINITION, + description: (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.description ? { + kind: graphql.Kind.STRING, + value: type.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: type.name + }, + directives: getDirectiveNodes(type, schema2, pathToDirectivesInExtensions), + types: type.getTypes().map((type2) => astFromType(type2)) + }; + } + function astFromInputObjectType(type, schema2, pathToDirectivesInExtensions) { + var _a, _b; + return { + kind: graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION, + description: (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.description ? { + kind: graphql.Kind.STRING, + value: type.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: type.name + }, + fields: Object.values(type.getFields()).map((field) => astFromInputField(field, schema2, pathToDirectivesInExtensions)), + directives: getDirectiveNodes(type, schema2, pathToDirectivesInExtensions) + }; + } + function astFromEnumType(type, schema2, pathToDirectivesInExtensions) { + var _a, _b; + return { + kind: graphql.Kind.ENUM_TYPE_DEFINITION, + description: (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.description ? { + kind: graphql.Kind.STRING, + value: type.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: type.name + }, + values: Object.values(type.getValues()).map((value) => astFromEnumValue(value, schema2, pathToDirectivesInExtensions)), + directives: getDirectiveNodes(type, schema2, pathToDirectivesInExtensions) + }; + } + function astFromScalarType(type, schema2, pathToDirectivesInExtensions) { + var _a, _b, _c; + const directivesInExtensions = getDirectivesInExtensions(type, pathToDirectivesInExtensions); + const directives = directivesInExtensions ? makeDirectiveNodes(schema2, directivesInExtensions) : ((_a = type.astNode) === null || _a === void 0 ? void 0 : _a.directives) || []; + const specifiedByValue = type["specifiedByUrl"] || type["specifiedByURL"]; + if (specifiedByValue && !directives.some((directiveNode) => directiveNode.name.value === "specifiedBy")) { + const specifiedByArgs = { + url: specifiedByValue + }; + directives.push(makeDirectiveNode("specifiedBy", specifiedByArgs)); + } + return { + kind: graphql.Kind.SCALAR_TYPE_DEFINITION, + description: (_c = (_b = type.astNode) === null || _b === void 0 ? void 0 : _b.description) !== null && _c !== void 0 ? _c : type.description ? { + kind: graphql.Kind.STRING, + value: type.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: type.name + }, + directives + }; + } + function astFromField(field, schema2, pathToDirectivesInExtensions) { + var _a, _b; + return { + kind: graphql.Kind.FIELD_DEFINITION, + description: (_b = (_a = field.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : field.description ? { + kind: graphql.Kind.STRING, + value: field.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: field.name + }, + arguments: field.args.map((arg) => astFromArg(arg, schema2, pathToDirectivesInExtensions)), + type: astFromType(field.type), + directives: getDeprecatableDirectiveNodes(field, schema2, pathToDirectivesInExtensions) + }; + } + function astFromInputField(field, schema2, pathToDirectivesInExtensions) { + var _a, _b, _c; + return { + kind: graphql.Kind.INPUT_VALUE_DEFINITION, + description: (_b = (_a = field.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : field.description ? { + kind: graphql.Kind.STRING, + value: field.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: field.name + }, + type: astFromType(field.type), + directives: getDeprecatableDirectiveNodes(field, schema2, pathToDirectivesInExtensions), + defaultValue: (_c = graphql.astFromValue(field.defaultValue, field.type)) !== null && _c !== void 0 ? _c : void 0 + }; + } + function astFromEnumValue(value, schema2, pathToDirectivesInExtensions) { + var _a, _b; + return { + kind: graphql.Kind.ENUM_VALUE_DEFINITION, + description: (_b = (_a = value.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : value.description ? { + kind: graphql.Kind.STRING, + value: value.description, + block: true + } : void 0, + name: { + kind: graphql.Kind.NAME, + value: value.name + }, + directives: getDirectiveNodes(value, schema2, pathToDirectivesInExtensions) + }; + } + function makeDeprecatedDirective(deprecationReason) { + return makeDirectiveNode("deprecated", { reason: deprecationReason }, graphql.GraphQLDeprecatedDirective); + } + function makeDirectiveNode(name, args, directive) { + const directiveArguments = []; + if (directive != null) { + for (const arg of directive.args) { + const argName = arg.name; + const argValue = args[argName]; + if (argValue !== void 0) { + const value = graphql.astFromValue(argValue, arg.type); + if (value) { + directiveArguments.push({ + kind: graphql.Kind.ARGUMENT, + name: { + kind: graphql.Kind.NAME, + value: argName + }, + value + }); + } + } + } + } else { + for (const argName in args) { + const argValue = args[argName]; + const value = astFromValueUntyped(argValue); + if (value) { + directiveArguments.push({ + kind: graphql.Kind.ARGUMENT, + name: { + kind: graphql.Kind.NAME, + value: argName + }, + value + }); + } + } + } + return { + kind: graphql.Kind.DIRECTIVE, + name: { + kind: graphql.Kind.NAME, + value: name + }, + arguments: directiveArguments + }; + } + function makeDirectiveNodes(schema2, directiveValues) { + const directiveNodes = []; + for (const directiveName in directiveValues) { + const arrayOrSingleValue = directiveValues[directiveName]; + const directive = schema2 === null || schema2 === void 0 ? void 0 : schema2.getDirective(directiveName); + if (Array.isArray(arrayOrSingleValue)) { + for (const value of arrayOrSingleValue) { + directiveNodes.push(makeDirectiveNode(directiveName, value, directive)); + } + } else { + directiveNodes.push(makeDirectiveNode(directiveName, arrayOrSingleValue, directive)); + } + } + return directiveNodes; + } + async function validateGraphQlDocuments(schema2, documentFiles, effectiveRules = createDefaultRules()) { + const allFragmentMap = new Map(); + const documentFileObjectsToValidate = []; + for (const documentFile of documentFiles) { + if (documentFile.document) { + const definitionsToValidate = []; + for (const definitionNode of documentFile.document.definitions) { + if (definitionNode.kind === graphql.Kind.FRAGMENT_DEFINITION) { + allFragmentMap.set(definitionNode.name.value, definitionNode); + } else { + definitionsToValidate.push(definitionNode); + } + } + documentFileObjectsToValidate.push({ + location: documentFile.location, + document: { + kind: graphql.Kind.DOCUMENT, + definitions: definitionsToValidate + } + }); + } + } + const allErrors = []; + const allFragmentsDocument = { + kind: graphql.Kind.DOCUMENT, + definitions: [...allFragmentMap.values()] + }; + await Promise.all(documentFileObjectsToValidate.map(async (documentFile) => { + const documentToValidate = graphql.concatAST([allFragmentsDocument, documentFile.document]); + const errors = graphql.validate(schema2, documentToValidate, effectiveRules); + if (errors.length > 0) { + allErrors.push({ + filePath: documentFile.location, + errors + }); + } + })); + return allErrors; + } + function checkValidationErrors(loadDocumentErrors) { + if (loadDocumentErrors.length > 0) { + const errors = []; + for (const loadDocumentError of loadDocumentErrors) { + for (const graphQLError of loadDocumentError.errors) { + const error = new Error(); + error.name = "GraphQLDocumentError"; + error.message = `${error.name}: ${graphQLError.message}`; + error.stack = error.message; + if (graphQLError.locations) { + for (const location of graphQLError.locations) { + error.stack += ` + at ${loadDocumentError.filePath}:${location.line}:${location.column}`; + } + } + errors.push(error); + } + } + throw new exports2.AggregateError(errors, `GraphQL Document Validation failed with ${errors.length} errors; + ${errors.map((error, index) => `Error ${index}: ${error.stack}`).join("\n\n")}`); + } + } + function createDefaultRules() { + let ignored = ["NoUnusedFragmentsRule", "NoUnusedVariablesRule", "KnownDirectivesRule"]; + if (graphql.versionInfo.major < 15) { + ignored = ignored.map((rule) => rule.replace(/Rule$/, "")); + } + return graphql.specifiedRules.filter((f) => !ignored.includes(f.name)); + } + function stripBOM(content) { + content = content.toString(); + if (content.charCodeAt(0) === 65279) { + content = content.slice(1); + } + return content; + } + function parseBOM(content) { + return JSON.parse(stripBOM(content)); + } + function parseGraphQLJSON(location, jsonContent, options) { + let parsedJson = parseBOM(jsonContent); + if (parsedJson.data) { + parsedJson = parsedJson.data; + } + if (parsedJson.kind === "Document") { + return { + location, + document: parsedJson + }; + } else if (parsedJson.__schema) { + const schema2 = graphql.buildClientSchema(parsedJson, options); + return { + location, + schema: schema2 + }; + } else if (typeof parsedJson === "string") { + return { + location, + rawSDL: parsedJson + }; + } + throw new Error(`Not valid JSON content`); + } + var MAX_LINE_LENGTH = 80; + var commentsRegistry = {}; + function resetComments() { + commentsRegistry = {}; + } + function collectComment(node) { + var _a; + const entityName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value; + if (entityName == null) { + return; + } + pushComment(node, entityName); + switch (node.kind) { + case "EnumTypeDefinition": + if (node.values) { + for (const value of node.values) { + pushComment(value, entityName, value.name.value); + } + } + break; + case "ObjectTypeDefinition": + case "InputObjectTypeDefinition": + case "InterfaceTypeDefinition": + if (node.fields) { + for (const field of node.fields) { + pushComment(field, entityName, field.name.value); + if (isFieldDefinitionNode(field) && field.arguments) { + for (const arg of field.arguments) { + pushComment(arg, entityName, field.name.value, arg.name.value); + } + } + } + } + break; + } + } + function pushComment(node, entity, field, argument) { + const comment = getComment(node); + if (typeof comment !== "string" || comment.length === 0) { + return; + } + const keys = [entity]; + if (field) { + keys.push(field); + if (argument) { + keys.push(argument); + } + } + const path = keys.join("."); + if (!commentsRegistry[path]) { + commentsRegistry[path] = []; + } + commentsRegistry[path].push(comment); + } + function printComment(comment) { + return "\n# " + comment.replace(/\n/g, "\n# "); + } + function join2(maybeArray, separator) { + return maybeArray ? maybeArray.filter((x) => x).join(separator || "") : ""; + } + function hasMultilineItems(maybeArray) { + var _a; + return (_a = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some((str) => str.includes("\n"))) !== null && _a !== void 0 ? _a : false; + } + function addDescription(cb) { + return (node, _key, _parent, path, ancestors) => { + var _a; + const keys = []; + const parent = path.reduce((prev, key2) => { + if (["fields", "arguments", "values"].includes(key2) && prev.name) { + keys.push(prev.name.value); + } + return prev[key2]; + }, ancestors[0]); + const key = [...keys, (_a = parent === null || parent === void 0 ? void 0 : parent.name) === null || _a === void 0 ? void 0 : _a.value].filter(Boolean).join("."); + const items = []; + if (node.kind.includes("Definition") && commentsRegistry[key]) { + items.push(...commentsRegistry[key]); + } + return join2([...items.map(printComment), node.description, cb(node, _key, _parent, path, ancestors)], "\n"); + }; + } + function indent(maybeString) { + return maybeString && ` ${maybeString.replace(/\n/g, "\n ")}`; + } + function block(array) { + return array && array.length !== 0 ? `{ +${indent(join2(array, "\n"))} +}` : ""; + } + function wrap(start, maybeString, end) { + return maybeString ? start + maybeString + (end || "") : ""; + } + function printBlockString(value, isDescription = false) { + const escaped = value.replace(/"""/g, '\\"""'); + return (value[0] === " " || value[0] === " ") && value.indexOf("\n") === -1 ? `"""${escaped.replace(/"$/, '"\n')}"""` : `""" +${isDescription ? escaped : indent(escaped)} +"""`; + } + var printDocASTReducer = { + Name: { leave: (node) => node.value }, + Variable: { leave: (node) => "$" + node.name }, + Document: { + leave: (node) => join2(node.definitions, "\n\n") + }, + OperationDefinition: { + leave: (node) => { + const varDefs = wrap("(", join2(node.variableDefinitions, ", "), ")"); + const prefix = join2([node.operation, join2([node.name, varDefs]), join2(node.directives, " ")], " "); + return prefix + " " + node.selectionSet; + } + }, + VariableDefinition: { + leave: ({ variable, type, defaultValue, directives }) => variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join2(directives, " ")) + }, + SelectionSet: { leave: ({ selections }) => block(selections) }, + Field: { + leave({ alias, name, arguments: args, directives, selectionSet }) { + const prefix = wrap("", alias, ": ") + name; + let argsLine = prefix + wrap("(", join2(args, ", "), ")"); + if (argsLine.length > MAX_LINE_LENGTH) { + argsLine = prefix + wrap("(\n", indent(join2(args, "\n")), "\n)"); + } + return join2([argsLine, join2(directives, " "), selectionSet], " "); + } + }, + Argument: { leave: ({ name, value }) => name + ": " + value }, + FragmentSpread: { + leave: ({ name, directives }) => "..." + name + wrap(" ", join2(directives, " ")) + }, + InlineFragment: { + leave: ({ typeCondition, directives, selectionSet }) => join2(["...", wrap("on ", typeCondition), join2(directives, " "), selectionSet], " ") + }, + FragmentDefinition: { + leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => `fragment ${name}${wrap("(", join2(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join2(directives, " "), " ")}` + selectionSet + }, + IntValue: { leave: ({ value }) => value }, + FloatValue: { leave: ({ value }) => value }, + StringValue: { + leave: ({ value, block: isBlockString }) => { + if (isBlockString) { + return printBlockString(value); + } + return JSON.stringify(value); + } + }, + BooleanValue: { leave: ({ value }) => value ? "true" : "false" }, + NullValue: { leave: () => "null" }, + EnumValue: { leave: ({ value }) => value }, + ListValue: { leave: ({ values }) => "[" + join2(values, ", ") + "]" }, + ObjectValue: { leave: ({ fields }) => "{" + join2(fields, ", ") + "}" }, + ObjectField: { leave: ({ name, value }) => name + ": " + value }, + Directive: { + leave: ({ name, arguments: args }) => "@" + name + wrap("(", join2(args, ", "), ")") + }, + NamedType: { leave: ({ name }) => name }, + ListType: { leave: ({ type }) => "[" + type + "]" }, + NonNullType: { leave: ({ type }) => type + "!" }, + SchemaDefinition: { + leave: ({ directives, operationTypes }) => join2(["schema", join2(directives, " "), block(operationTypes)], " ") + }, + OperationTypeDefinition: { + leave: ({ operation, type }) => operation + ": " + type + }, + ScalarTypeDefinition: { + leave: ({ name, directives }) => join2(["scalar", name, join2(directives, " ")], " ") + }, + ObjectTypeDefinition: { + leave: ({ name, interfaces, directives, fields }) => join2(["type", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " ") + }, + FieldDefinition: { + leave: ({ name, arguments: args, type, directives }) => name + (hasMultilineItems(args) ? wrap("(\n", indent(join2(args, "\n")), "\n)") : wrap("(", join2(args, ", "), ")")) + ": " + type + wrap(" ", join2(directives, " ")) + }, + InputValueDefinition: { + leave: ({ name, type, defaultValue, directives }) => join2([name + ": " + type, wrap("= ", defaultValue), join2(directives, " ")], " ") + }, + InterfaceTypeDefinition: { + leave: ({ name, interfaces, directives, fields }) => join2(["interface", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " ") + }, + UnionTypeDefinition: { + leave: ({ name, directives, types }) => join2(["union", name, join2(directives, " "), wrap("= ", join2(types, " | "))], " ") + }, + EnumTypeDefinition: { + leave: ({ name, directives, values }) => join2(["enum", name, join2(directives, " "), block(values)], " ") + }, + EnumValueDefinition: { + leave: ({ name, directives }) => join2([name, join2(directives, " ")], " ") + }, + InputObjectTypeDefinition: { + leave: ({ name, directives, fields }) => join2(["input", name, join2(directives, " "), block(fields)], " ") + }, + DirectiveDefinition: { + leave: ({ name, arguments: args, repeatable, locations }) => "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join2(args, "\n")), "\n)") : wrap("(", join2(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join2(locations, " | ") + }, + SchemaExtension: { + leave: ({ directives, operationTypes }) => join2(["extend schema", join2(directives, " "), block(operationTypes)], " ") + }, + ScalarTypeExtension: { + leave: ({ name, directives }) => join2(["extend scalar", name, join2(directives, " ")], " ") + }, + ObjectTypeExtension: { + leave: ({ name, interfaces, directives, fields }) => join2(["extend type", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " ") + }, + InterfaceTypeExtension: { + leave: ({ name, interfaces, directives, fields }) => join2(["extend interface", name, wrap("implements ", join2(interfaces, " & ")), join2(directives, " "), block(fields)], " ") + }, + UnionTypeExtension: { + leave: ({ name, directives, types }) => join2(["extend union", name, join2(directives, " "), wrap("= ", join2(types, " | "))], " ") + }, + EnumTypeExtension: { + leave: ({ name, directives, values }) => join2(["extend enum", name, join2(directives, " "), block(values)], " ") + }, + InputObjectTypeExtension: { + leave: ({ name, directives, fields }) => join2(["extend input", name, join2(directives, " "), block(fields)], " ") + } + }; + var printDocASTReducerWithComments = Object.keys(printDocASTReducer).reduce((prev, key) => __spreadProps(__spreadValues({}, prev), { + [key]: { + leave: addDescription(printDocASTReducer[key].leave) + } + }), {}); + function printWithComments(ast) { + return graphql.visit(ast, printDocASTReducerWithComments); + } + function isFieldDefinitionNode(node) { + return node.kind === "FieldDefinition"; + } + function getDescription(node, options) { + if (node.description != null) { + return node.description.value; + } + if (options === null || options === void 0 ? void 0 : options.commentDescriptions) { + return getComment(node); + } + } + function getComment(node) { + const rawValue = getLeadingCommentBlock(node); + if (rawValue !== void 0) { + return dedentBlockStringValue(` +${rawValue}`); + } + } + function getLeadingCommentBlock(node) { + const loc = node.loc; + if (!loc) { + return; + } + const comments = []; + let token = loc.startToken.prev; + while (token != null && token.kind === graphql.TokenKind.COMMENT && token.next != null && token.prev != null && token.line + 1 === token.next.line && token.line !== token.prev.line) { + const value = String(token.value); + comments.push(value); + token = token.prev; + } + return comments.length > 0 ? comments.reverse().join("\n") : void 0; + } + function dedentBlockStringValue(rawString) { + const lines = rawString.split(/\r\n|[\n\r]/g); + const commonIndent = getBlockStringIndentation(lines); + if (commonIndent !== 0) { + for (let i = 1; i < lines.length; i++) { + lines[i] = lines[i].slice(commonIndent); + } + } + while (lines.length > 0 && isBlank(lines[0])) { + lines.shift(); + } + while (lines.length > 0 && isBlank(lines[lines.length - 1])) { + lines.pop(); + } + return lines.join("\n"); + } + function getBlockStringIndentation(lines) { + let commonIndent = null; + for (let i = 1; i < lines.length; i++) { + const line = lines[i]; + const indent2 = leadingWhitespace(line); + if (indent2 === line.length) { + continue; + } + if (commonIndent === null || indent2 < commonIndent) { + commonIndent = indent2; + if (commonIndent === 0) { + break; + } + } + } + return commonIndent === null ? 0 : commonIndent; + } + function leadingWhitespace(str) { + let i = 0; + while (i < str.length && (str[i] === " " || str[i] === " ")) { + i++; + } + return i; + } + function isBlank(str) { + return leadingWhitespace(str) === str.length; + } + function parseGraphQLSDL(location, rawSDL, options = {}) { + let document2; + try { + if (options.commentDescriptions && rawSDL.includes("#")) { + document2 = transformCommentsToDescriptions(rawSDL, options); + if (options.noLocation) { + document2 = graphql.parse(graphql.print(document2), options); + } + } else { + document2 = graphql.parse(new graphql.Source(rawSDL, location), options); + } + } catch (e) { + if (e.message.includes("EOF") && rawSDL.replace(/(\#[^*]*)/g, "").trim() === "") { + document2 = { + kind: graphql.Kind.DOCUMENT, + definitions: [] + }; + } else { + throw e; + } + } + return { + location, + document: document2 + }; + } + function transformCommentsToDescriptions(sourceSdl, options = {}) { + const parsedDoc = graphql.parse(sourceSdl, __spreadProps(__spreadValues({}, options), { + noLocation: false + })); + const modifiedDoc = graphql.visit(parsedDoc, { + leave: (node) => { + if (isDescribable(node)) { + const rawValue = getLeadingCommentBlock(node); + if (rawValue !== void 0) { + const commentsBlock = dedentBlockStringValue("\n" + rawValue); + const isBlock = commentsBlock.includes("\n"); + if (!node.description) { + return __spreadProps(__spreadValues({}, node), { + description: { + kind: graphql.Kind.STRING, + value: commentsBlock, + block: isBlock + } + }); + } else { + return __spreadProps(__spreadValues({}, node), { + description: __spreadProps(__spreadValues({}, node.description), { + value: node.description.value + "\n" + commentsBlock, + block: true + }) + }); + } + } + } + } + }); + return modifiedDoc; + } + function isDescribable(node) { + return graphql.isTypeSystemDefinitionNode(node) || node.kind === graphql.Kind.FIELD_DEFINITION || node.kind === graphql.Kind.INPUT_VALUE_DEFINITION || node.kind === graphql.Kind.ENUM_VALUE_DEFINITION; + } + var operationVariables = []; + var fieldTypeMap = new Map(); + function addOperationVariable(variable) { + operationVariables.push(variable); + } + function resetOperationVariables() { + operationVariables = []; + } + function resetFieldMap() { + fieldTypeMap = new Map(); + } + function buildOperationNodeForField({ schema: schema2, kind, field, models, ignore = [], depthLimit, circularReferenceDepth, argNames, selectedFields = true }) { + resetOperationVariables(); + resetFieldMap(); + const rootTypeNames = getRootTypeNames(schema2); + const operationNode = buildOperationAndCollectVariables({ + schema: schema2, + fieldName: field, + kind, + models: models || [], + ignore, + depthLimit: depthLimit || Infinity, + circularReferenceDepth: circularReferenceDepth || 1, + argNames, + selectedFields, + rootTypeNames + }); + operationNode.variableDefinitions = [...operationVariables]; + resetOperationVariables(); + resetFieldMap(); + return operationNode; + } + function buildOperationAndCollectVariables({ schema: schema2, fieldName, kind, models, ignore, depthLimit, circularReferenceDepth, argNames, selectedFields, rootTypeNames }) { + const type = getDefinedRootType(schema2, kind); + const field = type.getFields()[fieldName]; + const operationName = `${fieldName}_${kind}`; + if (field.args) { + for (const arg of field.args) { + const argName = arg.name; + if (!argNames || argNames.includes(argName)) { + addOperationVariable(resolveVariable(arg, argName)); + } + } + } + return { + kind: graphql.Kind.OPERATION_DEFINITION, + operation: kind, + name: { + kind: graphql.Kind.NAME, + value: operationName + }, + variableDefinitions: [], + selectionSet: { + kind: graphql.Kind.SELECTION_SET, + selections: [ + resolveField({ + type, + field, + models, + firstCall: true, + path: [], + ancestors: [], + ignore, + depthLimit, + circularReferenceDepth, + schema: schema2, + depth: 0, + argNames, + selectedFields, + rootTypeNames + }) + ] + } + }; + } + function resolveSelectionSet({ parent, type, models, firstCall, path, ancestors, ignore, depthLimit, circularReferenceDepth, schema: schema2, depth, argNames, selectedFields, rootTypeNames }) { + if (typeof selectedFields === "boolean" && depth > depthLimit) { + return; + } + if (graphql.isUnionType(type)) { + const types = type.getTypes(); + return { + kind: graphql.Kind.SELECTION_SET, + selections: types.filter((t) => !hasCircularRef([...ancestors, t], { + depth: circularReferenceDepth + })).map((t) => { + return { + kind: graphql.Kind.INLINE_FRAGMENT, + typeCondition: { + kind: graphql.Kind.NAMED_TYPE, + name: { + kind: graphql.Kind.NAME, + value: t.name + } + }, + selectionSet: resolveSelectionSet({ + parent: type, + type: t, + models, + path, + ancestors, + ignore, + depthLimit, + circularReferenceDepth, + schema: schema2, + depth, + argNames, + selectedFields, + rootTypeNames + }) + }; + }).filter((fragmentNode) => { + var _a, _b; + return ((_b = (_a = fragmentNode === null || fragmentNode === void 0 ? void 0 : fragmentNode.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) === null || _b === void 0 ? void 0 : _b.length) > 0; + }) + }; + } + if (graphql.isInterfaceType(type)) { + const types = Object.values(schema2.getTypeMap()).filter((t) => graphql.isObjectType(t) && t.getInterfaces().includes(type)); + return { + kind: graphql.Kind.SELECTION_SET, + selections: types.filter((t) => !hasCircularRef([...ancestors, t], { + depth: circularReferenceDepth + })).map((t) => { + return { + kind: graphql.Kind.INLINE_FRAGMENT, + typeCondition: { + kind: graphql.Kind.NAMED_TYPE, + name: { + kind: graphql.Kind.NAME, + value: t.name + } + }, + selectionSet: resolveSelectionSet({ + parent: type, + type: t, + models, + path, + ancestors, + ignore, + depthLimit, + circularReferenceDepth, + schema: schema2, + depth, + argNames, + selectedFields, + rootTypeNames + }) + }; + }).filter((fragmentNode) => { + var _a, _b; + return ((_b = (_a = fragmentNode === null || fragmentNode === void 0 ? void 0 : fragmentNode.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) === null || _b === void 0 ? void 0 : _b.length) > 0; + }) + }; + } + if (graphql.isObjectType(type) && !rootTypeNames.has(type.name)) { + const isIgnored = ignore.includes(type.name) || ignore.includes(`${parent.name}.${path[path.length - 1]}`); + const isModel = models.includes(type.name); + if (!firstCall && isModel && !isIgnored) { + return { + kind: graphql.Kind.SELECTION_SET, + selections: [ + { + kind: graphql.Kind.FIELD, + name: { + kind: graphql.Kind.NAME, + value: "id" + } + } + ] + }; + } + const fields = type.getFields(); + return { + kind: graphql.Kind.SELECTION_SET, + selections: Object.keys(fields).filter((fieldName) => { + return !hasCircularRef([...ancestors, graphql.getNamedType(fields[fieldName].type)], { + depth: circularReferenceDepth + }); + }).map((fieldName) => { + const selectedSubFields = typeof selectedFields === "object" ? selectedFields[fieldName] : true; + if (selectedSubFields) { + return resolveField({ + type, + field: fields[fieldName], + models, + path: [...path, fieldName], + ancestors, + ignore, + depthLimit, + circularReferenceDepth, + schema: schema2, + depth, + argNames, + selectedFields: selectedSubFields, + rootTypeNames + }); + } + return null; + }).filter((f) => { + var _a, _b; + if (f == null) { + return false; + } else if ("selectionSet" in f) { + return !!((_b = (_a = f.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) === null || _b === void 0 ? void 0 : _b.length); + } + return true; + }) + }; + } + } + function resolveVariable(arg, name) { + function resolveVariableType(type) { + if (graphql.isListType(type)) { + return { + kind: graphql.Kind.LIST_TYPE, + type: resolveVariableType(type.ofType) + }; + } + if (graphql.isNonNullType(type)) { + return { + kind: graphql.Kind.NON_NULL_TYPE, + type: resolveVariableType(type.ofType) + }; + } + return { + kind: graphql.Kind.NAMED_TYPE, + name: { + kind: graphql.Kind.NAME, + value: type.name + } + }; + } + return { + kind: graphql.Kind.VARIABLE_DEFINITION, + variable: { + kind: graphql.Kind.VARIABLE, + name: { + kind: graphql.Kind.NAME, + value: name || arg.name + } + }, + type: resolveVariableType(arg.type) + }; + } + function getArgumentName(name, path) { + return [...path, name].join("_"); + } + function resolveField({ type, field, models, firstCall, path, ancestors, ignore, depthLimit, circularReferenceDepth, schema: schema2, depth, argNames, selectedFields, rootTypeNames }) { + const namedType = graphql.getNamedType(field.type); + let args = []; + let removeField = false; + if (field.args && field.args.length) { + args = field.args.map((arg) => { + const argumentName = getArgumentName(arg.name, path); + if (argNames && !argNames.includes(argumentName)) { + if (graphql.isNonNullType(arg.type)) { + removeField = true; + } + return null; + } + if (!firstCall) { + addOperationVariable(resolveVariable(arg, argumentName)); + } + return { + kind: graphql.Kind.ARGUMENT, + name: { + kind: graphql.Kind.NAME, + value: arg.name + }, + value: { + kind: graphql.Kind.VARIABLE, + name: { + kind: graphql.Kind.NAME, + value: getArgumentName(arg.name, path) + } + } + }; + }).filter(Boolean); + } + if (removeField) { + return null; + } + const fieldPath = [...path, field.name]; + const fieldPathStr = fieldPath.join("."); + let fieldName = field.name; + if (fieldTypeMap.has(fieldPathStr) && fieldTypeMap.get(fieldPathStr) !== field.type.toString()) { + fieldName += field.type.toString().replace("!", "NonNull"); + } + fieldTypeMap.set(fieldPathStr, field.type.toString()); + if (!graphql.isScalarType(namedType) && !graphql.isEnumType(namedType)) { + return __spreadProps(__spreadValues({ + kind: graphql.Kind.FIELD, + name: { + kind: graphql.Kind.NAME, + value: field.name + } + }, fieldName !== field.name && { alias: { kind: graphql.Kind.NAME, value: fieldName } }), { + selectionSet: resolveSelectionSet({ + parent: type, + type: namedType, + models, + firstCall, + path: fieldPath, + ancestors: [...ancestors, type], + ignore, + depthLimit, + circularReferenceDepth, + schema: schema2, + depth: depth + 1, + argNames, + selectedFields, + rootTypeNames + }) || void 0, + arguments: args + }); + } + return __spreadProps(__spreadValues({ + kind: graphql.Kind.FIELD, + name: { + kind: graphql.Kind.NAME, + value: field.name + } + }, fieldName !== field.name && { alias: { kind: graphql.Kind.NAME, value: fieldName } }), { + arguments: args + }); + } + function hasCircularRef(types, config = { + depth: 1 + }) { + const type = types[types.length - 1]; + if (graphql.isScalarType(type)) { + return false; + } + const size = types.filter((t) => t.name === type.name).length; + return size > config.depth; + } + (function(MapperKind) { + MapperKind["TYPE"] = "MapperKind.TYPE"; + MapperKind["SCALAR_TYPE"] = "MapperKind.SCALAR_TYPE"; + MapperKind["ENUM_TYPE"] = "MapperKind.ENUM_TYPE"; + MapperKind["COMPOSITE_TYPE"] = "MapperKind.COMPOSITE_TYPE"; + MapperKind["OBJECT_TYPE"] = "MapperKind.OBJECT_TYPE"; + MapperKind["INPUT_OBJECT_TYPE"] = "MapperKind.INPUT_OBJECT_TYPE"; + MapperKind["ABSTRACT_TYPE"] = "MapperKind.ABSTRACT_TYPE"; + MapperKind["UNION_TYPE"] = "MapperKind.UNION_TYPE"; + MapperKind["INTERFACE_TYPE"] = "MapperKind.INTERFACE_TYPE"; + MapperKind["ROOT_OBJECT"] = "MapperKind.ROOT_OBJECT"; + MapperKind["QUERY"] = "MapperKind.QUERY"; + MapperKind["MUTATION"] = "MapperKind.MUTATION"; + MapperKind["SUBSCRIPTION"] = "MapperKind.SUBSCRIPTION"; + MapperKind["DIRECTIVE"] = "MapperKind.DIRECTIVE"; + MapperKind["FIELD"] = "MapperKind.FIELD"; + MapperKind["COMPOSITE_FIELD"] = "MapperKind.COMPOSITE_FIELD"; + MapperKind["OBJECT_FIELD"] = "MapperKind.OBJECT_FIELD"; + MapperKind["ROOT_FIELD"] = "MapperKind.ROOT_FIELD"; + MapperKind["QUERY_ROOT_FIELD"] = "MapperKind.QUERY_ROOT_FIELD"; + MapperKind["MUTATION_ROOT_FIELD"] = "MapperKind.MUTATION_ROOT_FIELD"; + MapperKind["SUBSCRIPTION_ROOT_FIELD"] = "MapperKind.SUBSCRIPTION_ROOT_FIELD"; + MapperKind["INTERFACE_FIELD"] = "MapperKind.INTERFACE_FIELD"; + MapperKind["INPUT_OBJECT_FIELD"] = "MapperKind.INPUT_OBJECT_FIELD"; + MapperKind["ARGUMENT"] = "MapperKind.ARGUMENT"; + MapperKind["ENUM_VALUE"] = "MapperKind.ENUM_VALUE"; + })(exports2.MapperKind || (exports2.MapperKind = {})); + function getObjectTypeFromTypeMap(typeMap, type) { + if (type) { + const maybeObjectType = typeMap[type.name]; + if (graphql.isObjectType(maybeObjectType)) { + return maybeObjectType; + } + } + } + function createNamedStub(name, type) { + let constructor; + if (type === "object") { + constructor = graphql.GraphQLObjectType; + } else if (type === "interface") { + constructor = graphql.GraphQLInterfaceType; + } else { + constructor = graphql.GraphQLInputObjectType; + } + return new constructor({ + name, + fields: { + _fake: { + type: graphql.GraphQLString + } + } + }); + } + function createStub(node, type) { + switch (node.kind) { + case graphql.Kind.LIST_TYPE: + return new graphql.GraphQLList(createStub(node.type, type)); + case graphql.Kind.NON_NULL_TYPE: + return new graphql.GraphQLNonNull(createStub(node.type, type)); + default: + if (type === "output") { + return createNamedStub(node.name.value, "object"); + } + return createNamedStub(node.name.value, "input"); + } + } + function isNamedStub(type) { + if ("getFields" in type) { + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + return field.name === "_fake"; + } + } + return false; + } + function getBuiltInForStub(type) { + switch (type.name) { + case graphql.GraphQLInt.name: + return graphql.GraphQLInt; + case graphql.GraphQLFloat.name: + return graphql.GraphQLFloat; + case graphql.GraphQLString.name: + return graphql.GraphQLString; + case graphql.GraphQLBoolean.name: + return graphql.GraphQLBoolean; + case graphql.GraphQLID.name: + return graphql.GraphQLID; + default: + return type; + } + } + function rewireTypes(originalTypeMap, directives) { + const referenceTypeMap = Object.create(null); + for (const typeName in originalTypeMap) { + referenceTypeMap[typeName] = originalTypeMap[typeName]; + } + const newTypeMap = Object.create(null); + for (const typeName in referenceTypeMap) { + const namedType = referenceTypeMap[typeName]; + if (namedType == null || typeName.startsWith("__")) { + continue; + } + const newName = namedType.name; + if (newName.startsWith("__")) { + continue; + } + if (newTypeMap[newName] != null) { + throw new Error(`Duplicate schema type name ${newName}`); + } + newTypeMap[newName] = namedType; + } + for (const typeName in newTypeMap) { + newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]); + } + const newDirectives = directives.map((directive) => rewireDirective(directive)); + return { + typeMap: newTypeMap, + directives: newDirectives + }; + function rewireDirective(directive) { + if (graphql.isSpecifiedDirective(directive)) { + return directive; + } + const directiveConfig = directive.toConfig(); + directiveConfig.args = rewireArgs(directiveConfig.args); + return new graphql.GraphQLDirective(directiveConfig); + } + function rewireArgs(args) { + const rewiredArgs = {}; + for (const argName in args) { + const arg = args[argName]; + const rewiredArgType = rewireType(arg.type); + if (rewiredArgType != null) { + arg.type = rewiredArgType; + rewiredArgs[argName] = arg; + } + } + return rewiredArgs; + } + function rewireNamedType(type) { + if (graphql.isObjectType(type)) { + const config = type.toConfig(); + const newConfig = __spreadProps(__spreadValues({}, config), { + fields: () => rewireFields(config.fields), + interfaces: () => rewireNamedTypes(config.interfaces) + }); + return new graphql.GraphQLObjectType(newConfig); + } else if (graphql.isInterfaceType(type)) { + const config = type.toConfig(); + const newConfig = __spreadProps(__spreadValues({}, config), { + fields: () => rewireFields(config.fields) + }); + if ("interfaces" in newConfig) { + newConfig.interfaces = () => rewireNamedTypes(config.interfaces); + } + return new graphql.GraphQLInterfaceType(newConfig); + } else if (graphql.isUnionType(type)) { + const config = type.toConfig(); + const newConfig = __spreadProps(__spreadValues({}, config), { + types: () => rewireNamedTypes(config.types) + }); + return new graphql.GraphQLUnionType(newConfig); + } else if (graphql.isInputObjectType(type)) { + const config = type.toConfig(); + const newConfig = __spreadProps(__spreadValues({}, config), { + fields: () => rewireInputFields(config.fields) + }); + return new graphql.GraphQLInputObjectType(newConfig); + } else if (graphql.isEnumType(type)) { + const enumConfig = type.toConfig(); + return new graphql.GraphQLEnumType(enumConfig); + } else if (graphql.isScalarType(type)) { + if (graphql.isSpecifiedScalarType(type)) { + return type; + } + const scalarConfig = type.toConfig(); + return new graphql.GraphQLScalarType(scalarConfig); + } + throw new Error(`Unexpected schema type: ${type}`); + } + function rewireFields(fields) { + const rewiredFields = {}; + for (const fieldName in fields) { + const field = fields[fieldName]; + const rewiredFieldType = rewireType(field.type); + if (rewiredFieldType != null && field.args) { + field.type = rewiredFieldType; + field.args = rewireArgs(field.args); + rewiredFields[fieldName] = field; + } + } + return rewiredFields; + } + function rewireInputFields(fields) { + const rewiredFields = {}; + for (const fieldName in fields) { + const field = fields[fieldName]; + const rewiredFieldType = rewireType(field.type); + if (rewiredFieldType != null) { + field.type = rewiredFieldType; + rewiredFields[fieldName] = field; + } + } + return rewiredFields; + } + function rewireNamedTypes(namedTypes) { + const rewiredTypes = []; + for (const namedType of namedTypes) { + const rewiredType = rewireType(namedType); + if (rewiredType != null) { + rewiredTypes.push(rewiredType); + } + } + return rewiredTypes; + } + function rewireType(type) { + if (graphql.isListType(type)) { + const rewiredType = rewireType(type.ofType); + return rewiredType != null ? new graphql.GraphQLList(rewiredType) : null; + } else if (graphql.isNonNullType(type)) { + const rewiredType = rewireType(type.ofType); + return rewiredType != null ? new graphql.GraphQLNonNull(rewiredType) : null; + } else if (graphql.isNamedType(type)) { + let rewiredType = referenceTypeMap[type.name]; + if (rewiredType === void 0) { + rewiredType = isNamedStub(type) ? getBuiltInForStub(type) : rewireNamedType(type); + newTypeMap[rewiredType.name] = referenceTypeMap[type.name] = rewiredType; + } + return rewiredType != null ? newTypeMap[rewiredType.name] : null; + } + return null; + } + } + function transformInputValue(type, value, inputLeafValueTransformer = null, inputObjectValueTransformer = null) { + if (value == null) { + return value; + } + const nullableType = graphql.getNullableType(type); + if (graphql.isLeafType(nullableType)) { + return inputLeafValueTransformer != null ? inputLeafValueTransformer(nullableType, value) : value; + } else if (graphql.isListType(nullableType)) { + return value.map((listMember) => transformInputValue(nullableType.ofType, listMember, inputLeafValueTransformer, inputObjectValueTransformer)); + } else if (graphql.isInputObjectType(nullableType)) { + const fields = nullableType.getFields(); + const newValue = {}; + for (const key in value) { + const field = fields[key]; + if (field != null) { + newValue[key] = transformInputValue(field.type, value[key], inputLeafValueTransformer, inputObjectValueTransformer); + } + } + return inputObjectValueTransformer != null ? inputObjectValueTransformer(nullableType, newValue) : newValue; + } + } + function serializeInputValue(type, value) { + return transformInputValue(type, value, (t, v) => t.serialize(v)); + } + function parseInputValue(type, value) { + return transformInputValue(type, value, (t, v) => t.parseValue(v)); + } + function parseInputValueLiteral(type, value) { + return transformInputValue(type, value, (t, v) => t.parseLiteral(v, {})); + } + function mapSchema(schema2, schemaMapper = {}) { + const newTypeMap = mapArguments(mapFields(mapTypes(mapDefaultValues(mapEnumValues(mapTypes(mapDefaultValues(schema2.getTypeMap(), schema2, serializeInputValue), schema2, schemaMapper, (type) => graphql.isLeafType(type)), schema2, schemaMapper), schema2, parseInputValue), schema2, schemaMapper, (type) => !graphql.isLeafType(type)), schema2, schemaMapper), schema2, schemaMapper); + const originalDirectives = schema2.getDirectives(); + const newDirectives = mapDirectives(originalDirectives, schema2, schemaMapper); + const { typeMap, directives } = rewireTypes(newTypeMap, newDirectives); + return new graphql.GraphQLSchema(__spreadProps(__spreadValues({}, schema2.toConfig()), { + query: getObjectTypeFromTypeMap(typeMap, getObjectTypeFromTypeMap(newTypeMap, schema2.getQueryType())), + mutation: getObjectTypeFromTypeMap(typeMap, getObjectTypeFromTypeMap(newTypeMap, schema2.getMutationType())), + subscription: getObjectTypeFromTypeMap(typeMap, getObjectTypeFromTypeMap(newTypeMap, schema2.getSubscriptionType())), + types: Object.values(typeMap), + directives + })); + } + function mapTypes(originalTypeMap, schema2, schemaMapper, testFn = () => true) { + const newTypeMap = {}; + for (const typeName in originalTypeMap) { + if (!typeName.startsWith("__")) { + const originalType = originalTypeMap[typeName]; + if (originalType == null || !testFn(originalType)) { + newTypeMap[typeName] = originalType; + continue; + } + const typeMapper = getTypeMapper(schema2, schemaMapper, typeName); + if (typeMapper == null) { + newTypeMap[typeName] = originalType; + continue; + } + const maybeNewType = typeMapper(originalType, schema2); + if (maybeNewType === void 0) { + newTypeMap[typeName] = originalType; + continue; + } + newTypeMap[typeName] = maybeNewType; + } + } + return newTypeMap; + } + function mapEnumValues(originalTypeMap, schema2, schemaMapper) { + const enumValueMapper = getEnumValueMapper(schemaMapper); + if (!enumValueMapper) { + return originalTypeMap; + } + return mapTypes(originalTypeMap, schema2, { + [exports2.MapperKind.ENUM_TYPE]: (type) => { + const config = type.toConfig(); + const originalEnumValueConfigMap = config.values; + const newEnumValueConfigMap = {}; + for (const externalValue in originalEnumValueConfigMap) { + const originalEnumValueConfig = originalEnumValueConfigMap[externalValue]; + const mappedEnumValue = enumValueMapper(originalEnumValueConfig, type.name, schema2, externalValue); + if (mappedEnumValue === void 0) { + newEnumValueConfigMap[externalValue] = originalEnumValueConfig; + } else if (Array.isArray(mappedEnumValue)) { + const [newExternalValue, newEnumValueConfig] = mappedEnumValue; + newEnumValueConfigMap[newExternalValue] = newEnumValueConfig === void 0 ? originalEnumValueConfig : newEnumValueConfig; + } else if (mappedEnumValue !== null) { + newEnumValueConfigMap[externalValue] = mappedEnumValue; + } + } + return correctASTNodes(new graphql.GraphQLEnumType(__spreadProps(__spreadValues({}, config), { + values: newEnumValueConfigMap + }))); + } + }, (type) => graphql.isEnumType(type)); + } + function mapDefaultValues(originalTypeMap, schema2, fn) { + const newTypeMap = mapArguments(originalTypeMap, schema2, { + [exports2.MapperKind.ARGUMENT]: (argumentConfig) => { + if (argumentConfig.defaultValue === void 0) { + return argumentConfig; + } + const maybeNewType = getNewType(originalTypeMap, argumentConfig.type); + if (maybeNewType != null) { + return __spreadProps(__spreadValues({}, argumentConfig), { + defaultValue: fn(maybeNewType, argumentConfig.defaultValue) + }); + } + } + }); + return mapFields(newTypeMap, schema2, { + [exports2.MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig) => { + if (inputFieldConfig.defaultValue === void 0) { + return inputFieldConfig; + } + const maybeNewType = getNewType(newTypeMap, inputFieldConfig.type); + if (maybeNewType != null) { + return __spreadProps(__spreadValues({}, inputFieldConfig), { + defaultValue: fn(maybeNewType, inputFieldConfig.defaultValue) + }); + } + } + }); + } + function getNewType(newTypeMap, type) { + if (graphql.isListType(type)) { + const newType = getNewType(newTypeMap, type.ofType); + return newType != null ? new graphql.GraphQLList(newType) : null; + } else if (graphql.isNonNullType(type)) { + const newType = getNewType(newTypeMap, type.ofType); + return newType != null ? new graphql.GraphQLNonNull(newType) : null; + } else if (graphql.isNamedType(type)) { + const newType = newTypeMap[type.name]; + return newType != null ? newType : null; + } + return null; + } + function mapFields(originalTypeMap, schema2, schemaMapper) { + const newTypeMap = {}; + for (const typeName in originalTypeMap) { + if (!typeName.startsWith("__")) { + const originalType = originalTypeMap[typeName]; + if (!graphql.isObjectType(originalType) && !graphql.isInterfaceType(originalType) && !graphql.isInputObjectType(originalType)) { + newTypeMap[typeName] = originalType; + continue; + } + const fieldMapper = getFieldMapper(schema2, schemaMapper, typeName); + if (fieldMapper == null) { + newTypeMap[typeName] = originalType; + continue; + } + const config = originalType.toConfig(); + const originalFieldConfigMap = config.fields; + const newFieldConfigMap = {}; + for (const fieldName in originalFieldConfigMap) { + const originalFieldConfig = originalFieldConfigMap[fieldName]; + const mappedField = fieldMapper(originalFieldConfig, fieldName, typeName, schema2); + if (mappedField === void 0) { + newFieldConfigMap[fieldName] = originalFieldConfig; + } else if (Array.isArray(mappedField)) { + const [newFieldName, newFieldConfig] = mappedField; + if (newFieldConfig.astNode != null) { + newFieldConfig.astNode = __spreadProps(__spreadValues({}, newFieldConfig.astNode), { + name: __spreadProps(__spreadValues({}, newFieldConfig.astNode.name), { + value: newFieldName + }) + }); + } + newFieldConfigMap[newFieldName] = newFieldConfig === void 0 ? originalFieldConfig : newFieldConfig; + } else if (mappedField !== null) { + newFieldConfigMap[fieldName] = mappedField; + } + } + if (graphql.isObjectType(originalType)) { + newTypeMap[typeName] = correctASTNodes(new graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + }))); + } else if (graphql.isInterfaceType(originalType)) { + newTypeMap[typeName] = correctASTNodes(new graphql.GraphQLInterfaceType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + }))); + } else { + newTypeMap[typeName] = correctASTNodes(new graphql.GraphQLInputObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + }))); + } + } + } + return newTypeMap; + } + function mapArguments(originalTypeMap, schema2, schemaMapper) { + const newTypeMap = {}; + for (const typeName in originalTypeMap) { + if (!typeName.startsWith("__")) { + const originalType = originalTypeMap[typeName]; + if (!graphql.isObjectType(originalType) && !graphql.isInterfaceType(originalType)) { + newTypeMap[typeName] = originalType; + continue; + } + const argumentMapper = getArgumentMapper(schemaMapper); + if (argumentMapper == null) { + newTypeMap[typeName] = originalType; + continue; + } + const config = originalType.toConfig(); + const originalFieldConfigMap = config.fields; + const newFieldConfigMap = {}; + for (const fieldName in originalFieldConfigMap) { + const originalFieldConfig = originalFieldConfigMap[fieldName]; + const originalArgumentConfigMap = originalFieldConfig.args; + if (originalArgumentConfigMap == null) { + newFieldConfigMap[fieldName] = originalFieldConfig; + continue; + } + const argumentNames = Object.keys(originalArgumentConfigMap); + if (!argumentNames.length) { + newFieldConfigMap[fieldName] = originalFieldConfig; + continue; + } + const newArgumentConfigMap = {}; + for (const argumentName of argumentNames) { + const originalArgumentConfig = originalArgumentConfigMap[argumentName]; + const mappedArgument = argumentMapper(originalArgumentConfig, fieldName, typeName, schema2); + if (mappedArgument === void 0) { + newArgumentConfigMap[argumentName] = originalArgumentConfig; + } else if (Array.isArray(mappedArgument)) { + const [newArgumentName, newArgumentConfig] = mappedArgument; + newArgumentConfigMap[newArgumentName] = newArgumentConfig; + } else if (mappedArgument !== null) { + newArgumentConfigMap[argumentName] = mappedArgument; + } + } + newFieldConfigMap[fieldName] = __spreadProps(__spreadValues({}, originalFieldConfig), { + args: newArgumentConfigMap + }); + } + if (graphql.isObjectType(originalType)) { + newTypeMap[typeName] = new graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + })); + } else if (graphql.isInterfaceType(originalType)) { + newTypeMap[typeName] = new graphql.GraphQLInterfaceType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + })); + } else { + newTypeMap[typeName] = new graphql.GraphQLInputObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + })); + } + } + } + return newTypeMap; + } + function mapDirectives(originalDirectives, schema2, schemaMapper) { + const directiveMapper = getDirectiveMapper(schemaMapper); + if (directiveMapper == null) { + return originalDirectives.slice(); + } + const newDirectives = []; + for (const directive of originalDirectives) { + const mappedDirective = directiveMapper(directive, schema2); + if (mappedDirective === void 0) { + newDirectives.push(directive); + } else if (mappedDirective !== null) { + newDirectives.push(mappedDirective); + } + } + return newDirectives; + } + function getTypeSpecifiers(schema2, typeName) { + var _a, _b, _c; + const type = schema2.getType(typeName); + const specifiers = [exports2.MapperKind.TYPE]; + if (graphql.isObjectType(type)) { + specifiers.push(exports2.MapperKind.COMPOSITE_TYPE, exports2.MapperKind.OBJECT_TYPE); + if (typeName === ((_a = schema2.getQueryType()) === null || _a === void 0 ? void 0 : _a.name)) { + specifiers.push(exports2.MapperKind.ROOT_OBJECT, exports2.MapperKind.QUERY); + } else if (typeName === ((_b = schema2.getMutationType()) === null || _b === void 0 ? void 0 : _b.name)) { + specifiers.push(exports2.MapperKind.ROOT_OBJECT, exports2.MapperKind.MUTATION); + } else if (typeName === ((_c = schema2.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name)) { + specifiers.push(exports2.MapperKind.ROOT_OBJECT, exports2.MapperKind.SUBSCRIPTION); + } + } else if (graphql.isInputObjectType(type)) { + specifiers.push(exports2.MapperKind.INPUT_OBJECT_TYPE); + } else if (graphql.isInterfaceType(type)) { + specifiers.push(exports2.MapperKind.COMPOSITE_TYPE, exports2.MapperKind.ABSTRACT_TYPE, exports2.MapperKind.INTERFACE_TYPE); + } else if (graphql.isUnionType(type)) { + specifiers.push(exports2.MapperKind.COMPOSITE_TYPE, exports2.MapperKind.ABSTRACT_TYPE, exports2.MapperKind.UNION_TYPE); + } else if (graphql.isEnumType(type)) { + specifiers.push(exports2.MapperKind.ENUM_TYPE); + } else if (graphql.isScalarType(type)) { + specifiers.push(exports2.MapperKind.SCALAR_TYPE); + } + return specifiers; + } + function getTypeMapper(schema2, schemaMapper, typeName) { + const specifiers = getTypeSpecifiers(schema2, typeName); + let typeMapper; + const stack = [...specifiers]; + while (!typeMapper && stack.length > 0) { + const next = stack.pop(); + typeMapper = schemaMapper[next]; + } + return typeMapper != null ? typeMapper : null; + } + function getFieldSpecifiers(schema2, typeName) { + var _a, _b, _c; + const type = schema2.getType(typeName); + const specifiers = [exports2.MapperKind.FIELD]; + if (graphql.isObjectType(type)) { + specifiers.push(exports2.MapperKind.COMPOSITE_FIELD, exports2.MapperKind.OBJECT_FIELD); + if (typeName === ((_a = schema2.getQueryType()) === null || _a === void 0 ? void 0 : _a.name)) { + specifiers.push(exports2.MapperKind.ROOT_FIELD, exports2.MapperKind.QUERY_ROOT_FIELD); + } else if (typeName === ((_b = schema2.getMutationType()) === null || _b === void 0 ? void 0 : _b.name)) { + specifiers.push(exports2.MapperKind.ROOT_FIELD, exports2.MapperKind.MUTATION_ROOT_FIELD); + } else if (typeName === ((_c = schema2.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name)) { + specifiers.push(exports2.MapperKind.ROOT_FIELD, exports2.MapperKind.SUBSCRIPTION_ROOT_FIELD); + } + } else if (graphql.isInterfaceType(type)) { + specifiers.push(exports2.MapperKind.COMPOSITE_FIELD, exports2.MapperKind.INTERFACE_FIELD); + } else if (graphql.isInputObjectType(type)) { + specifiers.push(exports2.MapperKind.INPUT_OBJECT_FIELD); + } + return specifiers; + } + function getFieldMapper(schema2, schemaMapper, typeName) { + const specifiers = getFieldSpecifiers(schema2, typeName); + let fieldMapper; + const stack = [...specifiers]; + while (!fieldMapper && stack.length > 0) { + const next = stack.pop(); + fieldMapper = schemaMapper[next]; + } + return fieldMapper !== null && fieldMapper !== void 0 ? fieldMapper : null; + } + function getArgumentMapper(schemaMapper) { + const argumentMapper = schemaMapper[exports2.MapperKind.ARGUMENT]; + return argumentMapper != null ? argumentMapper : null; + } + function getDirectiveMapper(schemaMapper) { + const directiveMapper = schemaMapper[exports2.MapperKind.DIRECTIVE]; + return directiveMapper != null ? directiveMapper : null; + } + function getEnumValueMapper(schemaMapper) { + const enumValueMapper = schemaMapper[exports2.MapperKind.ENUM_VALUE]; + return enumValueMapper != null ? enumValueMapper : null; + } + function correctASTNodes(type) { + if (graphql.isObjectType(type)) { + const config = type.toConfig(); + if (config.astNode != null) { + const fields = []; + for (const fieldName in config.fields) { + const fieldConfig = config.fields[fieldName]; + if (fieldConfig.astNode != null) { + fields.push(fieldConfig.astNode); + } + } + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + kind: graphql.Kind.OBJECT_TYPE_DEFINITION, + fields + }); + } + if (config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.OBJECT_TYPE_EXTENSION, + fields: void 0 + })); + } + return new graphql.GraphQLObjectType(config); + } else if (graphql.isInterfaceType(type)) { + const config = type.toConfig(); + if (config.astNode != null) { + const fields = []; + for (const fieldName in config.fields) { + const fieldConfig = config.fields[fieldName]; + if (fieldConfig.astNode != null) { + fields.push(fieldConfig.astNode); + } + } + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + kind: graphql.Kind.INTERFACE_TYPE_DEFINITION, + fields + }); + } + if (config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.INTERFACE_TYPE_EXTENSION, + fields: void 0 + })); + } + return new graphql.GraphQLInterfaceType(config); + } else if (graphql.isInputObjectType(type)) { + const config = type.toConfig(); + if (config.astNode != null) { + const fields = []; + for (const fieldName in config.fields) { + const fieldConfig = config.fields[fieldName]; + if (fieldConfig.astNode != null) { + fields.push(fieldConfig.astNode); + } + } + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + kind: graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION, + fields + }); + } + if (config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION, + fields: void 0 + })); + } + return new graphql.GraphQLInputObjectType(config); + } else if (graphql.isEnumType(type)) { + const config = type.toConfig(); + if (config.astNode != null) { + const values = []; + for (const enumKey in config.values) { + const enumValueConfig = config.values[enumKey]; + if (enumValueConfig.astNode != null) { + values.push(enumValueConfig.astNode); + } + } + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + values + }); + } + if (config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + values: void 0 + })); + } + return new graphql.GraphQLEnumType(config); + } else { + return type; + } + } + function filterSchema({ schema: schema2, typeFilter = () => true, fieldFilter = void 0, rootFieldFilter = void 0, objectFieldFilter = void 0, interfaceFieldFilter = void 0, inputObjectFieldFilter = void 0, argumentFilter = void 0 }) { + const filteredSchema = mapSchema(schema2, { + [exports2.MapperKind.QUERY]: (type) => filterRootFields(type, "Query", rootFieldFilter, argumentFilter), + [exports2.MapperKind.MUTATION]: (type) => filterRootFields(type, "Mutation", rootFieldFilter, argumentFilter), + [exports2.MapperKind.SUBSCRIPTION]: (type) => filterRootFields(type, "Subscription", rootFieldFilter, argumentFilter), + [exports2.MapperKind.OBJECT_TYPE]: (type) => typeFilter(type.name, type) ? filterElementFields(graphql.GraphQLObjectType, type, objectFieldFilter || fieldFilter, argumentFilter) : null, + [exports2.MapperKind.INTERFACE_TYPE]: (type) => typeFilter(type.name, type) ? filterElementFields(graphql.GraphQLInterfaceType, type, interfaceFieldFilter || fieldFilter, argumentFilter) : null, + [exports2.MapperKind.INPUT_OBJECT_TYPE]: (type) => typeFilter(type.name, type) ? filterElementFields(graphql.GraphQLInputObjectType, type, inputObjectFieldFilter || fieldFilter) : null, + [exports2.MapperKind.UNION_TYPE]: (type) => typeFilter(type.name, type) ? void 0 : null, + [exports2.MapperKind.ENUM_TYPE]: (type) => typeFilter(type.name, type) ? void 0 : null, + [exports2.MapperKind.SCALAR_TYPE]: (type) => typeFilter(type.name, type) ? void 0 : null + }); + return filteredSchema; + } + function filterRootFields(type, operation, rootFieldFilter, argumentFilter) { + if (rootFieldFilter || argumentFilter) { + const config = type.toConfig(); + for (const fieldName in config.fields) { + const field = config.fields[fieldName]; + if (rootFieldFilter && !rootFieldFilter(operation, fieldName, config.fields[fieldName])) { + delete config.fields[fieldName]; + } else if (argumentFilter && field.args) { + for (const argName in field.args) { + if (!argumentFilter(operation, fieldName, argName, field.args[argName])) { + delete field.args[argName]; + } + } + } + } + return new graphql.GraphQLObjectType(config); + } + return type; + } + function filterElementFields(ElementConstructor, type, fieldFilter, argumentFilter) { + if (fieldFilter || argumentFilter) { + const config = type.toConfig(); + for (const fieldName in config.fields) { + const field = config.fields[fieldName]; + if (fieldFilter && !fieldFilter(type.name, fieldName, config.fields[fieldName])) { + delete config.fields[fieldName]; + } else if (argumentFilter && "args" in field) { + for (const argName in field.args) { + if (!argumentFilter(type.name, fieldName, argName, field.args[argName])) { + delete field.args[argName]; + } + } + } + } + return new ElementConstructor(config); + } + } + function healSchema(schema2) { + healTypes(schema2.getTypeMap(), schema2.getDirectives()); + return schema2; + } + function healTypes(originalTypeMap, directives) { + const actualNamedTypeMap = Object.create(null); + for (const typeName in originalTypeMap) { + const namedType = originalTypeMap[typeName]; + if (namedType == null || typeName.startsWith("__")) { + continue; + } + const actualName = namedType.name; + if (actualName.startsWith("__")) { + continue; + } + if (actualName in actualNamedTypeMap) { + throw new Error(`Duplicate schema type name ${actualName}`); + } + actualNamedTypeMap[actualName] = namedType; + } + for (const typeName in actualNamedTypeMap) { + const namedType = actualNamedTypeMap[typeName]; + originalTypeMap[typeName] = namedType; + } + for (const decl of directives) { + decl.args = decl.args.filter((arg) => { + arg.type = healType(arg.type); + return arg.type !== null; + }); + } + for (const typeName in originalTypeMap) { + const namedType = originalTypeMap[typeName]; + if (!typeName.startsWith("__") && typeName in actualNamedTypeMap) { + if (namedType != null) { + healNamedType(namedType); + } + } + } + for (const typeName in originalTypeMap) { + if (!typeName.startsWith("__") && !(typeName in actualNamedTypeMap)) { + delete originalTypeMap[typeName]; + } + } + function healNamedType(type) { + if (graphql.isObjectType(type)) { + healFields(type); + healInterfaces(type); + return; + } else if (graphql.isInterfaceType(type)) { + healFields(type); + if ("getInterfaces" in type) { + healInterfaces(type); + } + return; + } else if (graphql.isUnionType(type)) { + healUnderlyingTypes(type); + return; + } else if (graphql.isInputObjectType(type)) { + healInputFields(type); + return; + } else if (graphql.isLeafType(type)) { + return; + } + throw new Error(`Unexpected schema type: ${type}`); + } + function healFields(type) { + const fieldMap = type.getFields(); + for (const [key, field] of Object.entries(fieldMap)) { + field.args.map((arg) => { + arg.type = healType(arg.type); + return arg.type === null ? null : arg; + }).filter(Boolean); + field.type = healType(field.type); + if (field.type === null) { + delete fieldMap[key]; + } + } + } + function healInterfaces(type) { + if ("getInterfaces" in type) { + const interfaces = type.getInterfaces(); + interfaces.push(...interfaces.splice(0).map((iface) => healType(iface)).filter(Boolean)); + } + } + function healInputFields(type) { + const fieldMap = type.getFields(); + for (const [key, field] of Object.entries(fieldMap)) { + field.type = healType(field.type); + if (field.type === null) { + delete fieldMap[key]; + } + } + } + function healUnderlyingTypes(type) { + const types = type.getTypes(); + types.push(...types.splice(0).map((t) => healType(t)).filter(Boolean)); + } + function healType(type) { + if (graphql.isListType(type)) { + const healedType = healType(type.ofType); + return healedType != null ? new graphql.GraphQLList(healedType) : null; + } else if (graphql.isNonNullType(type)) { + const healedType = healType(type.ofType); + return healedType != null ? new graphql.GraphQLNonNull(healedType) : null; + } else if (graphql.isNamedType(type)) { + const officialType = originalTypeMap[type.name]; + if (officialType && type !== officialType) { + return officialType; + } + } + return type; + } + } + function getResolversFromSchema(schema2) { + var _a, _b; + const resolvers2 = Object.create(null); + const typeMap = schema2.getTypeMap(); + for (const typeName in typeMap) { + if (!typeName.startsWith("__")) { + const type = typeMap[typeName]; + if (graphql.isScalarType(type)) { + if (!graphql.isSpecifiedScalarType(type)) { + const config = type.toConfig(); + delete config.astNode; + resolvers2[typeName] = new graphql.GraphQLScalarType(config); + } + } else if (graphql.isEnumType(type)) { + resolvers2[typeName] = {}; + const values = type.getValues(); + for (const value of values) { + resolvers2[typeName][value.name] = value.value; + } + } else if (graphql.isInterfaceType(type)) { + if (type.resolveType != null) { + resolvers2[typeName] = { + __resolveType: type.resolveType + }; + } + } else if (graphql.isUnionType(type)) { + if (type.resolveType != null) { + resolvers2[typeName] = { + __resolveType: type.resolveType + }; + } + } else if (graphql.isObjectType(type)) { + resolvers2[typeName] = {}; + if (type.isTypeOf != null) { + resolvers2[typeName].__isTypeOf = type.isTypeOf; + } + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + if (field.subscribe != null) { + resolvers2[typeName][fieldName] = resolvers2[typeName][fieldName] || {}; + resolvers2[typeName][fieldName].subscribe = field.subscribe; + } + if (field.resolve != null && ((_a = field.resolve) === null || _a === void 0 ? void 0 : _a.name) !== "defaultFieldResolver" && ((_b = field.resolve) === null || _b === void 0 ? void 0 : _b.name) !== "defaultMergedResolver") { + resolvers2[typeName][fieldName] = resolvers2[typeName][fieldName] || {}; + resolvers2[typeName][fieldName].resolve = field.resolve; + } + } + } + } + } + return resolvers2; + } + function forEachField(schema2, fn) { + const typeMap = schema2.getTypeMap(); + for (const typeName in typeMap) { + const type = typeMap[typeName]; + if (!graphql.getNamedType(type).name.startsWith("__") && graphql.isObjectType(type)) { + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + fn(field, typeName, fieldName); + } + } + } + } + function forEachDefaultValue(schema2, fn) { + const typeMap = schema2.getTypeMap(); + for (const typeName in typeMap) { + const type = typeMap[typeName]; + if (!graphql.getNamedType(type).name.startsWith("__")) { + if (graphql.isObjectType(type)) { + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + for (const arg of field.args) { + arg.defaultValue = fn(arg.type, arg.defaultValue); + } + } + } else if (graphql.isInputObjectType(type)) { + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + field.defaultValue = fn(field.type, field.defaultValue); + } + } + } + } + } + function addTypes(schema2, newTypesOrDirectives) { + const config = schema2.toConfig(); + const originalTypeMap = {}; + for (const type of config.types) { + originalTypeMap[type.name] = type; + } + const originalDirectiveMap = {}; + for (const directive of config.directives) { + originalDirectiveMap[directive.name] = directive; + } + for (const newTypeOrDirective of newTypesOrDirectives) { + if (graphql.isNamedType(newTypeOrDirective)) { + originalTypeMap[newTypeOrDirective.name] = newTypeOrDirective; + } else if (graphql.isDirective(newTypeOrDirective)) { + originalDirectiveMap[newTypeOrDirective.name] = newTypeOrDirective; + } + } + const { typeMap, directives } = rewireTypes(originalTypeMap, Object.values(originalDirectiveMap)); + return new graphql.GraphQLSchema(__spreadProps(__spreadValues({}, config), { + query: getObjectTypeFromTypeMap(typeMap, schema2.getQueryType()), + mutation: getObjectTypeFromTypeMap(typeMap, schema2.getMutationType()), + subscription: getObjectTypeFromTypeMap(typeMap, schema2.getSubscriptionType()), + types: Object.values(typeMap), + directives + })); + } + function pruneSchema(schema2, options = {}) { + const pruningContext = createPruningContext(schema2); + visitTypes(pruningContext); + const types = Object.values(schema2.getTypeMap()); + const typesToPrune = new Set(); + for (const type of types) { + if (type.name.startsWith("__")) { + continue; + } + if (options.skipPruning && options.skipPruning(type)) { + continue; + } + if (graphql.isObjectType(type) || graphql.isInputObjectType(type)) { + if (!Object.keys(type.getFields()).length && !options.skipEmptyCompositeTypePruning || pruningContext.unusedTypes[type.name] && !options.skipUnusedTypesPruning) { + typesToPrune.add(type.name); + } + } else if (graphql.isUnionType(type)) { + if (!type.getTypes().length && !options.skipEmptyUnionPruning || pruningContext.unusedTypes[type.name] && !options.skipUnusedTypesPruning) { + typesToPrune.add(type.name); + } + } else if (graphql.isInterfaceType(type)) { + const implementations = getImplementations(pruningContext, type); + if (!Object.keys(type.getFields()).length && !options.skipEmptyCompositeTypePruning || implementations && !Object.keys(implementations).length && !options.skipUnimplementedInterfacesPruning || pruningContext.unusedTypes[type.name] && !options.skipUnusedTypesPruning) { + typesToPrune.add(type.name); + } + } else { + if (pruningContext.unusedTypes[type.name] && !options.skipUnusedTypesPruning) { + typesToPrune.add(type.name); + } + } + } + const prunedSchema = mapSchema(schema2, { + [exports2.MapperKind.TYPE]: (type) => { + if (typesToPrune.has(type.name)) { + return null; + } + } + }); + return typesToPrune.size ? pruneSchema(prunedSchema, options) : prunedSchema; + } + function visitOutputType(visitedTypes, pruningContext, type) { + if (visitedTypes[type.name]) { + return; + } + visitedTypes[type.name] = true; + pruningContext.unusedTypes[type.name] = false; + if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) { + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + const namedType = graphql.getNamedType(field.type); + visitOutputType(visitedTypes, pruningContext, namedType); + for (const arg of field.args) { + const type2 = graphql.getNamedType(arg.type); + visitInputType(visitedTypes, pruningContext, type2); + } + } + if (graphql.isInterfaceType(type)) { + const implementations = getImplementations(pruningContext, type); + if (implementations) { + for (const typeName in implementations) { + visitOutputType(visitedTypes, pruningContext, pruningContext.schema.getType(typeName)); + } + } + } + if ("getInterfaces" in type) { + for (const iFace of type.getInterfaces()) { + visitOutputType(visitedTypes, pruningContext, iFace); + } + } + } else if (graphql.isUnionType(type)) { + const types = type.getTypes(); + for (const type2 of types) { + visitOutputType(visitedTypes, pruningContext, type2); + } + } + } + function createPruningContext(schema2) { + const pruningContext = { + schema: schema2, + unusedTypes: Object.create(null), + implementations: Object.create(null) + }; + for (const typeName in schema2.getTypeMap()) { + const type = schema2.getType(typeName); + if (type && "getInterfaces" in type) { + for (const iface of type.getInterfaces()) { + const implementations = getImplementations(pruningContext, iface); + if (implementations == null) { + pruningContext.implementations[iface.name] = Object.create(null); + } + pruningContext.implementations[iface.name][type.name] = true; + } + } + } + return pruningContext; + } + function getImplementations(pruningContext, type) { + return pruningContext.implementations[type.name]; + } + function visitInputType(visitedTypes, pruningContext, type) { + if (visitedTypes[type.name]) { + return; + } + pruningContext.unusedTypes[type.name] = false; + visitedTypes[type.name] = true; + if (graphql.isInputObjectType(type)) { + const fields = type.getFields(); + for (const fieldName in fields) { + const field = fields[fieldName]; + const namedType = graphql.getNamedType(field.type); + visitInputType(visitedTypes, pruningContext, namedType); + } + } + } + function visitTypes(pruningContext) { + const schema2 = pruningContext.schema; + for (const typeName in schema2.getTypeMap()) { + if (!typeName.startsWith("__")) { + pruningContext.unusedTypes[typeName] = true; + } + } + const visitedTypes = Object.create(null); + const rootTypes = getRootTypes(schema2); + for (const rootType of rootTypes) { + visitOutputType(visitedTypes, pruningContext, rootType); + } + for (const directive of schema2.getDirectives()) { + for (const arg of directive.args) { + const type = graphql.getNamedType(arg.type); + visitInputType(visitedTypes, pruningContext, type); + } + } + } + function mergeDeep(sources, respectPrototype = false) { + const target = sources[0] || {}; + const output = {}; + if (respectPrototype) { + Object.setPrototypeOf(output, Object.create(Object.getPrototypeOf(target))); + } + for (const source of sources) { + if (isObject(target) && isObject(source)) { + if (respectPrototype) { + const outputPrototype = Object.getPrototypeOf(output); + const sourcePrototype = Object.getPrototypeOf(source); + if (sourcePrototype) { + for (const key of Object.getOwnPropertyNames(sourcePrototype)) { + const descriptor = Object.getOwnPropertyDescriptor(sourcePrototype, key); + if (isSome(descriptor)) { + Object.defineProperty(outputPrototype, key, descriptor); + } + } + } + } + for (const key in source) { + if (isObject(source[key])) { + if (!(key in output)) { + Object.assign(output, { [key]: source[key] }); + } else { + output[key] = mergeDeep([output[key], source[key]], respectPrototype); + } + } else { + Object.assign(output, { [key]: source[key] }); + } + } + } + } + return output; + } + function isObject(item) { + return item && typeof item === "object" && !Array.isArray(item); + } + function parseSelectionSet(selectionSet, options) { + const query = graphql.parse(selectionSet, options).definitions[0]; + return query.selectionSet; + } + function getResponseKeyFromInfo(info) { + return info.fieldNodes[0].alias != null ? info.fieldNodes[0].alias.value : info.fieldName; + } + function appendObjectFields(schema2, typeName, additionalFields) { + if (schema2.getType(typeName) == null) { + return addTypes(schema2, [ + new graphql.GraphQLObjectType({ + name: typeName, + fields: additionalFields + }) + ]); + } + return mapSchema(schema2, { + [exports2.MapperKind.OBJECT_TYPE]: (type) => { + if (type.name === typeName) { + const config = type.toConfig(); + const originalFieldConfigMap = config.fields; + const newFieldConfigMap = {}; + for (const fieldName in originalFieldConfigMap) { + newFieldConfigMap[fieldName] = originalFieldConfigMap[fieldName]; + } + for (const fieldName in additionalFields) { + newFieldConfigMap[fieldName] = additionalFields[fieldName]; + } + return correctASTNodes(new graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + }))); + } + } + }); + } + function removeObjectFields(schema2, typeName, testFn) { + const removedFields = {}; + const newSchema = mapSchema(schema2, { + [exports2.MapperKind.OBJECT_TYPE]: (type) => { + if (type.name === typeName) { + const config = type.toConfig(); + const originalFieldConfigMap = config.fields; + const newFieldConfigMap = {}; + for (const fieldName in originalFieldConfigMap) { + const originalFieldConfig = originalFieldConfigMap[fieldName]; + if (testFn(fieldName, originalFieldConfig)) { + removedFields[fieldName] = originalFieldConfig; + } else { + newFieldConfigMap[fieldName] = originalFieldConfig; + } + } + return correctASTNodes(new graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + }))); + } + } + }); + return [newSchema, removedFields]; + } + function selectObjectFields(schema2, typeName, testFn) { + const selectedFields = {}; + mapSchema(schema2, { + [exports2.MapperKind.OBJECT_TYPE]: (type) => { + if (type.name === typeName) { + const config = type.toConfig(); + const originalFieldConfigMap = config.fields; + for (const fieldName in originalFieldConfigMap) { + const originalFieldConfig = originalFieldConfigMap[fieldName]; + if (testFn(fieldName, originalFieldConfig)) { + selectedFields[fieldName] = originalFieldConfig; + } + } + } + return void 0; + } + }); + return selectedFields; + } + function modifyObjectFields(schema2, typeName, testFn, newFields) { + const removedFields = {}; + const newSchema = mapSchema(schema2, { + [exports2.MapperKind.OBJECT_TYPE]: (type) => { + if (type.name === typeName) { + const config = type.toConfig(); + const originalFieldConfigMap = config.fields; + const newFieldConfigMap = {}; + for (const fieldName in originalFieldConfigMap) { + const originalFieldConfig = originalFieldConfigMap[fieldName]; + if (testFn(fieldName, originalFieldConfig)) { + removedFields[fieldName] = originalFieldConfig; + } else { + newFieldConfigMap[fieldName] = originalFieldConfig; + } + } + for (const fieldName in newFields) { + const fieldConfig = newFields[fieldName]; + newFieldConfigMap[fieldName] = fieldConfig; + } + return correctASTNodes(new graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), { + fields: newFieldConfigMap + }))); + } + } + }); + return [newSchema, removedFields]; + } + function renameType(type, newTypeName) { + if (graphql.isObjectType(type)) { + return new graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, type.toConfig()), { + name: newTypeName, + astNode: type.astNode == null ? type.astNode : __spreadProps(__spreadValues({}, type.astNode), { + name: __spreadProps(__spreadValues({}, type.astNode.name), { + value: newTypeName + }) + }), + extensionASTNodes: type.extensionASTNodes == null ? type.extensionASTNodes : type.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + name: __spreadProps(__spreadValues({}, node.name), { + value: newTypeName + }) + })) + })); + } else if (graphql.isInterfaceType(type)) { + return new graphql.GraphQLInterfaceType(__spreadProps(__spreadValues({}, type.toConfig()), { + name: newTypeName, + astNode: type.astNode == null ? type.astNode : __spreadProps(__spreadValues({}, type.astNode), { + name: __spreadProps(__spreadValues({}, type.astNode.name), { + value: newTypeName + }) + }), + extensionASTNodes: type.extensionASTNodes == null ? type.extensionASTNodes : type.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + name: __spreadProps(__spreadValues({}, node.name), { + value: newTypeName + }) + })) + })); + } else if (graphql.isUnionType(type)) { + return new graphql.GraphQLUnionType(__spreadProps(__spreadValues({}, type.toConfig()), { + name: newTypeName, + astNode: type.astNode == null ? type.astNode : __spreadProps(__spreadValues({}, type.astNode), { + name: __spreadProps(__spreadValues({}, type.astNode.name), { + value: newTypeName + }) + }), + extensionASTNodes: type.extensionASTNodes == null ? type.extensionASTNodes : type.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + name: __spreadProps(__spreadValues({}, node.name), { + value: newTypeName + }) + })) + })); + } else if (graphql.isInputObjectType(type)) { + return new graphql.GraphQLInputObjectType(__spreadProps(__spreadValues({}, type.toConfig()), { + name: newTypeName, + astNode: type.astNode == null ? type.astNode : __spreadProps(__spreadValues({}, type.astNode), { + name: __spreadProps(__spreadValues({}, type.astNode.name), { + value: newTypeName + }) + }), + extensionASTNodes: type.extensionASTNodes == null ? type.extensionASTNodes : type.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + name: __spreadProps(__spreadValues({}, node.name), { + value: newTypeName + }) + })) + })); + } else if (graphql.isEnumType(type)) { + return new graphql.GraphQLEnumType(__spreadProps(__spreadValues({}, type.toConfig()), { + name: newTypeName, + astNode: type.astNode == null ? type.astNode : __spreadProps(__spreadValues({}, type.astNode), { + name: __spreadProps(__spreadValues({}, type.astNode.name), { + value: newTypeName + }) + }), + extensionASTNodes: type.extensionASTNodes == null ? type.extensionASTNodes : type.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + name: __spreadProps(__spreadValues({}, node.name), { + value: newTypeName + }) + })) + })); + } else if (graphql.isScalarType(type)) { + return new graphql.GraphQLScalarType(__spreadProps(__spreadValues({}, type.toConfig()), { + name: newTypeName, + astNode: type.astNode == null ? type.astNode : __spreadProps(__spreadValues({}, type.astNode), { + name: __spreadProps(__spreadValues({}, type.astNode.name), { + value: newTypeName + }) + }), + extensionASTNodes: type.extensionASTNodes == null ? type.extensionASTNodes : type.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), { + name: __spreadProps(__spreadValues({}, node.name), { + value: newTypeName + }) + })) + })); + } + throw new Error(`Unknown type ${type}.`); + } + function mapAsyncIterator(iterator, callback, rejectCallback) { + let $return; + let abruptClose; + if (typeof iterator.return === "function") { + $return = iterator.return; + abruptClose = (error) => { + const rethrow = () => Promise.reject(error); + return $return.call(iterator).then(rethrow, rethrow); + }; + } + function mapResult(result) { + return result.done ? result : asyncMapValue(result.value, callback).then(iteratorResult, abruptClose); + } + let mapReject; + if (rejectCallback) { + const reject = rejectCallback; + mapReject = (error) => asyncMapValue(error, reject).then(iteratorResult, abruptClose); + } + return { + next() { + return iterator.next().then(mapResult, mapReject); + }, + return() { + return $return ? $return.call(iterator).then(mapResult, mapReject) : Promise.resolve({ value: void 0, done: true }); + }, + throw(error) { + if (typeof iterator.throw === "function") { + return iterator.throw(error).then(mapResult, mapReject); + } + return Promise.reject(error).catch(abruptClose); + }, + [Symbol.asyncIterator]() { + return this; + } + }; + } + function asyncMapValue(value, callback) { + return new Promise((resolve) => resolve(callback(value))); + } + function iteratorResult(value) { + return { value, done: false }; + } + function updateArgument(argumentNodes, variableDefinitionsMap, variableValues, argName, varName, type, value) { + argumentNodes[argName] = { + kind: graphql.Kind.ARGUMENT, + name: { + kind: graphql.Kind.NAME, + value: argName + }, + value: { + kind: graphql.Kind.VARIABLE, + name: { + kind: graphql.Kind.NAME, + value: varName + } + } + }; + variableDefinitionsMap[varName] = { + kind: graphql.Kind.VARIABLE_DEFINITION, + variable: { + kind: graphql.Kind.VARIABLE, + name: { + kind: graphql.Kind.NAME, + value: varName + } + }, + type: astFromType(type) + }; + if (value !== void 0) { + variableValues[varName] = value; + return; + } + if (varName in variableValues) { + delete variableValues[varName]; + } + } + function createVariableNameGenerator(variableDefinitionMap) { + let varCounter = 0; + return (argName) => { + let varName; + do { + varName = `_v${(varCounter++).toString()}_${argName}`; + } while (varName in variableDefinitionMap); + return varName; + }; + } + function implementsAbstractType(schema2, typeA, typeB) { + if (typeB == null || typeA == null) { + return false; + } else if (typeA === typeB) { + return true; + } else if (graphql.isCompositeType(typeA) && graphql.isCompositeType(typeB)) { + return graphql.doTypesOverlap(schema2, typeA, typeB); + } + return false; + } + function relocatedError(originalError, path) { + return new graphql.GraphQLError(originalError.message, originalError.nodes, originalError.source, originalError.positions, path === null ? void 0 : path === void 0 ? originalError.path : path, originalError.originalError, originalError.extensions); + } + function observableToAsyncIterable(observable) { + const pullQueue = []; + const pushQueue = []; + let listening = true; + const pushValue = (value) => { + if (pullQueue.length !== 0) { + pullQueue.shift()({ value, done: false }); + } else { + pushQueue.push({ value, done: false }); + } + }; + const pushError = (error) => { + if (pullQueue.length !== 0) { + pullQueue.shift()({ value: { errors: [error] }, done: false }); + } else { + pushQueue.push({ value: { errors: [error] }, done: false }); + } + }; + const pushDone = () => { + if (pullQueue.length !== 0) { + pullQueue.shift()({ done: true }); + } else { + pushQueue.push({ done: true }); + } + }; + const pullValue = () => new Promise((resolve) => { + if (pushQueue.length !== 0) { + const element = pushQueue.shift(); + resolve(element); + } else { + pullQueue.push(resolve); + } + }); + const subscription = observable.subscribe({ + next(value) { + pushValue(value); + }, + error(err) { + pushError(err); + }, + complete() { + pushDone(); + } + }); + const emptyQueue = () => { + if (listening) { + listening = false; + subscription.unsubscribe(); + for (const resolve of pullQueue) { + resolve({ value: void 0, done: true }); + } + pullQueue.length = 0; + pushQueue.length = 0; + } + }; + return { + next() { + return listening ? pullValue() : this.return(); + }, + return() { + emptyQueue(); + return Promise.resolve({ value: void 0, done: true }); + }, + throw(error) { + emptyQueue(); + return Promise.reject(error); + }, + [Symbol.asyncIterator]() { + return this; + } + }; + } + function getOperationASTFromDocument(documentNode, operationName) { + const doc = graphql.getOperationAST(documentNode, operationName); + if (!doc) { + throw new Error(`Cannot infer operation ${operationName || ""}`); + } + return doc; + } + var getOperationASTFromRequest = memoize1(function getOperationASTFromRequest2(request) { + return getOperationASTFromDocument(request.document, request.operationName); + }); + function collectFields(schema2, fragments, variableValues, runtimeType, selectionSet, fields, visitedFragmentNames) { + for (const selection of selectionSet.selections) { + switch (selection.kind) { + case graphql.Kind.FIELD: { + if (!shouldIncludeNode(variableValues, selection)) { + continue; + } + const name = getFieldEntryKey(selection); + const fieldList = fields.get(name); + if (fieldList !== void 0) { + fieldList.push(selection); + } else { + fields.set(name, [selection]); + } + break; + } + case graphql.Kind.INLINE_FRAGMENT: { + if (!shouldIncludeNode(variableValues, selection) || !doesFragmentConditionMatch(schema2, selection, runtimeType)) { + continue; + } + collectFields(schema2, fragments, variableValues, runtimeType, selection.selectionSet, fields, visitedFragmentNames); + break; + } + case graphql.Kind.FRAGMENT_SPREAD: { + const fragName = selection.name.value; + if (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection)) { + continue; + } + visitedFragmentNames.add(fragName); + const fragment = fragments[fragName]; + if (!fragment || !doesFragmentConditionMatch(schema2, fragment, runtimeType)) { + continue; + } + collectFields(schema2, fragments, variableValues, runtimeType, fragment.selectionSet, fields, visitedFragmentNames); + break; + } + } + } + return fields; + } + function shouldIncludeNode(variableValues, node) { + const skip = graphql.getDirectiveValues(graphql.GraphQLSkipDirective, node, variableValues); + if ((skip === null || skip === void 0 ? void 0 : skip["if"]) === true) { + return false; + } + const include = graphql.getDirectiveValues(graphql.GraphQLIncludeDirective, node, variableValues); + if ((include === null || include === void 0 ? void 0 : include["if"]) === false) { + return false; + } + return true; + } + function doesFragmentConditionMatch(schema2, fragment, type) { + const typeConditionNode = fragment.typeCondition; + if (!typeConditionNode) { + return true; + } + const conditionalType = graphql.typeFromAST(schema2, typeConditionNode); + if (conditionalType === type) { + return true; + } + if (graphql.isAbstractType(conditionalType)) { + const possibleTypes = schema2.getPossibleTypes(conditionalType); + return possibleTypes.includes(type); + } + return false; + } + function getFieldEntryKey(node) { + return node.alias ? node.alias.value : node.name.value; + } + var collectSubFields = memoize5(function collectSubFields2(schema2, fragments, variableValues, type, fieldNodes) { + const subFieldNodes = new Map(); + const visitedFragmentNames = new Set(); + for (const fieldNode of fieldNodes) { + if (fieldNode.selectionSet) { + collectFields(schema2, fragments, variableValues, type, fieldNode.selectionSet, subFieldNodes, visitedFragmentNames); + } + } + return subFieldNodes; + }); + function visitData(data, enter, leave) { + if (Array.isArray(data)) { + return data.map((value) => visitData(value, enter, leave)); + } else if (typeof data === "object") { + const newData = enter != null ? enter(data) : data; + if (newData != null) { + for (const key in newData) { + const value = newData[key]; + Object.defineProperty(newData, key, { + value: visitData(value, enter, leave) + }); + } + } + return leave != null ? leave(newData) : newData; + } + return data; + } + function visitErrors(errors, visitor) { + return errors.map((error) => visitor(error)); + } + function visitResult(result, request, schema2, resultVisitorMap, errorVisitorMap) { + const fragments = request.document.definitions.reduce((acc, def) => { + if (def.kind === graphql.Kind.FRAGMENT_DEFINITION) { + acc[def.name.value] = def; + } + return acc; + }, {}); + const variableValues = request.variables || {}; + const errorInfo = { + segmentInfoMap: new Map(), + unpathedErrors: new Set() + }; + const data = result.data; + const errors = result.errors; + const visitingErrors = errors != null && errorVisitorMap != null; + const operationDocumentNode = getOperationASTFromRequest(request); + if (data != null && operationDocumentNode != null) { + result.data = visitRoot(data, operationDocumentNode, schema2, fragments, variableValues, resultVisitorMap, visitingErrors ? errors : void 0, errorInfo); + } + if (errors != null && errorVisitorMap) { + result.errors = visitErrorsByType(errors, errorVisitorMap, errorInfo); + } + return result; + } + function visitErrorsByType(errors, errorVisitorMap, errorInfo) { + const segmentInfoMap = errorInfo.segmentInfoMap; + const unpathedErrors = errorInfo.unpathedErrors; + const unpathedErrorVisitor = errorVisitorMap["__unpathed"]; + return errors.map((originalError) => { + const pathSegmentsInfo = segmentInfoMap.get(originalError); + const newError = pathSegmentsInfo == null ? originalError : pathSegmentsInfo.reduceRight((acc, segmentInfo) => { + const typeName = segmentInfo.type.name; + const typeVisitorMap = errorVisitorMap[typeName]; + if (typeVisitorMap == null) { + return acc; + } + const errorVisitor = typeVisitorMap[segmentInfo.fieldName]; + return errorVisitor == null ? acc : errorVisitor(acc, segmentInfo.pathIndex); + }, originalError); + if (unpathedErrorVisitor && unpathedErrors.has(originalError)) { + return unpathedErrorVisitor(newError); + } + return newError; + }); + } + function visitRoot(root, operation, schema2, fragments, variableValues, resultVisitorMap, errors, errorInfo) { + const operationRootType = graphql.getOperationRootType(schema2, operation); + const collectedFields = collectFields(schema2, fragments, variableValues, operationRootType, operation.selectionSet, new Map(), new Set()); + return visitObjectValue(root, operationRootType, collectedFields, schema2, fragments, variableValues, resultVisitorMap, 0, errors, errorInfo); + } + function visitObjectValue(object, type, fieldNodeMap, schema2, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo) { + const fieldMap = type.getFields(); + const typeVisitorMap = resultVisitorMap === null || resultVisitorMap === void 0 ? void 0 : resultVisitorMap[type.name]; + const enterObject = typeVisitorMap === null || typeVisitorMap === void 0 ? void 0 : typeVisitorMap.__enter; + const newObject = enterObject != null ? enterObject(object) : object; + let sortedErrors; + let errorMap = null; + if (errors != null) { + sortedErrors = sortErrorsByPathSegment(errors, pathIndex); + errorMap = sortedErrors.errorMap; + for (const error of sortedErrors.unpathedErrors) { + errorInfo.unpathedErrors.add(error); + } + } + for (const [responseKey, subFieldNodes] of fieldNodeMap) { + const fieldName = subFieldNodes[0].name.value; + const fieldType = fieldName === "__typename" ? graphql.TypeNameMetaFieldDef.type : fieldMap[fieldName].type; + const newPathIndex = pathIndex + 1; + let fieldErrors; + if (errorMap) { + fieldErrors = errorMap[responseKey]; + if (fieldErrors != null) { + delete errorMap[responseKey]; + } + addPathSegmentInfo(type, fieldName, newPathIndex, fieldErrors, errorInfo); + } + const newValue = visitFieldValue(object[responseKey], fieldType, subFieldNodes, schema2, fragments, variableValues, resultVisitorMap, newPathIndex, fieldErrors, errorInfo); + updateObject(newObject, responseKey, newValue, typeVisitorMap, fieldName); + } + const oldTypename = newObject.__typename; + if (oldTypename != null) { + updateObject(newObject, "__typename", oldTypename, typeVisitorMap, "__typename"); + } + if (errorMap) { + for (const errorsKey in errorMap) { + const errors2 = errorMap[errorsKey]; + for (const error of errors2) { + errorInfo.unpathedErrors.add(error); + } + } + } + const leaveObject = typeVisitorMap === null || typeVisitorMap === void 0 ? void 0 : typeVisitorMap.__leave; + return leaveObject != null ? leaveObject(newObject) : newObject; + } + function updateObject(object, responseKey, newValue, typeVisitorMap, fieldName) { + if (typeVisitorMap == null) { + object[responseKey] = newValue; + return; + } + const fieldVisitor = typeVisitorMap[fieldName]; + if (fieldVisitor == null) { + object[responseKey] = newValue; + return; + } + const visitedValue = fieldVisitor(newValue); + if (visitedValue === void 0) { + delete object[responseKey]; + return; + } + object[responseKey] = visitedValue; + } + function visitListValue(list, returnType, fieldNodes, schema2, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo) { + return list.map((listMember) => visitFieldValue(listMember, returnType, fieldNodes, schema2, fragments, variableValues, resultVisitorMap, pathIndex + 1, errors, errorInfo)); + } + function visitFieldValue(value, returnType, fieldNodes, schema2, fragments, variableValues, resultVisitorMap, pathIndex, errors = [], errorInfo) { + if (value == null) { + return value; + } + const nullableType = graphql.getNullableType(returnType); + if (graphql.isListType(nullableType)) { + return visitListValue(value, nullableType.ofType, fieldNodes, schema2, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo); + } else if (graphql.isAbstractType(nullableType)) { + const finalType = schema2.getType(value.__typename); + const collectedFields = collectSubFields(schema2, fragments, variableValues, finalType, fieldNodes); + return visitObjectValue(value, finalType, collectedFields, schema2, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo); + } else if (graphql.isObjectType(nullableType)) { + const collectedFields = collectSubFields(schema2, fragments, variableValues, nullableType, fieldNodes); + return visitObjectValue(value, nullableType, collectedFields, schema2, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo); + } + const typeVisitorMap = resultVisitorMap === null || resultVisitorMap === void 0 ? void 0 : resultVisitorMap[nullableType.name]; + if (typeVisitorMap == null) { + return value; + } + const visitedValue = typeVisitorMap(value); + return visitedValue === void 0 ? value : visitedValue; + } + function sortErrorsByPathSegment(errors, pathIndex) { + var _a; + const errorMap = Object.create(null); + const unpathedErrors = new Set(); + for (const error of errors) { + const pathSegment = (_a = error.path) === null || _a === void 0 ? void 0 : _a[pathIndex]; + if (pathSegment == null) { + unpathedErrors.add(error); + continue; + } + if (pathSegment in errorMap) { + errorMap[pathSegment].push(error); + } else { + errorMap[pathSegment] = [error]; + } + } + return { + errorMap, + unpathedErrors + }; + } + function addPathSegmentInfo(type, fieldName, pathIndex, errors = [], errorInfo) { + for (const error of errors) { + const segmentInfo = { + type, + fieldName, + pathIndex + }; + const pathSegmentsInfo = errorInfo.segmentInfoMap.get(error); + if (pathSegmentsInfo == null) { + errorInfo.segmentInfoMap.set(error, [segmentInfo]); + } else { + pathSegmentsInfo.push(segmentInfo); + } + } + } + function valueMatchesCriteria(value, criteria) { + if (value == null) { + return value === criteria; + } else if (Array.isArray(value)) { + return Array.isArray(criteria) && value.every((val, index) => valueMatchesCriteria(val, criteria[index])); + } else if (typeof value === "object") { + return typeof criteria === "object" && criteria && Object.keys(criteria).every((propertyName) => valueMatchesCriteria(value[propertyName], criteria[propertyName])); + } else if (criteria instanceof RegExp) { + return criteria.test(value); + } + return value === criteria; + } + function isAsyncIterable(value) { + return typeof value === "object" && value != null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function"; + } + function isDocumentNode(object) { + return object && typeof object === "object" && "kind" in object && object.kind === graphql.Kind.DOCUMENT; + } + async function defaultAsyncIteratorReturn(value) { + return { value, done: true }; + } + var proxyMethodFactory = memoize2(function proxyMethodFactory2(target, targetMethod) { + return function proxyMethod(...args) { + return Reflect.apply(targetMethod, target, args); + }; + }); + function getAsyncIteratorWithCancel(asyncIterator, onCancel) { + return new Proxy(asyncIterator, { + has(asyncIterator2, prop) { + if (prop === "return") { + return true; + } + return Reflect.has(asyncIterator2, prop); + }, + get(asyncIterator2, prop, receiver) { + const existingPropValue = Reflect.get(asyncIterator2, prop, receiver); + if (prop === "return") { + const existingReturn = existingPropValue || defaultAsyncIteratorReturn; + return async function returnWithCancel(value) { + const returnValue = await onCancel(value); + return Reflect.apply(existingReturn, asyncIterator2, [returnValue]); + }; + } else if (typeof existingPropValue === "function") { + return proxyMethodFactory(asyncIterator2, existingPropValue); + } + return existingPropValue; + } + }); + } + function getAsyncIterableWithCancel(asyncIterable, onCancel) { + return new Proxy(asyncIterable, { + get(asyncIterable2, prop, receiver) { + const existingPropValue = Reflect.get(asyncIterable2, prop, receiver); + if (Symbol.asyncIterator === prop) { + return function asyncIteratorFactory() { + const asyncIterator = Reflect.apply(existingPropValue, asyncIterable2, []); + return getAsyncIteratorWithCancel(asyncIterator, onCancel); + }; + } else if (typeof existingPropValue === "function") { + return proxyMethodFactory(asyncIterable2, existingPropValue); + } + return existingPropValue; + } + }); + } + function buildFixedSchema(schema2, options) { + const document2 = getDocumentNodeFromSchema(schema2); + return graphql.buildASTSchema(document2, __spreadValues({}, options || {})); + } + function fixSchemaAst(schema2, options) { + let schemaWithValidAst = void 0; + if (!schema2.astNode || !schema2.extensionASTNodes) { + schemaWithValidAst = buildFixedSchema(schema2, options); + } + if (!schema2.astNode && (schemaWithValidAst === null || schemaWithValidAst === void 0 ? void 0 : schemaWithValidAst.astNode)) { + schema2.astNode = schemaWithValidAst.astNode; + } + if (!schema2.extensionASTNodes && (schemaWithValidAst === null || schemaWithValidAst === void 0 ? void 0 : schemaWithValidAst.astNode)) { + schema2.extensionASTNodes = schemaWithValidAst.extensionASTNodes; + } + return schema2; + } + exports2.addTypes = addTypes; + exports2.appendObjectFields = appendObjectFields; + exports2.asArray = asArray; + exports2.assertSome = assertSome; + exports2.astFromArg = astFromArg; + exports2.astFromDirective = astFromDirective; + exports2.astFromEnumType = astFromEnumType; + exports2.astFromEnumValue = astFromEnumValue; + exports2.astFromField = astFromField; + exports2.astFromInputField = astFromInputField; + exports2.astFromInputObjectType = astFromInputObjectType; + exports2.astFromInterfaceType = astFromInterfaceType; + exports2.astFromObjectType = astFromObjectType; + exports2.astFromScalarType = astFromScalarType; + exports2.astFromSchema = astFromSchema; + exports2.astFromUnionType = astFromUnionType; + exports2.astFromValueUntyped = astFromValueUntyped; + exports2.buildOperationNodeForField = buildOperationNodeForField; + exports2.checkValidationErrors = checkValidationErrors; + exports2.collectComment = collectComment; + exports2.collectFields = collectFields; + exports2.collectSubFields = collectSubFields; + exports2.compareNodes = compareNodes; + exports2.compareStrings = compareStrings; + exports2.correctASTNodes = correctASTNodes; + exports2.createDefaultRules = createDefaultRules; + exports2.createNamedStub = createNamedStub; + exports2.createStub = createStub; + exports2.createVariableNameGenerator = createVariableNameGenerator; + exports2.dedentBlockStringValue = dedentBlockStringValue; + exports2.filterSchema = filterSchema; + exports2.fixSchemaAst = fixSchemaAst; + exports2.forEachDefaultValue = forEachDefaultValue; + exports2.forEachField = forEachField; + exports2.getArgumentValues = getArgumentValues; + exports2.getAsyncIterableWithCancel = getAsyncIterableWithCancel; + exports2.getAsyncIteratorWithCancel = getAsyncIteratorWithCancel; + exports2.getBlockStringIndentation = getBlockStringIndentation; + exports2.getBuiltInForStub = getBuiltInForStub; + exports2.getComment = getComment; + exports2.getDefinedRootType = getDefinedRootType; + exports2.getDeprecatableDirectiveNodes = getDeprecatableDirectiveNodes; + exports2.getDescription = getDescription; + exports2.getDirective = getDirective; + exports2.getDirectiveInExtensions = getDirectiveInExtensions; + exports2.getDirectiveNodes = getDirectiveNodes; + exports2.getDirectives = getDirectives; + exports2.getDirectivesInExtensions = getDirectivesInExtensions; + exports2.getDocumentNodeFromSchema = getDocumentNodeFromSchema; + exports2.getFieldsWithDirectives = getFieldsWithDirectives; + exports2.getImplementingTypes = getImplementingTypes; + exports2.getLeadingCommentBlock = getLeadingCommentBlock; + exports2.getOperationASTFromDocument = getOperationASTFromDocument; + exports2.getOperationASTFromRequest = getOperationASTFromRequest; + exports2.getResolversFromSchema = getResolversFromSchema; + exports2.getResponseKeyFromInfo = getResponseKeyFromInfo; + exports2.getRootTypeMap = getRootTypeMap; + exports2.getRootTypeNames = getRootTypeNames; + exports2.getRootTypes = getRootTypes; + exports2.healSchema = healSchema; + exports2.healTypes = healTypes; + exports2.implementsAbstractType = implementsAbstractType; + exports2.inspect = inspect; + exports2.isAggregateError = isAggregateError; + exports2.isAsyncIterable = isAsyncIterable; + exports2.isDescribable = isDescribable; + exports2.isDocumentNode = isDocumentNode; + exports2.isDocumentString = isDocumentString; + exports2.isNamedStub = isNamedStub; + exports2.isSome = isSome; + exports2.isValidPath = isValidPath; + exports2.makeDeprecatedDirective = makeDeprecatedDirective; + exports2.makeDirectiveNode = makeDirectiveNode; + exports2.makeDirectiveNodes = makeDirectiveNodes; + exports2.mapAsyncIterator = mapAsyncIterator; + exports2.mapSchema = mapSchema; + exports2.memoize1 = memoize1; + exports2.memoize2 = memoize2; + exports2.memoize2of4 = memoize2of4; + exports2.memoize3 = memoize3; + exports2.memoize4 = memoize4; + exports2.memoize5 = memoize5; + exports2.mergeDeep = mergeDeep; + exports2.modifyObjectFields = modifyObjectFields; + exports2.nodeToString = nodeToString; + exports2.observableToAsyncIterable = observableToAsyncIterable; + exports2.parseGraphQLJSON = parseGraphQLJSON; + exports2.parseGraphQLSDL = parseGraphQLSDL; + exports2.parseInputValue = parseInputValue; + exports2.parseInputValueLiteral = parseInputValueLiteral; + exports2.parseSelectionSet = parseSelectionSet; + exports2.printComment = printComment; + exports2.printSchemaWithDirectives = printSchemaWithDirectives; + exports2.printWithComments = printWithComments; + exports2.pruneSchema = pruneSchema; + exports2.pushComment = pushComment; + exports2.relocatedError = relocatedError; + exports2.removeObjectFields = removeObjectFields; + exports2.renameType = renameType; + exports2.resetComments = resetComments; + exports2.rewireTypes = rewireTypes; + exports2.selectObjectFields = selectObjectFields; + exports2.serializeInputValue = serializeInputValue; + exports2.transformCommentsToDescriptions = transformCommentsToDescriptions; + exports2.transformInputValue = transformInputValue; + exports2.updateArgument = updateArgument; + exports2.validateGraphQlDocuments = validateGraphQlDocuments; + exports2.valueMatchesCriteria = valueMatchesCriteria; + exports2.visitData = visitData; + exports2.visitErrors = visitErrors; + exports2.visitResult = visitResult; + exports2.withCancel = getAsyncIterableWithCancel; + } +}); + +// node_modules/@graphql-tools/merge/index.js +var require_merge = __commonJS({ + "node_modules/@graphql-tools/merge/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var utils = require_utils2(); + var graphql = require_graphql2(); + function mergeResolvers(resolversDefinitions, options) { + if (!resolversDefinitions || Array.isArray(resolversDefinitions) && resolversDefinitions.length === 0) { + return {}; + } + if (!Array.isArray(resolversDefinitions)) { + return resolversDefinitions; + } + if (resolversDefinitions.length === 1) { + return resolversDefinitions[0] || {}; + } + const resolvers2 = new Array(); + for (let resolversDefinition of resolversDefinitions) { + if (Array.isArray(resolversDefinition)) { + resolversDefinition = mergeResolvers(resolversDefinition); + } + if (typeof resolversDefinition === "object" && resolversDefinition) { + resolvers2.push(resolversDefinition); + } + } + const result = utils.mergeDeep(resolvers2, true); + if (options === null || options === void 0 ? void 0 : options.exclusions) { + for (const exclusion of options.exclusions) { + const [typeName, fieldName] = exclusion.split("."); + if (!fieldName || fieldName === "*") { + delete result[typeName]; + } else if (result[typeName]) { + delete result[typeName][fieldName]; + } + } + } + return result; + } + function mergeArguments(args1, args2, config) { + const result = deduplicateArguments([...args2, ...args1].filter(utils.isSome)); + if (config && config.sort) { + result.sort(utils.compareNodes); + } + return result; + } + function deduplicateArguments(args) { + return args.reduce((acc, current) => { + const dup = acc.find((arg) => arg.name.value === current.name.value); + if (!dup) { + return acc.concat([current]); + } + return acc; + }, []); + } + function directiveAlreadyExists(directivesArr, otherDirective) { + return !!directivesArr.find((directive) => directive.name.value === otherDirective.name.value); + } + function nameAlreadyExists(name, namesArr) { + return namesArr.some(({ value }) => value === name.value); + } + function mergeArguments$1(a1, a2) { + const result = [...a2]; + for (const argument of a1) { + const existingIndex = result.findIndex((a) => a.name.value === argument.name.value); + if (existingIndex > -1) { + const existingArg = result[existingIndex]; + if (existingArg.value.kind === "ListValue") { + const source = existingArg.value.values; + const target = argument.value.values; + existingArg.value.values = deduplicateLists(source, target, (targetVal, source2) => { + const value = targetVal.value; + return !value || !source2.some((sourceVal) => sourceVal.value === value); + }); + } else { + existingArg.value = argument.value; + } + } else { + result.push(argument); + } + } + return result; + } + function deduplicateDirectives(directives) { + return directives.map((directive, i, all) => { + const firstAt = all.findIndex((d) => d.name.value === directive.name.value); + if (firstAt !== i) { + const dup = all[firstAt]; + directive.arguments = mergeArguments$1(directive.arguments, dup.arguments); + return null; + } + return directive; + }).filter(utils.isSome); + } + function mergeDirectives(d1 = [], d2 = [], config) { + const reverseOrder = config && config.reverseDirectives; + const asNext = reverseOrder ? d1 : d2; + const asFirst = reverseOrder ? d2 : d1; + const result = deduplicateDirectives([...asNext]); + for (const directive of asFirst) { + if (directiveAlreadyExists(result, directive)) { + const existingDirectiveIndex = result.findIndex((d) => d.name.value === directive.name.value); + const existingDirective = result[existingDirectiveIndex]; + result[existingDirectiveIndex].arguments = mergeArguments$1(directive.arguments || [], existingDirective.arguments || []); + } else { + result.push(directive); + } + } + return result; + } + function validateInputs(node, existingNode) { + const printedNode = graphql.print(__spreadProps(__spreadValues({}, node), { + description: void 0 + })); + const printedExistingNode = graphql.print(__spreadProps(__spreadValues({}, existingNode), { + description: void 0 + })); + const leaveInputs = new RegExp("(directive @w*d*)|( on .*$)", "g"); + const sameArguments = printedNode.replace(leaveInputs, "") === printedExistingNode.replace(leaveInputs, ""); + if (!sameArguments) { + throw new Error(`Unable to merge GraphQL directive "${node.name.value}". +Existing directive: + ${printedExistingNode} +Received directive: + ${printedNode}`); + } + } + function mergeDirective(node, existingNode) { + if (existingNode) { + validateInputs(node, existingNode); + return __spreadProps(__spreadValues({}, node), { + locations: [ + ...existingNode.locations, + ...node.locations.filter((name) => !nameAlreadyExists(name, existingNode.locations)) + ] + }); + } + return node; + } + function deduplicateLists(source, target, filterFn) { + return source.concat(target.filter((val) => filterFn(val, source))); + } + function mergeEnumValues(first, second, config) { + if (config === null || config === void 0 ? void 0 : config.consistentEnumMerge) { + const reversed = []; + if (first) { + reversed.push(...first); + } + first = second; + second = reversed; + } + const enumValueMap = new Map(); + if (first) { + for (const firstValue of first) { + enumValueMap.set(firstValue.name.value, firstValue); + } + } + if (second) { + for (const secondValue of second) { + const enumValue = secondValue.name.value; + if (enumValueMap.has(enumValue)) { + const firstValue = enumValueMap.get(enumValue); + firstValue.description = secondValue.description || firstValue.description; + firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives); + } else { + enumValueMap.set(enumValue, secondValue); + } + } + } + const result = [...enumValueMap.values()]; + if (config && config.sort) { + result.sort(utils.compareNodes); + } + return result; + } + function mergeEnum(e1, e2, config) { + if (e2) { + return { + name: e1.name, + description: e1["description"] || e2["description"], + kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || e1.kind === "EnumTypeDefinition" || e2.kind === "EnumTypeDefinition" ? "EnumTypeDefinition" : "EnumTypeExtension", + loc: e1.loc, + directives: mergeDirectives(e1.directives, e2.directives, config), + values: mergeEnumValues(e1.values, e2.values, config) + }; + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, e1), { + kind: graphql.Kind.ENUM_TYPE_DEFINITION + }) : e1; + } + function isStringTypes(types) { + return typeof types === "string"; + } + function isSourceTypes(types) { + return types instanceof graphql.Source; + } + function extractType(type) { + let visitedType = type; + while (visitedType.kind === graphql.Kind.LIST_TYPE || visitedType.kind === "NonNullType") { + visitedType = visitedType.type; + } + return visitedType; + } + function isWrappingTypeNode(type) { + return type.kind !== graphql.Kind.NAMED_TYPE; + } + function isListTypeNode(type) { + return type.kind === graphql.Kind.LIST_TYPE; + } + function isNonNullTypeNode(type) { + return type.kind === graphql.Kind.NON_NULL_TYPE; + } + function printTypeNode(type) { + if (isListTypeNode(type)) { + return `[${printTypeNode(type.type)}]`; + } + if (isNonNullTypeNode(type)) { + return `${printTypeNode(type.type)}!`; + } + return type.name.value; + } + (function(CompareVal) { + CompareVal[CompareVal["A_SMALLER_THAN_B"] = -1] = "A_SMALLER_THAN_B"; + CompareVal[CompareVal["A_EQUALS_B"] = 0] = "A_EQUALS_B"; + CompareVal[CompareVal["A_GREATER_THAN_B"] = 1] = "A_GREATER_THAN_B"; + })(exports2.CompareVal || (exports2.CompareVal = {})); + function defaultStringComparator(a, b) { + if (a == null && b == null) { + return exports2.CompareVal.A_EQUALS_B; + } + if (a == null) { + return exports2.CompareVal.A_SMALLER_THAN_B; + } + if (b == null) { + return exports2.CompareVal.A_GREATER_THAN_B; + } + if (a < b) + return exports2.CompareVal.A_SMALLER_THAN_B; + if (a > b) + return exports2.CompareVal.A_GREATER_THAN_B; + return exports2.CompareVal.A_EQUALS_B; + } + function fieldAlreadyExists(fieldsArr, otherField, config) { + const result = fieldsArr.find((field) => field.name.value === otherField.name.value); + if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) { + const t1 = extractType(result.type); + const t2 = extractType(otherField.type); + if (t1.name.value !== t2.name.value) { + throw new Error(`Field "${otherField.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`); + } + } + return !!result; + } + function mergeFields(type, f1, f2, config) { + const result = []; + if (f2 != null) { + result.push(...f2); + } + if (f1 != null) { + for (const field of f1) { + if (fieldAlreadyExists(result, field, config)) { + const existing = result.find((f) => f.name.value === field.name.value); + if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) { + if (config === null || config === void 0 ? void 0 : config.throwOnConflict) { + preventConflicts(type, existing, field, false); + } else { + preventConflicts(type, existing, field, true); + } + if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) { + existing.type = field.type; + } + } + existing.arguments = mergeArguments(field["arguments"] || [], existing.arguments || [], config); + existing.directives = mergeDirectives(field.directives, existing.directives, config); + existing.description = field.description || existing.description; + } else { + result.push(field); + } + } + } + if (config && config.sort) { + result.sort(utils.compareNodes); + } + if (config && config.exclusions) { + const exclusions = config.exclusions; + return result.filter((field) => !exclusions.includes(`${type.name.value}.${field.name.value}`)); + } + return result; + } + function preventConflicts(type, a, b, ignoreNullability = false) { + const aType = printTypeNode(a.type); + const bType = printTypeNode(b.type); + if (aType !== bType && !safeChangeForFieldType(a.type, b.type, ignoreNullability)) { + throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`); + } + } + function safeChangeForFieldType(oldType, newType, ignoreNullability = false) { + if (!isWrappingTypeNode(oldType) && !isWrappingTypeNode(newType)) { + return oldType.toString() === newType.toString(); + } + if (isNonNullTypeNode(newType)) { + const ofType = isNonNullTypeNode(oldType) ? oldType.type : oldType; + return safeChangeForFieldType(ofType, newType.type); + } + if (isNonNullTypeNode(oldType)) { + return safeChangeForFieldType(newType, oldType, ignoreNullability); + } + if (isListTypeNode(oldType)) { + return isListTypeNode(newType) && safeChangeForFieldType(oldType.type, newType.type) || isNonNullTypeNode(newType) && safeChangeForFieldType(oldType, newType["type"]); + } + return false; + } + function mergeInputType(node, existingNode, config) { + if (existingNode) { + try { + return { + name: node.name, + description: node["description"] || existingNode["description"], + kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "InputObjectTypeDefinition" || existingNode.kind === "InputObjectTypeDefinition" ? "InputObjectTypeDefinition" : "InputObjectTypeExtension", + loc: node.loc, + fields: mergeFields(node, node.fields, existingNode.fields, config), + directives: mergeDirectives(node.directives, existingNode.directives, config) + }; + } catch (e) { + throw new Error(`Unable to merge GraphQL input type "${node.name.value}": ${e.message}`); + } + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION + }) : node; + } + function mergeInterface(node, existingNode, config) { + if (existingNode) { + try { + return { + name: node.name, + description: node["description"] || existingNode["description"], + kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "InterfaceTypeDefinition" || existingNode.kind === "InterfaceTypeDefinition" ? "InterfaceTypeDefinition" : "InterfaceTypeExtension", + loc: node.loc, + fields: mergeFields(node, node.fields, existingNode.fields, config), + directives: mergeDirectives(node.directives, existingNode.directives, config), + interfaces: node["interfaces"] ? mergeNamedTypeArray(node["interfaces"], existingNode["interfaces"], config) : void 0 + }; + } catch (e) { + throw new Error(`Unable to merge GraphQL interface "${node.name.value}": ${e.message}`); + } + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.INTERFACE_TYPE_DEFINITION + }) : node; + } + function alreadyExists(arr, other) { + return !!arr.find((i) => i.name.value === other.name.value); + } + function mergeNamedTypeArray(first = [], second = [], config = {}) { + const result = [...second, ...first.filter((d) => !alreadyExists(second, d))]; + if (config && config.sort) { + result.sort(utils.compareNodes); + } + return result; + } + function mergeType(node, existingNode, config) { + if (existingNode) { + try { + return { + name: node.name, + description: node["description"] || existingNode["description"], + kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "ObjectTypeDefinition" || existingNode.kind === "ObjectTypeDefinition" ? "ObjectTypeDefinition" : "ObjectTypeExtension", + loc: node.loc, + fields: mergeFields(node, node.fields, existingNode.fields, config), + directives: mergeDirectives(node.directives, existingNode.directives, config), + interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config) + }; + } catch (e) { + throw new Error(`Unable to merge GraphQL type "${node.name.value}": ${e.message}`); + } + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.OBJECT_TYPE_DEFINITION + }) : node; + } + function mergeScalar(node, existingNode, config) { + if (existingNode) { + return { + name: node.name, + description: node["description"] || existingNode["description"], + kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "ScalarTypeDefinition" || existingNode.kind === "ScalarTypeDefinition" ? "ScalarTypeDefinition" : "ScalarTypeExtension", + loc: node.loc, + directives: mergeDirectives(node.directives, existingNode.directives, config) + }; + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.SCALAR_TYPE_DEFINITION + }) : node; + } + function mergeUnion(first, second, config) { + if (second) { + return { + name: first.name, + description: first["description"] || second["description"], + directives: mergeDirectives(first.directives, second.directives, config), + kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? graphql.Kind.UNION_TYPE_DEFINITION : graphql.Kind.UNION_TYPE_EXTENSION, + loc: first.loc, + types: mergeNamedTypeArray(first.types, second.types, config) + }; + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, first), { + kind: graphql.Kind.UNION_TYPE_DEFINITION + }) : first; + } + var DEFAULT_OPERATION_TYPE_NAME_MAP = { + query: "Query", + mutation: "Mutation", + subscription: "Subscription" + }; + function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) { + const finalOpNodeList = []; + for (const opNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) { + const opNode = opNodeList.find((n) => n.operation === opNodeType) || existingOpNodeList.find((n) => n.operation === opNodeType); + if (opNode) { + finalOpNodeList.push(opNode); + } + } + return finalOpNodeList; + } + function mergeSchemaDefs(node, existingNode, config) { + if (existingNode) { + return { + kind: node.kind === graphql.Kind.SCHEMA_DEFINITION || existingNode.kind === graphql.Kind.SCHEMA_DEFINITION ? graphql.Kind.SCHEMA_DEFINITION : graphql.Kind.SCHEMA_EXTENSION, + description: node["description"] || existingNode["description"], + directives: mergeDirectives(node.directives, existingNode.directives, config), + operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes) + }; + } + return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? __spreadProps(__spreadValues({}, node), { + kind: graphql.Kind.SCHEMA_DEFINITION + }) : node; + } + var schemaDefSymbol = "SCHEMA_DEF_SYMBOL"; + function isNamedDefinitionNode(definitionNode) { + return "name" in definitionNode; + } + function mergeGraphQLNodes(nodes, config) { + var _a, _b, _c; + const mergedResultMap = {}; + for (const nodeDefinition of nodes) { + if (isNamedDefinitionNode(nodeDefinition)) { + const name = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value; + if (config === null || config === void 0 ? void 0 : config.commentDescriptions) { + utils.collectComment(nodeDefinition); + } + if (name == null) { + continue; + } + if (((_b = config === null || config === void 0 ? void 0 : config.exclusions) === null || _b === void 0 ? void 0 : _b.includes(name + ".*")) || ((_c = config === null || config === void 0 ? void 0 : config.exclusions) === null || _c === void 0 ? void 0 : _c.includes(name))) { + delete mergedResultMap[name]; + } else { + switch (nodeDefinition.kind) { + case graphql.Kind.OBJECT_TYPE_DEFINITION: + case graphql.Kind.OBJECT_TYPE_EXTENSION: + mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config); + break; + case graphql.Kind.ENUM_TYPE_DEFINITION: + case graphql.Kind.ENUM_TYPE_EXTENSION: + mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config); + break; + case graphql.Kind.UNION_TYPE_DEFINITION: + case graphql.Kind.UNION_TYPE_EXTENSION: + mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config); + break; + case graphql.Kind.SCALAR_TYPE_DEFINITION: + case graphql.Kind.SCALAR_TYPE_EXTENSION: + mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config); + break; + case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION: + case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION: + mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config); + break; + case graphql.Kind.INTERFACE_TYPE_DEFINITION: + case graphql.Kind.INTERFACE_TYPE_EXTENSION: + mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config); + break; + case graphql.Kind.DIRECTIVE_DEFINITION: + mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]); + break; + } + } + } else if (nodeDefinition.kind === graphql.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === graphql.Kind.SCHEMA_EXTENSION) { + mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config); + } + } + return mergedResultMap; + } + function mergeTypeDefs(typeSource, config) { + utils.resetComments(); + const doc = { + kind: graphql.Kind.DOCUMENT, + definitions: mergeGraphQLTypes(typeSource, __spreadValues({ + useSchemaDefinition: true, + forceSchemaDefinition: false, + throwOnConflict: false, + commentDescriptions: false + }, config)) + }; + let result; + if (config === null || config === void 0 ? void 0 : config.commentDescriptions) { + result = utils.printWithComments(doc); + } else { + result = doc; + } + utils.resetComments(); + return result; + } + function visitTypeSources(typeSource, options, allNodes = [], visitedTypeSources = new Set()) { + if (typeSource && !visitedTypeSources.has(typeSource)) { + visitedTypeSources.add(typeSource); + if (typeof typeSource === "function") { + visitTypeSources(typeSource(), options, allNodes, visitedTypeSources); + } else if (Array.isArray(typeSource)) { + for (const type of typeSource) { + visitTypeSources(type, options, allNodes, visitedTypeSources); + } + } else if (graphql.isSchema(typeSource)) { + const documentNode = utils.getDocumentNodeFromSchema(typeSource, options); + visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources); + } else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) { + const documentNode = graphql.parse(typeSource, options); + visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources); + } else if (typeof typeSource === "object" && graphql.isDefinitionNode(typeSource)) { + allNodes.push(typeSource); + } else if (utils.isDocumentNode(typeSource)) { + visitTypeSources(typeSource.definitions, options, allNodes, visitedTypeSources); + } else { + throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`); + } + } + return allNodes; + } + function mergeGraphQLTypes(typeSource, config) { + var _a, _b, _c; + utils.resetComments(); + const allNodes = visitTypeSources(typeSource, config); + const mergedNodes = mergeGraphQLNodes(allNodes, config); + if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) { + const schemaDef = mergedNodes[schemaDefSymbol] || { + kind: graphql.Kind.SCHEMA_DEFINITION, + operationTypes: [] + }; + const operationTypes = schemaDef.operationTypes; + for (const opTypeDefNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) { + const opTypeDefNode = operationTypes.find((operationType) => operationType.operation === opTypeDefNodeType); + if (!opTypeDefNode) { + const possibleRootTypeName = DEFAULT_OPERATION_TYPE_NAME_MAP[opTypeDefNodeType]; + const existingPossibleRootType = mergedNodes[possibleRootTypeName]; + if (existingPossibleRootType != null && existingPossibleRootType.name != null) { + operationTypes.push({ + kind: graphql.Kind.OPERATION_TYPE_DEFINITION, + type: { + kind: graphql.Kind.NAMED_TYPE, + name: existingPossibleRootType.name + }, + operation: opTypeDefNodeType + }); + } + } + } + if (((_a = schemaDef === null || schemaDef === void 0 ? void 0 : schemaDef.operationTypes) === null || _a === void 0 ? void 0 : _a.length) != null && schemaDef.operationTypes.length > 0) { + mergedNodes[schemaDefSymbol] = schemaDef; + } + } + if ((config === null || config === void 0 ? void 0 : config.forceSchemaDefinition) && !((_c = (_b = mergedNodes[schemaDefSymbol]) === null || _b === void 0 ? void 0 : _b.operationTypes) === null || _c === void 0 ? void 0 : _c.length)) { + mergedNodes[schemaDefSymbol] = { + kind: graphql.Kind.SCHEMA_DEFINITION, + operationTypes: [ + { + kind: graphql.Kind.OPERATION_TYPE_DEFINITION, + operation: "query", + type: { + kind: graphql.Kind.NAMED_TYPE, + name: { + kind: graphql.Kind.NAME, + value: "Query" + } + } + } + ] + }; + } + const mergedNodeDefinitions = Object.values(mergedNodes); + if (config === null || config === void 0 ? void 0 : config.sort) { + const sortFn = typeof config.sort === "function" ? config.sort : defaultStringComparator; + mergedNodeDefinitions.sort((a, b) => { + var _a2, _b2; + return sortFn((_a2 = a.name) === null || _a2 === void 0 ? void 0 : _a2.value, (_b2 = b.name) === null || _b2 === void 0 ? void 0 : _b2.value); + }); + } + return mergedNodeDefinitions; + } + function travelSchemaPossibleExtensions(schema2, hooks) { + hooks.onSchema(schema2); + const typesMap = schema2.getTypeMap(); + for (const [, type] of Object.entries(typesMap)) { + const isPredefinedScalar = graphql.isScalarType(type) && graphql.isSpecifiedScalarType(type); + const isIntrospection = graphql.isIntrospectionType(type); + if (isPredefinedScalar || isIntrospection) { + continue; + } + if (graphql.isObjectType(type)) { + hooks.onObjectType(type); + const fields = type.getFields(); + for (const [, field] of Object.entries(fields)) { + hooks.onObjectField(type, field); + const args = field.args || []; + for (const arg of args) { + hooks.onObjectFieldArg(type, field, arg); + } + } + } else if (graphql.isInterfaceType(type)) { + hooks.onInterface(type); + const fields = type.getFields(); + for (const [, field] of Object.entries(fields)) { + hooks.onInterfaceField(type, field); + const args = field.args || []; + for (const arg of args) { + hooks.onInterfaceFieldArg(type, field, arg); + } + } + } else if (graphql.isInputObjectType(type)) { + hooks.onInputType(type); + const fields = type.getFields(); + for (const [, field] of Object.entries(fields)) { + hooks.onInputFieldType(type, field); + } + } else if (graphql.isUnionType(type)) { + hooks.onUnion(type); + } else if (graphql.isScalarType(type)) { + hooks.onScalar(type); + } else if (graphql.isEnumType(type)) { + hooks.onEnum(type); + for (const value of type.getValues()) { + hooks.onEnumValue(type, value); + } + } + } + } + function mergeExtensions(extensions) { + return utils.mergeDeep(extensions); + } + function applyExtensionObject(obj, extensions) { + if (!obj) { + return; + } + obj.extensions = utils.mergeDeep([obj.extensions || {}, extensions || {}]); + } + function applyExtensions(schema2, extensions) { + applyExtensionObject(schema2, extensions.schemaExtensions); + for (const [typeName, data] of Object.entries(extensions.types || {})) { + const type = schema2.getType(typeName); + if (type) { + applyExtensionObject(type, data.extensions); + if (data.type === "object" || data.type === "interface") { + for (const [fieldName, fieldData] of Object.entries(data.fields)) { + const field = type.getFields()[fieldName]; + if (field) { + applyExtensionObject(field, fieldData.extensions); + for (const [arg, argData] of Object.entries(fieldData.arguments)) { + applyExtensionObject(field.args.find((a) => a.name === arg), argData); + } + } + } + } else if (data.type === "input") { + for (const [fieldName, fieldData] of Object.entries(data.fields)) { + const field = type.getFields()[fieldName]; + applyExtensionObject(field, fieldData.extensions); + } + } else if (data.type === "enum") { + for (const [valueName, valueData] of Object.entries(data.values)) { + const value = type.getValue(valueName); + applyExtensionObject(value, valueData); + } + } + } + } + return schema2; + } + function extractExtensionsFromSchema(schema2) { + const result = { + schemaExtensions: {}, + types: {} + }; + travelSchemaPossibleExtensions(schema2, { + onSchema: (schema3) => result.schemaExtensions = schema3.extensions || {}, + onObjectType: (type) => result.types[type.name] = { fields: {}, type: "object", extensions: type.extensions || {} }, + onObjectField: (type, field) => result.types[type.name].fields[field.name] = { + arguments: {}, + extensions: field.extensions || {} + }, + onObjectFieldArg: (type, field, arg) => result.types[type.name].fields[field.name].arguments[arg.name] = arg.extensions || {}, + onInterface: (type) => result.types[type.name] = { fields: {}, type: "interface", extensions: type.extensions || {} }, + onInterfaceField: (type, field) => result.types[type.name].fields[field.name] = { + arguments: {}, + extensions: field.extensions || {} + }, + onInterfaceFieldArg: (type, field, arg) => result.types[type.name].fields[field.name].arguments[arg.name] = arg.extensions || {}, + onEnum: (type) => result.types[type.name] = { values: {}, type: "enum", extensions: type.extensions || {} }, + onEnumValue: (type, value) => result.types[type.name].values[value.name] = value.extensions || {}, + onScalar: (type) => result.types[type.name] = { type: "scalar", extensions: type.extensions || {} }, + onUnion: (type) => result.types[type.name] = { type: "union", extensions: type.extensions || {} }, + onInputType: (type) => result.types[type.name] = { fields: {}, type: "input", extensions: type.extensions || {} }, + onInputFieldType: (type, field) => result.types[type.name].fields[field.name] = { extensions: field.extensions || {} } + }); + return result; + } + exports2.applyExtensions = applyExtensions; + exports2.defaultStringComparator = defaultStringComparator; + exports2.extractExtensionsFromSchema = extractExtensionsFromSchema; + exports2.extractType = extractType; + exports2.isListTypeNode = isListTypeNode; + exports2.isNamedDefinitionNode = isNamedDefinitionNode; + exports2.isNonNullTypeNode = isNonNullTypeNode; + exports2.isSourceTypes = isSourceTypes; + exports2.isStringTypes = isStringTypes; + exports2.isWrappingTypeNode = isWrappingTypeNode; + exports2.mergeArguments = mergeArguments; + exports2.mergeDirective = mergeDirective; + exports2.mergeDirectives = mergeDirectives; + exports2.mergeEnum = mergeEnum; + exports2.mergeEnumValues = mergeEnumValues; + exports2.mergeExtensions = mergeExtensions; + exports2.mergeFields = mergeFields; + exports2.mergeGraphQLNodes = mergeGraphQLNodes; + exports2.mergeGraphQLTypes = mergeGraphQLTypes; + exports2.mergeInputType = mergeInputType; + exports2.mergeInterface = mergeInterface; + exports2.mergeNamedTypeArray = mergeNamedTypeArray; + exports2.mergeResolvers = mergeResolvers; + exports2.mergeScalar = mergeScalar; + exports2.mergeType = mergeType; + exports2.mergeTypeDefs = mergeTypeDefs; + exports2.mergeUnion = mergeUnion; + exports2.printTypeNode = printTypeNode; + exports2.schemaDefSymbol = schemaDefSymbol; + exports2.travelSchemaPossibleExtensions = travelSchemaPossibleExtensions; + } +}); + +// node_modules/@graphql-tools/schema/index.js +var require_schema2 = __commonJS({ + "node_modules/@graphql-tools/schema/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var graphql = require_graphql2(); + var utils = require_utils2(); + var merge = require_merge(); + function assertResolversPresent(schema2, resolverValidationOptions = {}) { + const { requireResolversForArgs, requireResolversForNonScalar, requireResolversForAllFields } = resolverValidationOptions; + if (requireResolversForAllFields && (requireResolversForArgs || requireResolversForNonScalar)) { + throw new TypeError("requireResolversForAllFields takes precedence over the more specific assertions. Please configure either requireResolversForAllFields or requireResolversForArgs / requireResolversForNonScalar, but not a combination of them."); + } + utils.forEachField(schema2, (field, typeName, fieldName) => { + if (requireResolversForAllFields) { + expectResolver("requireResolversForAllFields", requireResolversForAllFields, field, typeName, fieldName); + } + if (requireResolversForArgs && field.args.length > 0) { + expectResolver("requireResolversForArgs", requireResolversForArgs, field, typeName, fieldName); + } + if (requireResolversForNonScalar !== "ignore" && !graphql.isScalarType(graphql.getNamedType(field.type))) { + expectResolver("requireResolversForNonScalar", requireResolversForNonScalar, field, typeName, fieldName); + } + }); + } + function expectResolver(validator, behavior, field, typeName, fieldName) { + if (!field.resolve) { + const message = `Resolver missing for "${typeName}.${fieldName}". +To disable this validator, use: + resolverValidationOptions: { + ${validator}: 'ignore' + }`; + if (behavior === "error") { + throw new Error(message); + } + if (behavior === "warn") { + console.warn(message); + } + return; + } + if (typeof field.resolve !== "function") { + throw new Error(`Resolver "${typeName}.${fieldName}" must be a function`); + } + } + function chainResolvers(resolvers2) { + return (root, args, ctx, info) => resolvers2.reduce((prev, curResolver) => { + if (curResolver != null) { + return curResolver(prev, args, ctx, info); + } + return graphql.defaultFieldResolver(prev, args, ctx, info); + }, root); + } + function checkForResolveTypeResolver(schema2, requireResolversForResolveType) { + utils.mapSchema(schema2, { + [utils.MapperKind.ABSTRACT_TYPE]: (type) => { + if (!type.resolveType) { + const message = `Type "${type.name}" is missing a "__resolveType" resolver. Pass 'ignore' into "resolverValidationOptions.requireResolversForResolveType" to disable this error.`; + if (requireResolversForResolveType === "error") { + throw new Error(message); + } + if (requireResolversForResolveType === "warn") { + console.warn(message); + } + } + return void 0; + } + }); + } + function extendResolversFromInterfaces(schema2, resolvers2) { + const extendedResolvers = {}; + const typeMap = schema2.getTypeMap(); + for (const typeName in typeMap) { + const type = typeMap[typeName]; + if ("getInterfaces" in type) { + extendedResolvers[typeName] = {}; + for (const iFace of type.getInterfaces()) { + if (resolvers2[iFace.name]) { + for (const fieldName in resolvers2[iFace.name]) { + if (fieldName === "__isTypeOf" || !fieldName.startsWith("__")) { + extendedResolvers[typeName][fieldName] = resolvers2[iFace.name][fieldName]; + } + } + } + } + const typeResolvers = resolvers2[typeName]; + extendedResolvers[typeName] = __spreadValues(__spreadValues({}, extendedResolvers[typeName]), typeResolvers); + } else { + const typeResolvers = resolvers2[typeName]; + if (typeResolvers != null) { + extendedResolvers[typeName] = typeResolvers; + } + } + } + return extendedResolvers; + } + function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInputValidationOptions) { + const options = graphql.isSchema(schemaOrOptions) ? { + schema: schemaOrOptions, + resolvers: legacyInputResolvers !== null && legacyInputResolvers !== void 0 ? legacyInputResolvers : {}, + resolverValidationOptions: legacyInputValidationOptions + } : schemaOrOptions; + let { schema: schema2, resolvers: inputResolvers, defaultFieldResolver, resolverValidationOptions = {}, inheritResolversFromInterfaces = false, updateResolversInPlace = false } = options; + const { requireResolversToMatchSchema = "error", requireResolversForResolveType } = resolverValidationOptions; + const resolvers2 = inheritResolversFromInterfaces ? extendResolversFromInterfaces(schema2, inputResolvers) : inputResolvers; + for (const typeName in resolvers2) { + const resolverValue = resolvers2[typeName]; + const resolverType = typeof resolverValue; + if (resolverType !== "object") { + throw new Error(`"${typeName}" defined in resolvers, but has invalid value "${resolverValue}". The resolver's value must be of type object.`); + } + const type = schema2.getType(typeName); + if (type == null) { + if (requireResolversToMatchSchema === "ignore") { + break; + } + throw new Error(`"${typeName}" defined in resolvers, but not in schema`); + } else if (graphql.isSpecifiedScalarType(type)) { + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + type[fieldName.substring(2)] = resolverValue[fieldName]; + } else { + type[fieldName] = resolverValue[fieldName]; + } + } + } else if (graphql.isEnumType(type)) { + const values = type.getValues(); + for (const fieldName in resolverValue) { + if (!fieldName.startsWith("__") && !values.some((value) => value.name === fieldName) && requireResolversToMatchSchema && requireResolversToMatchSchema !== "ignore") { + throw new Error(`${type.name}.${fieldName} was defined in resolvers, but not present within ${type.name}`); + } + } + } else if (graphql.isUnionType(type)) { + for (const fieldName in resolverValue) { + if (!fieldName.startsWith("__") && requireResolversToMatchSchema && requireResolversToMatchSchema !== "ignore") { + throw new Error(`${type.name}.${fieldName} was defined in resolvers, but ${type.name} is not an object or interface type`); + } + } + } else if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) { + for (const fieldName in resolverValue) { + if (!fieldName.startsWith("__")) { + const fields = type.getFields(); + const field = fields[fieldName]; + if (field == null) { + if (requireResolversToMatchSchema && requireResolversToMatchSchema !== "ignore") { + throw new Error(`${typeName}.${fieldName} defined in resolvers, but not in schema`); + } + } else { + const fieldResolve = resolverValue[fieldName]; + if (typeof fieldResolve !== "function" && typeof fieldResolve !== "object") { + throw new Error(`Resolver ${typeName}.${fieldName} must be object or function`); + } + } + } + } + } + } + schema2 = updateResolversInPlace ? addResolversToExistingSchema(schema2, resolvers2, defaultFieldResolver) : createNewSchemaWithResolvers(schema2, resolvers2, defaultFieldResolver); + if (requireResolversForResolveType && requireResolversForResolveType !== "ignore") { + checkForResolveTypeResolver(schema2, requireResolversForResolveType); + } + return schema2; + } + function addResolversToExistingSchema(schema2, resolvers2, defaultFieldResolver) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t; + const typeMap = schema2.getTypeMap(); + for (const typeName in resolvers2) { + const type = schema2.getType(typeName); + const resolverValue = resolvers2[typeName]; + if (graphql.isScalarType(type)) { + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + type[fieldName.substring(2)] = resolverValue[fieldName]; + } else if (fieldName === "astNode" && type.astNode != null) { + type.astNode = __spreadProps(__spreadValues({}, type.astNode), { + description: (_c = (_b = (_a = resolverValue) === null || _a === void 0 ? void 0 : _a.astNode) === null || _b === void 0 ? void 0 : _b.description) !== null && _c !== void 0 ? _c : type.astNode.description, + directives: ((_d = type.astNode.directives) !== null && _d !== void 0 ? _d : []).concat((_g = (_f = (_e = resolverValue) === null || _e === void 0 ? void 0 : _e.astNode) === null || _f === void 0 ? void 0 : _f.directives) !== null && _g !== void 0 ? _g : []) + }); + } else if (fieldName === "extensionASTNodes" && type.extensionASTNodes != null) { + type.extensionASTNodes = type.extensionASTNodes.concat((_j = (_h = resolverValue) === null || _h === void 0 ? void 0 : _h.extensionASTNodes) !== null && _j !== void 0 ? _j : []); + } else if (fieldName === "extensions" && type.extensions != null && resolverValue.extensions != null) { + type.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions); + } else { + type[fieldName] = resolverValue[fieldName]; + } + } + } else if (graphql.isEnumType(type)) { + const config = type.toConfig(); + const enumValueConfigMap = config.values; + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + config[fieldName.substring(2)] = resolverValue[fieldName]; + } else if (fieldName === "astNode" && config.astNode != null) { + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + description: (_m = (_l = (_k = resolverValue) === null || _k === void 0 ? void 0 : _k.astNode) === null || _l === void 0 ? void 0 : _l.description) !== null && _m !== void 0 ? _m : config.astNode.description, + directives: ((_o = config.astNode.directives) !== null && _o !== void 0 ? _o : []).concat((_r = (_q = (_p = resolverValue) === null || _p === void 0 ? void 0 : _p.astNode) === null || _q === void 0 ? void 0 : _q.directives) !== null && _r !== void 0 ? _r : []) + }); + } else if (fieldName === "extensionASTNodes" && config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.concat((_t = (_s = resolverValue) === null || _s === void 0 ? void 0 : _s.extensionASTNodes) !== null && _t !== void 0 ? _t : []); + } else if (fieldName === "extensions" && type.extensions != null && resolverValue.extensions != null) { + type.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions); + } else if (enumValueConfigMap[fieldName]) { + enumValueConfigMap[fieldName].value = resolverValue[fieldName]; + } + } + typeMap[typeName] = new graphql.GraphQLEnumType(config); + } else if (graphql.isUnionType(type)) { + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + type[fieldName.substring(2)] = resolverValue[fieldName]; + } + } + } else if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) { + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + type[fieldName.substring(2)] = resolverValue[fieldName]; + break; + } + const fields = type.getFields(); + const field = fields[fieldName]; + if (field != null) { + const fieldResolve = resolverValue[fieldName]; + if (typeof fieldResolve === "function") { + field.resolve = fieldResolve.bind(resolverValue); + } else { + setFieldProperties(field, fieldResolve); + } + } + } + } + } + utils.forEachDefaultValue(schema2, utils.serializeInputValue); + utils.healSchema(schema2); + utils.forEachDefaultValue(schema2, utils.parseInputValue); + if (defaultFieldResolver != null) { + utils.forEachField(schema2, (field) => { + if (!field.resolve) { + field.resolve = defaultFieldResolver; + } + }); + } + return schema2; + } + function createNewSchemaWithResolvers(schema2, resolvers2, defaultFieldResolver) { + schema2 = utils.mapSchema(schema2, { + [utils.MapperKind.SCALAR_TYPE]: (type) => { + var _a, _b, _c, _d, _e, _f, _g, _h, _j; + const config = type.toConfig(); + const resolverValue = resolvers2[type.name]; + if (!graphql.isSpecifiedScalarType(type) && resolverValue != null) { + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + config[fieldName.substring(2)] = resolverValue[fieldName]; + } else if (fieldName === "astNode" && config.astNode != null) { + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + description: (_c = (_b = (_a = resolverValue) === null || _a === void 0 ? void 0 : _a.astNode) === null || _b === void 0 ? void 0 : _b.description) !== null && _c !== void 0 ? _c : config.astNode.description, + directives: ((_d = config.astNode.directives) !== null && _d !== void 0 ? _d : []).concat((_g = (_f = (_e = resolverValue) === null || _e === void 0 ? void 0 : _e.astNode) === null || _f === void 0 ? void 0 : _f.directives) !== null && _g !== void 0 ? _g : []) + }); + } else if (fieldName === "extensionASTNodes" && config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.concat((_j = (_h = resolverValue) === null || _h === void 0 ? void 0 : _h.extensionASTNodes) !== null && _j !== void 0 ? _j : []); + } else if (fieldName === "extensions" && config.extensions != null && resolverValue.extensions != null) { + config.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions); + } else { + config[fieldName] = resolverValue[fieldName]; + } + } + return new graphql.GraphQLScalarType(config); + } + }, + [utils.MapperKind.ENUM_TYPE]: (type) => { + var _a, _b, _c, _d, _e, _f, _g, _h, _j; + const resolverValue = resolvers2[type.name]; + const config = type.toConfig(); + const enumValueConfigMap = config.values; + if (resolverValue != null) { + for (const fieldName in resolverValue) { + if (fieldName.startsWith("__")) { + config[fieldName.substring(2)] = resolverValue[fieldName]; + } else if (fieldName === "astNode" && config.astNode != null) { + config.astNode = __spreadProps(__spreadValues({}, config.astNode), { + description: (_c = (_b = (_a = resolverValue) === null || _a === void 0 ? void 0 : _a.astNode) === null || _b === void 0 ? void 0 : _b.description) !== null && _c !== void 0 ? _c : config.astNode.description, + directives: ((_d = config.astNode.directives) !== null && _d !== void 0 ? _d : []).concat((_g = (_f = (_e = resolverValue) === null || _e === void 0 ? void 0 : _e.astNode) === null || _f === void 0 ? void 0 : _f.directives) !== null && _g !== void 0 ? _g : []) + }); + } else if (fieldName === "extensionASTNodes" && config.extensionASTNodes != null) { + config.extensionASTNodes = config.extensionASTNodes.concat((_j = (_h = resolverValue) === null || _h === void 0 ? void 0 : _h.extensionASTNodes) !== null && _j !== void 0 ? _j : []); + } else if (fieldName === "extensions" && config.extensions != null && resolverValue.extensions != null) { + config.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions); + } else if (enumValueConfigMap[fieldName]) { + enumValueConfigMap[fieldName].value = resolverValue[fieldName]; + } + } + return new graphql.GraphQLEnumType(config); + } + }, + [utils.MapperKind.UNION_TYPE]: (type) => { + const resolverValue = resolvers2[type.name]; + if (resolverValue != null) { + const config = type.toConfig(); + if (resolverValue["__resolveType"]) { + config.resolveType = resolverValue["__resolveType"]; + } + return new graphql.GraphQLUnionType(config); + } + }, + [utils.MapperKind.OBJECT_TYPE]: (type) => { + const resolverValue = resolvers2[type.name]; + if (resolverValue != null) { + const config = type.toConfig(); + if (resolverValue["__isTypeOf"]) { + config.isTypeOf = resolverValue["__isTypeOf"]; + } + return new graphql.GraphQLObjectType(config); + } + }, + [utils.MapperKind.INTERFACE_TYPE]: (type) => { + const resolverValue = resolvers2[type.name]; + if (resolverValue != null) { + const config = type.toConfig(); + if (resolverValue["__resolveType"]) { + config.resolveType = resolverValue["__resolveType"]; + } + return new graphql.GraphQLInterfaceType(config); + } + }, + [utils.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => { + const resolverValue = resolvers2[typeName]; + if (resolverValue != null) { + const fieldResolve = resolverValue[fieldName]; + if (fieldResolve != null) { + const newFieldConfig = __spreadValues({}, fieldConfig); + if (typeof fieldResolve === "function") { + newFieldConfig.resolve = fieldResolve.bind(resolverValue); + } else { + setFieldProperties(newFieldConfig, fieldResolve); + } + return newFieldConfig; + } + } + } + }); + if (defaultFieldResolver != null) { + schema2 = utils.mapSchema(schema2, { + [utils.MapperKind.OBJECT_FIELD]: (fieldConfig) => __spreadProps(__spreadValues({}, fieldConfig), { + resolve: fieldConfig.resolve != null ? fieldConfig.resolve : defaultFieldResolver + }) + }); + } + return schema2; + } + function setFieldProperties(field, propertiesObj) { + for (const propertyName in propertiesObj) { + field[propertyName] = propertiesObj[propertyName]; + } + } + function makeExecutableSchema({ typeDefs: typeDefs2, resolvers: resolvers2 = {}, resolverValidationOptions = {}, parseOptions = {}, inheritResolversFromInterfaces = false, pruningOptions, updateResolversInPlace = false, schemaExtensions }) { + if (typeof resolverValidationOptions !== "object") { + throw new Error("Expected `resolverValidationOptions` to be an object"); + } + if (!typeDefs2) { + throw new Error("Must provide typeDefs"); + } + let schema2; + if (graphql.isSchema(typeDefs2)) { + schema2 = typeDefs2; + } else if (parseOptions === null || parseOptions === void 0 ? void 0 : parseOptions.commentDescriptions) { + const mergedTypeDefs = merge.mergeTypeDefs(typeDefs2, __spreadProps(__spreadValues({}, parseOptions), { + commentDescriptions: true + })); + schema2 = graphql.buildSchema(mergedTypeDefs, parseOptions); + } else { + const mergedTypeDefs = merge.mergeTypeDefs(typeDefs2, parseOptions); + schema2 = graphql.buildASTSchema(mergedTypeDefs, parseOptions); + } + if (pruningOptions) { + schema2 = utils.pruneSchema(schema2); + } + schema2 = addResolversToSchema({ + schema: schema2, + resolvers: merge.mergeResolvers(resolvers2), + resolverValidationOptions, + inheritResolversFromInterfaces, + updateResolversInPlace + }); + if (Object.keys(resolverValidationOptions).length > 0) { + assertResolversPresent(schema2, resolverValidationOptions); + } + if (schemaExtensions) { + schemaExtensions = merge.mergeExtensions(utils.asArray(schemaExtensions)); + merge.applyExtensions(schema2, schemaExtensions); + } + return schema2; + } + function mergeSchemas(config) { + const extractedTypeDefs = utils.asArray(config.typeDefs || []); + const extractedResolvers = utils.asArray(config.resolvers || []); + const extractedSchemaExtensions = utils.asArray(config.schemaExtensions || []); + const schemas = config.schemas || []; + for (const schema2 of schemas) { + extractedTypeDefs.push(schema2); + extractedResolvers.push(utils.getResolversFromSchema(schema2)); + extractedSchemaExtensions.push(merge.extractExtensionsFromSchema(schema2)); + } + return makeExecutableSchema(__spreadProps(__spreadValues({ + parseOptions: config + }, config), { + typeDefs: extractedTypeDefs, + resolvers: extractedResolvers, + schemaExtensions: extractedSchemaExtensions + })); + } + exports2.addResolversToSchema = addResolversToSchema; + exports2.assertResolversPresent = assertResolversPresent; + exports2.chainResolvers = chainResolvers; + exports2.checkForResolveTypeResolver = checkForResolveTypeResolver; + exports2.extendResolversFromInterfaces = extendResolversFromInterfaces; + exports2.makeExecutableSchema = makeExecutableSchema; + exports2.mergeSchemas = mergeSchemas; + } +}); + +// node_modules/@graphql-tools/mock/index.js +var require_mock = __commonJS({ + "node_modules/@graphql-tools/mock/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + function _interopDefault(ex) { + return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex; + } + var graphql = require_graphql2(); + var stringify = _interopDefault(require_fast_json_stable_stringify()); + var utils = require_utils2(); + var schema2 = require_schema2(); + function isRef(maybeRef) { + return !!(maybeRef && typeof maybeRef === "object" && "$ref" in maybeRef); + } + function assertIsRef(maybeRef, message) { + if (!isRef(maybeRef)) { + throw new Error(message || `Expected ${maybeRef} to be a valid Ref.`); + } + } + function isRecord(obj) { + return typeof obj === "object" && obj !== null; + } + function uuidv4() { + return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => { + const r = Math.random() * 16 | 0; + const v = c == "x" ? r : r & 3 | 8; + return v.toString(16); + }); + } + var randomListLength = () => { + return 2; + }; + var takeRandom = (arr) => arr[Math.floor(Math.random() * arr.length)]; + function makeRef(typeName, key) { + return { $ref: { key, typeName } }; + } + function isObject(thing) { + return thing === Object(thing) && !Array.isArray(thing); + } + function copyOwnPropsIfNotPresent(target, source) { + for (const prop of Object.getOwnPropertyNames(source)) { + if (!Object.getOwnPropertyDescriptor(target, prop)) { + const propertyDescriptor = Object.getOwnPropertyDescriptor(source, prop); + Object.defineProperty(target, prop, propertyDescriptor == null ? {} : propertyDescriptor); + } + } + } + function copyOwnProps(target, ...sources) { + for (const source of sources) { + let chain = source; + while (chain != null) { + copyOwnPropsIfNotPresent(target, chain); + chain = Object.getPrototypeOf(chain); + } + } + return target; + } + var isRootType = (type, schema3) => { + const rootTypeNames = utils.getRootTypeNames(schema3); + return rootTypeNames.has(type.name); + }; + function isMockList(obj) { + if (typeof (obj === null || obj === void 0 ? void 0 : obj.len) === "number" || Array.isArray(obj === null || obj === void 0 ? void 0 : obj.len) && typeof (obj === null || obj === void 0 ? void 0 : obj.len[0]) === "number") { + if (typeof obj.wrappedFunction === "undefined" || typeof obj.wrappedFunction === "function") { + return true; + } + } + return false; + } + var MockList = class { + constructor(length, mockFunction) { + this.len = length; + if (typeof mockFunction !== "undefined") { + if (typeof mockFunction !== "function") { + throw new Error("Second argument to MockList must be a function or undefined"); + } + this.wrappedFunction = mockFunction; + } + } + mock() { + let arr; + if (Array.isArray(this.len)) { + arr = new Array(this.randint(this.len[0], this.len[1])); + } else { + arr = new Array(this.len); + } + for (let i = 0; i < arr.length; i++) { + if (typeof this.wrappedFunction === "function") { + const res = this.wrappedFunction(); + if (isMockList(res)) { + arr[i] = res.mock(); + } else { + arr[i] = res; + } + } else { + arr[i] = void 0; + } + } + return arr; + } + randint(low, high) { + return Math.floor(Math.random() * (high - low + 1) + low); + } + }; + function deepResolveMockList(mockList) { + return mockList.mock().map((v) => { + if (isMockList(v)) + return deepResolveMockList(v); + return v; + }); + } + var defaultMocks = { + Int: () => Math.round(Math.random() * 200) - 100, + Float: () => Math.random() * 200 - 100, + String: () => "Hello World", + Boolean: () => Math.random() > 0.5, + ID: () => uuidv4() + }; + var defaultKeyFieldNames = ["id", "_id"]; + var MockStore = class { + constructor({ schema: schema3, mocks, typePolicies }) { + this.store = {}; + this.schema = schema3; + this.mocks = __spreadValues(__spreadValues({}, defaultMocks), mocks); + this.typePolicies = typePolicies || {}; + } + has(typeName, key) { + return !!this.store[typeName] && !!this.store[typeName][key]; + } + get(_typeName, _key, _fieldName, _fieldArgs) { + if (typeof _typeName !== "string") { + if (_key === void 0) { + if (isRef(_typeName)) { + throw new Error("Can't provide a ref as first argument and no other argument"); + } + return this.getImpl(_typeName); + } else { + assertIsRef(_typeName); + const { $ref } = _typeName; + _fieldArgs = _fieldName; + _fieldName = _key; + _key = $ref.key; + _typeName = $ref.typeName; + } + } + const args = { + typeName: _typeName + }; + if (isRecord(_key) || _key === void 0) { + args.defaultValue = _key; + return this.getImpl(args); + } + args.key = _key; + if (Array.isArray(_fieldName) && _fieldName.length === 1) { + _fieldName = _fieldName[0]; + } + if (typeof _fieldName !== "string" && !Array.isArray(_fieldName)) { + args.defaultValue = _fieldName; + return this.getImpl(args); + } + if (Array.isArray(_fieldName)) { + const ref = this.get(_typeName, _key, _fieldName[0], _fieldArgs); + assertIsRef(ref); + return this.get(ref.$ref.typeName, ref.$ref.key, _fieldName.slice(1, _fieldName.length)); + } + args.fieldName = _fieldName; + args.fieldArgs = _fieldArgs; + return this.getImpl(args); + } + set(_typeName, _key, _fieldName, _value) { + if (typeof _typeName !== "string") { + if (_key === void 0) { + if (isRef(_typeName)) { + throw new Error("Can't provide a ref as first argument and no other argument"); + } + return this.setImpl(_typeName); + } else { + assertIsRef(_typeName); + const { $ref } = _typeName; + _value = _fieldName; + _fieldName = _key; + _key = $ref.key; + _typeName = $ref.typeName; + } + } + assertIsDefined(_key, "key was not provided"); + const args = { + typeName: _typeName, + key: _key + }; + if (typeof _fieldName !== "string") { + if (!isRecord(_fieldName)) + throw new Error("Expected value to be a record"); + args.value = _fieldName; + return this.setImpl(args); + } + args.fieldName = _fieldName; + args.value = _value; + return this.setImpl(args); + } + reset() { + this.store = {}; + } + filter(key, predicate) { + const entity = this.store[key]; + return Object.values(entity).filter(predicate); + } + find(key, predicate) { + const entity = this.store[key]; + return Object.values(entity).find(predicate); + } + getImpl(args) { + const { typeName, key, fieldName, fieldArgs, defaultValue } = args; + if (!fieldName) { + if (defaultValue !== void 0 && !isRecord(defaultValue)) { + throw new Error("`defaultValue` should be an object"); + } + let valuesToInsert = defaultValue || {}; + if (key) { + valuesToInsert = __spreadValues(__spreadValues({}, valuesToInsert), makeRef(typeName, key)); + } + return this.insert(typeName, valuesToInsert, true); + } + assertIsDefined(key, "key argument should be given when fieldName is given"); + const fieldNameInStore = getFieldNameInStore(fieldName, fieldArgs); + if (this.store[typeName] === void 0 || this.store[typeName][key] === void 0 || this.store[typeName][key][fieldNameInStore] === void 0) { + let value; + if (defaultValue !== void 0) { + value = defaultValue; + } else if (this.isKeyField(typeName, fieldName)) { + value = key; + } else { + value = this.generateFieldValue(typeName, fieldName, (otherFieldName, otherValue) => { + if (this.isKeyField(typeName, otherFieldName)) + return; + this.set({ typeName, key, fieldName: otherFieldName, value: otherValue, noOverride: true }); + }); + } + this.set({ typeName, key, fieldName, fieldArgs, value, noOverride: true }); + } + return this.store[typeName][key][fieldNameInStore]; + } + setImpl(args) { + const { typeName, key, fieldName, fieldArgs, noOverride } = args; + let { value } = args; + if (isMockList(value)) { + value = deepResolveMockList(value); + } + if (this.store[typeName] === void 0) { + this.store[typeName] = {}; + } + if (this.store[typeName][key] === void 0) { + this.store[typeName][key] = {}; + } + if (!fieldName) { + if (!isRecord(value)) { + throw new Error("When no `fieldName` is provided, `value` should be a record."); + } + for (const fieldName2 in value) { + this.setImpl({ + typeName, + key, + fieldName: fieldName2, + value: value[fieldName2], + noOverride + }); + } + return; + } + const fieldNameInStore = getFieldNameInStore(fieldName, fieldArgs); + if (this.isKeyField(typeName, fieldName) && value !== key) { + throw new Error(`Field ${fieldName} is a key field of ${typeName} and you are trying to set it to ${value} while the key is ${key}`); + } + if (this.store[typeName][key][fieldNameInStore] !== void 0 && noOverride) { + return; + } + const fieldType = this.getFieldType(typeName, fieldName); + const currentValue = this.store[typeName][key][fieldNameInStore]; + let valueToStore; + try { + valueToStore = this.normalizeValueToStore(fieldType, value, currentValue, (typeName2, values) => this.insert(typeName2, values, noOverride)); + } catch (e) { + throw new Error(`Value to set in ${typeName}.${fieldName} in not normalizable: ${e.message}`); + } + this.store[typeName][key] = __spreadProps(__spreadValues({}, this.store[typeName][key]), { + [fieldNameInStore]: valueToStore + }); + } + normalizeValueToStore(fieldType, value, currentValue, onInsertType) { + const fieldTypeName = fieldType.toString(); + if (value === null) { + if (!graphql.isNullableType(fieldType)) { + throw new Error(`should not be null because ${fieldTypeName} is not nullable. Received null.`); + } + return null; + } + const nullableFieldType = graphql.getNullableType(fieldType); + if (value === void 0) + return this.generateValueFromType(nullableFieldType); + if (graphql.isCompositeType(nullableFieldType)) { + if (!isRecord(value)) + throw new Error(`should be an object or null or undefined. Received ${value}`); + let joinedTypeName; + if (graphql.isAbstractType(nullableFieldType)) { + if (isRef(value)) { + joinedTypeName = value.$ref.typeName; + } else { + if (typeof value["__typename"] !== "string") { + throw new Error(`should contain a '__typename' because ${nullableFieldType.name} an abstract type`); + } + joinedTypeName = value["__typename"]; + } + } else { + joinedTypeName = nullableFieldType.name; + } + return onInsertType(joinedTypeName, isRef(currentValue) ? __spreadValues(__spreadValues({}, currentValue), value) : value); + } + if (graphql.isListType(nullableFieldType)) { + if (!Array.isArray(value)) + throw new Error(`should be an array or null or undefined. Received ${value}`); + return value.map((v, index) => { + return this.normalizeValueToStore(nullableFieldType.ofType, v, typeof currentValue === "object" && currentValue != null && currentValue[index] ? currentValue : void 0, onInsertType); + }); + } + return value; + } + insert(typeName, values, noOverride) { + const keyFieldName = this.getKeyFieldName(typeName); + let key; + const otherValues = {}; + if (isRef(values)) { + key = values.$ref.key; + } else if (keyFieldName && keyFieldName in values) { + key = values[keyFieldName]; + } else { + key = this.generateKeyForType(typeName, (otherFieldName, otherFieldValue) => { + otherValues[otherFieldName] = otherFieldValue; + }); + } + const toInsert = __spreadValues(__spreadValues({}, otherValues), values); + for (const fieldName in toInsert) { + if (fieldName === "$ref") + continue; + if (fieldName === "__typename") + continue; + this.set({ + typeName, + key, + fieldName, + value: toInsert[fieldName], + noOverride + }); + } + if (this.store[typeName] === void 0) { + this.store[typeName] = {}; + } + if (this.store[typeName][key] === void 0) { + this.store[typeName][key] = {}; + } + return makeRef(typeName, key); + } + generateFieldValue(typeName, fieldName, onOtherFieldsGenerated) { + const mockedValue = this.generateFieldValueFromMocks(typeName, fieldName, onOtherFieldsGenerated); + if (mockedValue !== void 0) + return mockedValue; + const fieldType = this.getFieldType(typeName, fieldName); + return this.generateValueFromType(fieldType); + } + generateFieldValueFromMocks(typeName, fieldName, onOtherFieldsGenerated) { + let value; + const mock = this.mocks ? this.mocks[typeName] : void 0; + if (mock) { + if (typeof mock === "function") { + const values = mock(); + if (typeof values !== "object" || values == null) { + throw new Error(`Value returned by the mock for ${typeName} is not an object`); + } + for (const otherFieldName in values) { + if (otherFieldName === fieldName) + continue; + if (typeof values[otherFieldName] === "function") + continue; + onOtherFieldsGenerated && onOtherFieldsGenerated(otherFieldName, values[otherFieldName]); + } + value = values[fieldName]; + if (typeof value === "function") + value = value(); + } else if (typeof mock === "object" && mock != null && typeof mock[fieldName] === "function") { + value = mock[fieldName](); + } + } + if (value !== void 0) + return value; + const type = this.getType(typeName); + const interfaces = "getInterfaces" in type ? type.getInterfaces() : []; + if (interfaces.length > 0) { + for (const interface_ of interfaces) { + if (value) + break; + value = this.generateFieldValueFromMocks(interface_.name, fieldName, onOtherFieldsGenerated); + } + } + return value; + } + generateKeyForType(typeName, onOtherFieldsGenerated) { + const keyFieldName = this.getKeyFieldName(typeName); + if (!keyFieldName) + return uuidv4(); + return this.generateFieldValue(typeName, keyFieldName, onOtherFieldsGenerated); + } + generateValueFromType(fieldType) { + const nullableType = graphql.getNullableType(fieldType); + if (graphql.isScalarType(nullableType)) { + const mockFn = this.mocks[nullableType.name]; + if (typeof mockFn !== "function") + throw new Error(`No mock defined for type "${nullableType.name}"`); + return mockFn(); + } else if (graphql.isEnumType(nullableType)) { + const mockFn = this.mocks[nullableType.name]; + if (typeof mockFn === "function") + return mockFn(); + const values = nullableType.getValues().map((v) => v.value); + return takeRandom(values); + } else if (graphql.isObjectType(nullableType)) { + return this.insert(nullableType.name, {}); + } else if (graphql.isListType(nullableType)) { + return [...new Array(randomListLength())].map(() => this.generateValueFromType(nullableType.ofType)); + } else if (graphql.isAbstractType(nullableType)) { + const mock = this.mocks[nullableType.name]; + let typeName; + let values = {}; + if (!mock) { + typeName = takeRandom(this.schema.getPossibleTypes(nullableType).map((t) => t.name)); + } else if (typeof mock === "function") { + const mockRes = mock(); + if (mockRes === null) + return null; + if (!isRecord(mockRes)) { + throw new Error(`Value returned by the mock for ${nullableType.name} is not an object or null`); + } + values = mockRes; + if (typeof values["__typename"] !== "string") { + throw new Error(`Please return a __typename in "${nullableType.name}"`); + } + typeName = values["__typename"]; + } else if (typeof mock === "object" && mock != null && typeof mock["__typename"] === "function") { + const mockRes = mock["__typename"](); + if (typeof mockRes !== "string") + throw new Error(`'__typename' returned by the mock for abstract type ${nullableType.name} is not a string`); + typeName = mockRes; + } else { + throw new Error(`Please return a __typename in "${nullableType.name}"`); + } + const toInsert = {}; + for (const fieldName in values) { + if (fieldName === "__typename") + continue; + const fieldValue = values[fieldName]; + toInsert[fieldName] = typeof fieldValue === "function" ? fieldValue() : fieldValue; + } + return this.insert(typeName, toInsert); + } else { + throw new Error(`${nullableType} not implemented`); + } + } + getFieldType(typeName, fieldName) { + if (fieldName === "__typename") { + return graphql.GraphQLString; + } + const type = this.getType(typeName); + const field = type.getFields()[fieldName]; + if (!field) { + throw new Error(`${fieldName} does not exist on type ${typeName}`); + } + return field.type; + } + getType(typeName) { + const type = this.schema.getType(typeName); + if (!type || !(graphql.isObjectType(type) || graphql.isInterfaceType(type))) { + throw new Error(`${typeName} does not exist on schema or is not an object or interface`); + } + return type; + } + isKeyField(typeName, fieldName) { + return this.getKeyFieldName(typeName) === fieldName; + } + getKeyFieldName(typeName) { + var _a; + const typePolicyKeyField = (_a = this.typePolicies[typeName]) === null || _a === void 0 ? void 0 : _a.keyFieldName; + if (typePolicyKeyField !== void 0) { + if (typePolicyKeyField === false) + return null; + return typePolicyKeyField; + } + const gqlType = this.getType(typeName); + for (const fieldName in gqlType.getFields()) { + if (defaultKeyFieldNames.includes(fieldName)) { + return fieldName; + } + } + return null; + } + }; + var getFieldNameInStore = (fieldName, fieldArgs) => { + if (!fieldArgs) + return fieldName; + if (typeof fieldArgs === "string") { + return `${fieldName}:${fieldArgs}`; + } + if (Object.keys(fieldArgs).length === 0) { + return fieldName; + } + return `${fieldName}:${stringify(fieldArgs)}`; + }; + function assertIsDefined(value, message) { + if (value !== void 0 && value !== null) { + return; + } + throw new Error(process.env["NODE_ENV"] === "production" ? "Invariant failed:" : `Invariant failed: ${message || ""}`); + } + function createMockStore(options) { + return new MockStore(options); + } + function addMocksToSchema({ schema: schema$1, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers = false }) { + if (!schema$1) { + throw new Error("Must provide schema to mock"); + } + if (!graphql.isSchema(schema$1)) { + throw new Error('Value at "schema" must be of type GraphQLSchema'); + } + if (mocks && !isObject(mocks)) { + throw new Error("mocks must be of type Object"); + } + const mockStore = createMockStore({ + schema: schema$1, + mocks, + typePolicies + }); + const store = maybeStore || mockStore; + const resolvers2 = typeof resolversOrFnResolvers === "function" ? resolversOrFnResolvers(store) : resolversOrFnResolvers; + const mockResolver = (source, args, contex, info) => { + const defaultResolvedValue = graphql.defaultFieldResolver(source, args, contex, info); + if (defaultResolvedValue !== void 0) + return defaultResolvedValue; + if (isRef(source)) { + return store.get({ + typeName: source.$ref.typeName, + key: source.$ref.key, + fieldName: info.fieldName, + fieldArgs: args + }); + } + if (isRootType(info.parentType, info.schema)) { + return store.get({ + typeName: info.parentType.name, + key: "ROOT", + fieldName: info.fieldName, + fieldArgs: args + }); + } + if (defaultResolvedValue === void 0) { + return mockStore.generateFieldValue(info.parentType.name, info.fieldName); + } + return void 0; + }; + const typeResolver = (data) => { + if (isRef(data)) { + return data.$ref.typeName; + } + }; + const mockSubscriber = () => ({ + [Symbol.asyncIterator]() { + return { + async next() { + return { + done: true, + value: {} + }; + } + }; + } + }); + const schemaWithMocks = utils.mapSchema(schema$1, { + [utils.MapperKind.OBJECT_FIELD]: (fieldConfig) => { + const newFieldConfig = __spreadValues({}, fieldConfig); + const oldResolver = fieldConfig.resolve; + if (!preserveResolvers || !oldResolver) { + newFieldConfig.resolve = mockResolver; + } else { + newFieldConfig.resolve = async (rootObject, args, context, info) => { + const [mockedValue, resolvedValue] = await Promise.all([ + mockResolver(rootObject, args, context, info), + oldResolver(rootObject, args, context, info) + ]); + if (mockedValue instanceof Error) { + if (resolvedValue === void 0) { + throw mockedValue; + } + return resolvedValue; + } + if (resolvedValue instanceof Date && mockedValue instanceof Date) { + return resolvedValue !== void 0 ? resolvedValue : mockedValue; + } + if (isObject(mockedValue) && isObject(resolvedValue)) { + const emptyObject = Object.create(Object.getPrototypeOf(resolvedValue)); + return copyOwnProps(emptyObject, resolvedValue, mockedValue); + } + return resolvedValue !== void 0 ? resolvedValue : mockedValue; + }; + } + const fieldSubscriber = fieldConfig.subscribe; + if (!preserveResolvers || !fieldSubscriber) { + newFieldConfig.subscribe = mockSubscriber; + } else { + newFieldConfig.subscribe = async (rootObject, args, context, info) => { + const [mockAsyncIterable, oldAsyncIterable] = await Promise.all([ + mockSubscriber(), + fieldSubscriber(rootObject, args, context, info) + ]); + return oldAsyncIterable || mockAsyncIterable; + }; + } + return newFieldConfig; + }, + [utils.MapperKind.ABSTRACT_TYPE]: (type) => { + if (preserveResolvers && type.resolveType != null && type.resolveType.length) { + return; + } + if (graphql.isUnionType(type)) { + return new graphql.GraphQLUnionType(__spreadProps(__spreadValues({}, type.toConfig()), { + resolveType: typeResolver + })); + } else { + return new graphql.GraphQLInterfaceType(__spreadProps(__spreadValues({}, type.toConfig()), { + resolveType: typeResolver + })); + } + } + }); + return resolvers2 ? schema2.addResolversToSchema(schemaWithMocks, resolvers2) : schemaWithMocks; + } + function mockServer(schema$1, mocks, preserveResolvers = false) { + const mockedSchema = addMocksToSchema({ + schema: graphql.isSchema(schema$1) ? schema$1 : schema2.makeExecutableSchema({ + typeDefs: schema$1 + }), + mocks, + preserveResolvers + }); + return { + query: (query, vars) => graphql.graphql({ + schema: mockedSchema, + source: query, + rootValue: {}, + contextValue: {}, + variableValues: vars + }) + }; + } + var relayStylePaginationMock = (store, { cursorFn = (node) => `${node.$ref.key}`, applyOnNodes, allNodesFn } = {}) => { + return (parent, args, context, info) => { + const source = isRootType(info.parentType, info.schema) ? makeRef(info.parentType.name, "ROOT") : parent; + const allNodesFn_ = allNodesFn !== null && allNodesFn !== void 0 ? allNodesFn : defaultAllNodesFn(store); + let allNodes = allNodesFn_(source, args, context, info); + if (applyOnNodes) { + allNodes = applyOnNodes(allNodes, args); + } + const allEdges = allNodes.map((node) => ({ + node, + cursor: cursorFn(node) + })); + let start, end; + const { first, after, last, before } = args; + if (typeof first === "number") { + if (last || before) { + throw new Error("if `first` is provided, `last` or `before` can't be provided"); + } + const afterIndex = after ? allEdges.findIndex((e) => e.cursor === after) : -1; + start = afterIndex + 1; + end = afterIndex + 1 + first; + } else if (typeof last === "number") { + if (first || after) { + throw new Error("if `last` is provided, `first` or `after` can't be provided"); + } + const foundBeforeIndex = before ? allEdges.findIndex((e) => e.cursor === before) : -1; + const beforeIndex = foundBeforeIndex !== -1 ? foundBeforeIndex : allNodes.length; + start = allEdges.length - (allEdges.length - beforeIndex) - last; + if (start < 0) + start = 0; + end = beforeIndex; + } else { + throw new Error("A `first` or a `last` arguments should be provided"); + } + const edges = allEdges.slice(start, end); + const pageInfo = { + startCursor: edges.length > 0 ? edges[0].cursor : "", + endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : "", + hasNextPage: end < allEdges.length - 1, + hasPreviousPage: start > 0 + }; + return { + edges, + pageInfo, + totalCount: allEdges.length + }; + }; + }; + var defaultAllNodesFn = (store) => (parent, _, __, info) => store.get(parent, [info.fieldName, "edges"]).map((e) => store.get(e, "node")); + exports2.MockList = MockList; + exports2.MockStore = MockStore; + exports2.addMocksToSchema = addMocksToSchema; + exports2.assertIsRef = assertIsRef; + exports2.createMockStore = createMockStore; + exports2.deepResolveMockList = deepResolveMockList; + exports2.defaultMocks = defaultMocks; + exports2.isMockList = isMockList; + exports2.isRecord = isRecord; + exports2.isRef = isRef; + exports2.mockServer = mockServer; + exports2.relayStylePaginationMock = relayStylePaginationMock; + } +}); + +// node_modules/loglevel/lib/loglevel.js +var require_loglevel = __commonJS({ + "node_modules/loglevel/lib/loglevel.js"(exports2, module2) { + (function(root, definition) { + "use strict"; + if (typeof define === "function" && define.amd) { + define(definition); + } else if (typeof module2 === "object" && module2.exports) { + module2.exports = definition(); + } else { + root.log = definition(); + } + })(exports2, function() { + "use strict"; + var noop = function() { + }; + var undefinedType = "undefined"; + var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent); + var logMethods = [ + "trace", + "debug", + "info", + "warn", + "error" + ]; + function bindMethod(obj, methodName) { + var method = obj[methodName]; + if (typeof method.bind === "function") { + return method.bind(obj); + } else { + try { + return Function.prototype.bind.call(method, obj); + } catch (e) { + return function() { + return Function.prototype.apply.apply(method, [obj, arguments]); + }; + } + } + } + function traceForIE() { + if (console.log) { + if (console.log.apply) { + console.log.apply(console, arguments); + } else { + Function.prototype.apply.apply(console.log, [console, arguments]); + } + } + if (console.trace) + console.trace(); + } + function realMethod(methodName) { + if (methodName === "debug") { + methodName = "log"; + } + if (typeof console === undefinedType) { + return false; + } else if (methodName === "trace" && isIE) { + return traceForIE; + } else if (console[methodName] !== void 0) { + return bindMethod(console, methodName); + } else if (console.log !== void 0) { + return bindMethod(console, "log"); + } else { + return noop; + } + } + function replaceLoggingMethods(level, loggerName) { + for (var i = 0; i < logMethods.length; i++) { + var methodName = logMethods[i]; + this[methodName] = i < level ? noop : this.methodFactory(methodName, level, loggerName); + } + this.log = this.debug; + } + function enableLoggingWhenConsoleArrives(methodName, level, loggerName) { + return function() { + if (typeof console !== undefinedType) { + replaceLoggingMethods.call(this, level, loggerName); + this[methodName].apply(this, arguments); + } + }; + } + function defaultMethodFactory(methodName, level, loggerName) { + return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments); + } + function Logger(name, defaultLevel, factory) { + var self2 = this; + var currentLevel; + defaultLevel = defaultLevel == null ? "WARN" : defaultLevel; + var storageKey = "loglevel"; + if (typeof name === "string") { + storageKey += ":" + name; + } else if (typeof name === "symbol") { + storageKey = void 0; + } + function persistLevelIfPossible(levelNum) { + var levelName = (logMethods[levelNum] || "silent").toUpperCase(); + if (typeof window === undefinedType || !storageKey) + return; + try { + window.localStorage[storageKey] = levelName; + return; + } catch (ignore) { + } + try { + window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";"; + } catch (ignore) { + } + } + function getPersistedLevel() { + var storedLevel; + if (typeof window === undefinedType || !storageKey) + return; + try { + storedLevel = window.localStorage[storageKey]; + } catch (ignore) { + } + if (typeof storedLevel === undefinedType) { + try { + var cookie = window.document.cookie; + var location = cookie.indexOf(encodeURIComponent(storageKey) + "="); + if (location !== -1) { + storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1]; + } + } catch (ignore) { + } + } + if (self2.levels[storedLevel] === void 0) { + storedLevel = void 0; + } + return storedLevel; + } + function clearPersistedLevel() { + if (typeof window === undefinedType || !storageKey) + return; + try { + window.localStorage.removeItem(storageKey); + return; + } catch (ignore) { + } + try { + window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC"; + } catch (ignore) { + } + } + self2.name = name; + self2.levels = { + "TRACE": 0, + "DEBUG": 1, + "INFO": 2, + "WARN": 3, + "ERROR": 4, + "SILENT": 5 + }; + self2.methodFactory = factory || defaultMethodFactory; + self2.getLevel = function() { + return currentLevel; + }; + self2.setLevel = function(level, persist) { + if (typeof level === "string" && self2.levels[level.toUpperCase()] !== void 0) { + level = self2.levels[level.toUpperCase()]; + } + if (typeof level === "number" && level >= 0 && level <= self2.levels.SILENT) { + currentLevel = level; + if (persist !== false) { + persistLevelIfPossible(level); + } + replaceLoggingMethods.call(self2, level, name); + if (typeof console === undefinedType && level < self2.levels.SILENT) { + return "No console available for logging"; + } + } else { + throw "log.setLevel() called with invalid level: " + level; + } + }; + self2.setDefaultLevel = function(level) { + defaultLevel = level; + if (!getPersistedLevel()) { + self2.setLevel(level, false); + } + }; + self2.resetLevel = function() { + self2.setLevel(defaultLevel, false); + clearPersistedLevel(); + }; + self2.enableAll = function(persist) { + self2.setLevel(self2.levels.TRACE, persist); + }; + self2.disableAll = function(persist) { + self2.setLevel(self2.levels.SILENT, persist); + }; + var initialLevel = getPersistedLevel(); + if (initialLevel == null) { + initialLevel = defaultLevel; + } + self2.setLevel(initialLevel, false); + } + var defaultLogger = new Logger(); + var _loggersByName = {}; + defaultLogger.getLogger = function getLogger(name) { + if (typeof name !== "symbol" && typeof name !== "string" || name === "") { + throw new TypeError("You must supply a name when creating a logger."); + } + var logger = _loggersByName[name]; + if (!logger) { + logger = _loggersByName[name] = new Logger(name, defaultLogger.getLevel(), defaultLogger.methodFactory); + } + return logger; + }; + var _log = typeof window !== undefinedType ? window.log : void 0; + defaultLogger.noConflict = function() { + if (typeof window !== undefinedType && window.log === defaultLogger) { + window.log = _log; + } + return defaultLogger; + }; + defaultLogger.getLoggers = function getLoggers() { + return _loggersByName; + }; + defaultLogger["default"] = defaultLogger; + return defaultLogger; + }); + } +}); + +// node_modules/@josephg/resolvable/index.js +var require_resolvable = __commonJS({ + "node_modules/@josephg/resolvable/index.js"(exports2, module2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var resolvablePromise = () => { + let resolve; + let reject; + const promise = new Promise((_resolve, _reject) => { + resolve = _resolve; + reject = _reject; + }); + promise.resolve = resolve; + promise.reject = reject; + return promise; + }; + exports2.default = resolvablePromise; + module2.exports = resolvablePromise; + } +}); + +// node_modules/apollo-server-core/dist/utils/schemaHash.js +var require_schemaHash = __commonJS({ + "node_modules/apollo-server-core/dist/utils/schemaHash.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.generateSchemaHash = void 0; + var language_1 = require_language(); + var execution_1 = require_execution(); + var utilities_1 = require_utilities(); + var fast_json_stable_stringify_1 = __importDefault(require_fast_json_stable_stringify()); + var createSHA_1 = __importDefault(require_createSHA()); + function generateSchemaHash(schema2) { + const introspectionQuery = (0, utilities_1.getIntrospectionQuery)(); + const document2 = (0, language_1.parse)(introspectionQuery); + const result = (0, execution_1.execute)({ + schema: schema2, + document: document2 + }); + if (result && typeof result.then === "function") { + throw new Error([ + "The introspection query is resolving asynchronously; execution of an introspection query is not expected to return a `Promise`.", + "", + "Wrapped type resolvers should maintain the existing execution dynamics of the resolvers they wrap (i.e. async vs sync) or introspection types should be excluded from wrapping by checking them with `graphql/type`s, `isIntrospectionType` predicate function prior to wrapping." + ].join("\n")); + } + if (!result || !result.data || !result.data.__schema) { + throw new Error("Unable to generate server introspection document."); + } + const introspectionSchema = result.data.__schema; + const stringifiedSchema = (0, fast_json_stable_stringify_1.default)(introspectionSchema); + return (0, createSHA_1.default)("sha512").update(stringifiedSchema).digest("hex"); + } + exports2.generateSchemaHash = generateSchemaHash; + } +}); + +// node_modules/@apollographql/apollo-tools/lib/utilities/invariant.js +var require_invariant2 = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/utilities/invariant.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.invariant = void 0; + function invariant(condition, message) { + if (!condition) { + throw new Error(message); + } + } + exports2.invariant = invariant; + } +}); + +// node_modules/@apollographql/apollo-tools/lib/utilities/predicates.js +var require_predicates2 = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/utilities/predicates.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.isNotNullOrUndefined = void 0; + function isNotNullOrUndefined(value) { + return value !== null && typeof value !== "undefined"; + } + exports2.isNotNullOrUndefined = isNotNullOrUndefined; + } +}); + +// node_modules/@apollographql/apollo-tools/lib/utilities/graphql.js +var require_graphql3 = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/utilities/graphql.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.isDocumentNode = exports2.isNode = void 0; + var graphql_1 = require_graphql2(); + function isNode(maybeNode) { + return maybeNode && typeof maybeNode.kind === "string"; + } + exports2.isNode = isNode; + function isDocumentNode(node) { + return isNode(node) && node.kind === graphql_1.Kind.DOCUMENT; + } + exports2.isDocumentNode = isDocumentNode; + } +}); + +// node_modules/@apollographql/apollo-tools/lib/utilities/index.js +var require_utilities2 = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/utilities/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) + __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + __exportStar(require_invariant2(), exports2); + __exportStar(require_predicates2(), exports2); + __exportStar(require_graphql3(), exports2); + } +}); + +// node_modules/@apollographql/apollo-tools/lib/schema/resolverMap.js +var require_resolverMap = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/schema/resolverMap.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + } +}); + +// node_modules/@apollographql/apollo-tools/lib/schema/resolveObject.js +var require_resolveObject = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/schema/resolveObject.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + } +}); + +// node_modules/@apollographql/apollo-tools/lib/schema/index.js +var require_schema3 = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/schema/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) + __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + __exportStar(require_resolverMap(), exports2); + __exportStar(require_resolveObject(), exports2); + } +}); + +// node_modules/@apollographql/apollo-tools/lib/buildServiceDefinition.js +var require_buildServiceDefinition = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/buildServiceDefinition.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.buildServiceDefinition = void 0; + var graphql_1 = require_graphql2(); + var graphql_2 = require_graphql3(); + var predicates_1 = require_predicates2(); + function flattened(arr) { + return new Array().concat(...arr); + } + function buildServiceDefinition(modules) { + const errors = []; + const typeDefinitionsMap = Object.create(null); + const typeExtensionsMap = Object.create(null); + const directivesMap = Object.create(null); + const schemaDefinitions = []; + const schemaExtensions = []; + for (let module3 of modules) { + if (graphql_2.isNode(module3) && graphql_2.isDocumentNode(module3)) { + module3 = { typeDefs: module3 }; + } + for (const definition of module3.typeDefs.definitions) { + if (graphql_1.isTypeDefinitionNode(definition)) { + const typeName = definition.name.value; + if (typeDefinitionsMap[typeName]) { + typeDefinitionsMap[typeName].push(definition); + } else { + typeDefinitionsMap[typeName] = [definition]; + } + } else if (graphql_1.isTypeExtensionNode(definition)) { + const typeName = definition.name.value; + if (typeExtensionsMap[typeName]) { + typeExtensionsMap[typeName].push(definition); + } else { + typeExtensionsMap[typeName] = [definition]; + } + } else if (definition.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) { + const directiveName = definition.name.value; + if (directivesMap[directiveName]) { + directivesMap[directiveName].push(definition); + } else { + directivesMap[directiveName] = [definition]; + } + } else if (definition.kind === graphql_1.Kind.SCHEMA_DEFINITION) { + schemaDefinitions.push(definition); + } else if (definition.kind === graphql_1.Kind.SCHEMA_EXTENSION) { + schemaExtensions.push(definition); + } + } + } + for (const [typeName, typeDefinitions] of Object.entries(typeDefinitionsMap)) { + if (typeDefinitions.length > 1) { + errors.push(new graphql_1.GraphQLError(`Type "${typeName}" was defined more than once.`, typeDefinitions)); + } + } + for (const [directiveName, directives] of Object.entries(directivesMap)) { + if (directives.length > 1) { + errors.push(new graphql_1.GraphQLError(`Directive "${directiveName}" was defined more than once.`, directives)); + } + } + let operationTypeMap; + if (schemaDefinitions.length > 0 || schemaExtensions.length > 0) { + operationTypeMap = {}; + const schemaDefinition = schemaDefinitions[schemaDefinitions.length - 1]; + const operationTypes = flattened([schemaDefinition, ...schemaExtensions].map((node) => node.operationTypes).filter(predicates_1.isNotNullOrUndefined)); + for (const operationType of operationTypes) { + const typeName = operationType.type.name.value; + const operation = operationType.operation; + if (operationTypeMap[operation]) { + throw new graphql_1.GraphQLError(`Must provide only one ${operation} type in schema.`, [schemaDefinition]); + } + if (!(typeDefinitionsMap[typeName] || typeExtensionsMap[typeName])) { + throw new graphql_1.GraphQLError(`Specified ${operation} type "${typeName}" not found in document.`, [schemaDefinition]); + } + operationTypeMap[operation] = typeName; + } + } else { + operationTypeMap = { + query: "Query", + mutation: "Mutation", + subscription: "Subscription" + }; + } + for (const [typeName, typeExtensions] of Object.entries(typeExtensionsMap)) { + if (!typeDefinitionsMap[typeName]) { + if (Object.values(operationTypeMap).includes(typeName)) { + typeDefinitionsMap[typeName] = [ + { + kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION, + name: { + kind: graphql_1.Kind.NAME, + value: typeName + } + } + ]; + } else { + errors.push(new graphql_1.GraphQLError(`Cannot extend type "${typeName}" because it does not exist in the existing schema.`, typeExtensions)); + } + } + } + if (errors.length > 0) { + return { errors }; + } + try { + const typeDefinitions = flattened(Object.values(typeDefinitionsMap)); + const directives = flattened(Object.values(directivesMap)); + let schema2 = graphql_1.buildASTSchema({ + kind: graphql_1.Kind.DOCUMENT, + definitions: [...typeDefinitions, ...directives] + }); + const typeExtensions = flattened(Object.values(typeExtensionsMap)); + if (typeExtensions.length > 0) { + schema2 = graphql_1.extendSchema(schema2, { + kind: graphql_1.Kind.DOCUMENT, + definitions: typeExtensions + }); + } + for (const module3 of modules) { + if (!module3.resolvers) + continue; + addResolversToSchema(schema2, module3.resolvers); + } + return { schema: schema2 }; + } catch (error) { + return { errors: [error] }; + } + } + exports2.buildServiceDefinition = buildServiceDefinition; + function addResolversToSchema(schema2, resolvers2) { + for (const [typeName, fieldConfigs] of Object.entries(resolvers2)) { + const type = schema2.getType(typeName); + if (!graphql_1.isObjectType(type)) + continue; + const fieldMap = type.getFields(); + for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) { + if (fieldName.startsWith("__")) { + type[fieldName.substring(2)] = fieldConfig; + continue; + } + const field = fieldMap[fieldName]; + if (!field) + continue; + if (typeof fieldConfig === "function") { + field.resolve = fieldConfig; + } else { + if (fieldConfig.resolve) { + field.resolve = fieldConfig.resolve; + } + if (fieldConfig.subscribe) { + field.subscribe = fieldConfig.subscribe; + } + } + } + } + } + } +}); + +// node_modules/@apollographql/apollo-tools/lib/index.js +var require_lib3 = __commonJS({ + "node_modules/@apollographql/apollo-tools/lib/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) + __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + __exportStar(require_utilities2(), exports2); + __exportStar(require_schema3(), exports2); + __exportStar(require_buildServiceDefinition(), exports2); + } +}); + +// node_modules/apollo-server-core/dist/determineApolloConfig.js +var require_determineApolloConfig = __commonJS({ + "node_modules/apollo-server-core/dist/determineApolloConfig.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.determineApolloConfig = void 0; + var createSHA_1 = __importDefault(require_createSHA()); + function determineApolloConfig(input) { + var _a, _b; + const apolloConfig = {}; + const { APOLLO_KEY, APOLLO_GRAPH_REF, APOLLO_GRAPH_ID, APOLLO_GRAPH_VARIANT } = process.env; + if (input === null || input === void 0 ? void 0 : input.key) { + apolloConfig.key = input.key; + } else if (APOLLO_KEY) { + apolloConfig.key = APOLLO_KEY; + } + if (apolloConfig.key) { + apolloConfig.keyHash = (0, createSHA_1.default)("sha512").update(apolloConfig.key).digest("hex"); + } + if (input === null || input === void 0 ? void 0 : input.graphRef) { + apolloConfig.graphRef = input.graphRef; + } else if (APOLLO_GRAPH_REF) { + apolloConfig.graphRef = APOLLO_GRAPH_REF; + } + const graphId = (_a = input === null || input === void 0 ? void 0 : input.graphId) !== null && _a !== void 0 ? _a : APOLLO_GRAPH_ID; + const graphVariant = (_b = input === null || input === void 0 ? void 0 : input.graphVariant) !== null && _b !== void 0 ? _b : APOLLO_GRAPH_VARIANT; + if (apolloConfig.graphRef) { + if (graphId) { + throw new Error("Cannot specify both graph ref and graph ID. Please use `apollo.graphRef` or `APOLLO_GRAPH_REF` without also setting the graph ID."); + } + if (graphVariant) { + throw new Error("Cannot specify both graph ref and graph variant. Please use `apollo.graphRef` or `APOLLO_GRAPH_REF` without also setting the graph ID."); + } + } else if (graphId) { + apolloConfig.graphRef = graphVariant ? `${graphId}@${graphVariant}` : graphId; + } + return apolloConfig; + } + exports2.determineApolloConfig = determineApolloConfig; + } +}); + +// node_modules/retry/lib/retry_operation.js +var require_retry_operation = __commonJS({ + "node_modules/retry/lib/retry_operation.js"(exports2, module2) { + function RetryOperation(timeouts, options) { + if (typeof options === "boolean") { + options = { forever: options }; + } + this._originalTimeouts = JSON.parse(JSON.stringify(timeouts)); + this._timeouts = timeouts; + this._options = options || {}; + this._maxRetryTime = options && options.maxRetryTime || Infinity; + this._fn = null; + this._errors = []; + this._attempts = 1; + this._operationTimeout = null; + this._operationTimeoutCb = null; + this._timeout = null; + this._operationStart = null; + this._timer = null; + if (this._options.forever) { + this._cachedTimeouts = this._timeouts.slice(0); + } + } + module2.exports = RetryOperation; + RetryOperation.prototype.reset = function() { + this._attempts = 1; + this._timeouts = this._originalTimeouts.slice(0); + }; + RetryOperation.prototype.stop = function() { + if (this._timeout) { + clearTimeout(this._timeout); + } + if (this._timer) { + clearTimeout(this._timer); + } + this._timeouts = []; + this._cachedTimeouts = null; + }; + RetryOperation.prototype.retry = function(err) { + if (this._timeout) { + clearTimeout(this._timeout); + } + if (!err) { + return false; + } + var currentTime = new Date().getTime(); + if (err && currentTime - this._operationStart >= this._maxRetryTime) { + this._errors.push(err); + this._errors.unshift(new Error("RetryOperation timeout occurred")); + return false; + } + this._errors.push(err); + var timeout = this._timeouts.shift(); + if (timeout === void 0) { + if (this._cachedTimeouts) { + this._errors.splice(0, this._errors.length - 1); + timeout = this._cachedTimeouts.slice(-1); + } else { + return false; + } + } + var self2 = this; + this._timer = setTimeout(function() { + self2._attempts++; + if (self2._operationTimeoutCb) { + self2._timeout = setTimeout(function() { + self2._operationTimeoutCb(self2._attempts); + }, self2._operationTimeout); + if (self2._options.unref) { + self2._timeout.unref(); + } + } + self2._fn(self2._attempts); + }, timeout); + if (this._options.unref) { + this._timer.unref(); + } + return true; + }; + RetryOperation.prototype.attempt = function(fn, timeoutOps) { + this._fn = fn; + if (timeoutOps) { + if (timeoutOps.timeout) { + this._operationTimeout = timeoutOps.timeout; + } + if (timeoutOps.cb) { + this._operationTimeoutCb = timeoutOps.cb; + } + } + var self2 = this; + if (this._operationTimeoutCb) { + this._timeout = setTimeout(function() { + self2._operationTimeoutCb(); + }, self2._operationTimeout); + } + this._operationStart = new Date().getTime(); + this._fn(this._attempts); + }; + RetryOperation.prototype.try = function(fn) { + console.log("Using RetryOperation.try() is deprecated"); + this.attempt(fn); + }; + RetryOperation.prototype.start = function(fn) { + console.log("Using RetryOperation.start() is deprecated"); + this.attempt(fn); + }; + RetryOperation.prototype.start = RetryOperation.prototype.try; + RetryOperation.prototype.errors = function() { + return this._errors; + }; + RetryOperation.prototype.attempts = function() { + return this._attempts; + }; + RetryOperation.prototype.mainError = function() { + if (this._errors.length === 0) { + return null; + } + var counts = {}; + var mainError = null; + var mainErrorCount = 0; + for (var i = 0; i < this._errors.length; i++) { + var error = this._errors[i]; + var message = error.message; + var count = (counts[message] || 0) + 1; + counts[message] = count; + if (count >= mainErrorCount) { + mainError = error; + mainErrorCount = count; + } + } + return mainError; + }; + } +}); + +// node_modules/retry/lib/retry.js +var require_retry = __commonJS({ + "node_modules/retry/lib/retry.js"(exports2) { + var RetryOperation = require_retry_operation(); + exports2.operation = function(options) { + var timeouts = exports2.timeouts(options); + return new RetryOperation(timeouts, { + forever: options && (options.forever || options.retries === Infinity), + unref: options && options.unref, + maxRetryTime: options && options.maxRetryTime + }); + }; + exports2.timeouts = function(options) { + if (options instanceof Array) { + return [].concat(options); + } + var opts = { + retries: 10, + factor: 2, + minTimeout: 1 * 1e3, + maxTimeout: Infinity, + randomize: false + }; + for (var key in options) { + opts[key] = options[key]; + } + if (opts.minTimeout > opts.maxTimeout) { + throw new Error("minTimeout is greater than maxTimeout"); + } + var timeouts = []; + for (var i = 0; i < opts.retries; i++) { + timeouts.push(this.createTimeout(i, opts)); + } + if (options && options.forever && !timeouts.length) { + timeouts.push(this.createTimeout(i, opts)); + } + timeouts.sort(function(a, b) { + return a - b; + }); + return timeouts; + }; + exports2.createTimeout = function(attempt, opts) { + var random = opts.randomize ? Math.random() + 1 : 1; + var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt)); + timeout = Math.min(timeout, opts.maxTimeout); + return timeout; + }; + exports2.wrap = function(obj, options, methods) { + if (options instanceof Array) { + methods = options; + options = null; + } + if (!methods) { + methods = []; + for (var key in obj) { + if (typeof obj[key] === "function") { + methods.push(key); + } + } + } + for (var i = 0; i < methods.length; i++) { + var method = methods[i]; + var original = obj[method]; + obj[method] = function retryWrapper(original2) { + var op = exports2.operation(options); + var args = Array.prototype.slice.call(arguments, 1); + var callback = args.pop(); + args.push(function(err) { + if (op.retry(err)) { + return; + } + if (err) { + arguments[0] = op.mainError(); + } + callback.apply(this, arguments); + }); + op.attempt(function() { + original2.apply(obj, args); + }); + }.bind(obj, original); + obj[method].options = options; + } + }; + } +}); + +// node_modules/retry/index.js +var require_retry2 = __commonJS({ + "node_modules/retry/index.js"(exports2, module2) { + module2.exports = require_retry(); + } +}); + +// node_modules/async-retry/lib/index.js +var require_lib4 = __commonJS({ + "node_modules/async-retry/lib/index.js"(exports2, module2) { + var retrier = require_retry2(); + function retry(fn, opts) { + function run(resolve, reject) { + var options = opts || {}; + var op; + if (!("randomize" in options)) { + options.randomize = true; + } + op = retrier.operation(options); + function bail(err) { + reject(err || new Error("Aborted")); + } + function onError(err, num) { + if (err.bail) { + bail(err); + return; + } + if (!op.retry(err)) { + reject(op.mainError()); + } else if (options.onRetry) { + options.onRetry(err, num); + } + } + function runAttempt(num) { + var val; + try { + val = fn(bail, num); + } catch (err) { + onError(err, num); + return; + } + Promise.resolve(val).then(resolve).catch(function catchIt(err) { + onError(err, num); + }); + } + op.attempt(runAttempt); + } + return new Promise(run); + } + module2.exports = retry; + } +}); + +// node_modules/@protobufjs/aspromise/index.js +var require_aspromise = __commonJS({ + "node_modules/@protobufjs/aspromise/index.js"(exports2, module2) { + "use strict"; + module2.exports = asPromise; + function asPromise(fn, ctx) { + var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true; + while (index < arguments.length) + params[offset++] = arguments[index++]; + return new Promise(function executor(resolve, reject) { + params[offset] = function callback(err) { + if (pending) { + pending = false; + if (err) + reject(err); + else { + var params2 = new Array(arguments.length - 1), offset2 = 0; + while (offset2 < params2.length) + params2[offset2++] = arguments[offset2]; + resolve.apply(null, params2); + } + } + }; + try { + fn.apply(ctx || null, params); + } catch (err) { + if (pending) { + pending = false; + reject(err); + } + } + }); + } + } +}); + +// node_modules/@protobufjs/base64/index.js +var require_base64 = __commonJS({ + "node_modules/@protobufjs/base64/index.js"(exports2) { + "use strict"; + var base64 = exports2; + base64.length = function length(string) { + var p = string.length; + if (!p) + return 0; + var n = 0; + while (--p % 4 > 1 && string.charAt(p) === "=") + ++n; + return Math.ceil(string.length * 3) / 4 - n; + }; + var b64 = new Array(64); + var s64 = new Array(123); + for (var i = 0; i < 64; ) + s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++; + base64.encode = function encode(buffer, start, end) { + var parts = null, chunk = []; + var i2 = 0, j = 0, t; + while (start < end) { + var b = buffer[start++]; + switch (j) { + case 0: + chunk[i2++] = b64[b >> 2]; + t = (b & 3) << 4; + j = 1; + break; + case 1: + chunk[i2++] = b64[t | b >> 4]; + t = (b & 15) << 2; + j = 2; + break; + case 2: + chunk[i2++] = b64[t | b >> 6]; + chunk[i2++] = b64[b & 63]; + j = 0; + break; + } + if (i2 > 8191) { + (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk)); + i2 = 0; + } + } + if (j) { + chunk[i2++] = b64[t]; + chunk[i2++] = 61; + if (j === 1) + chunk[i2++] = 61; + } + if (parts) { + if (i2) + parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2))); + return parts.join(""); + } + return String.fromCharCode.apply(String, chunk.slice(0, i2)); + }; + var invalidEncoding = "invalid encoding"; + base64.decode = function decode(string, buffer, offset) { + var start = offset; + var j = 0, t; + for (var i2 = 0; i2 < string.length; ) { + var c = string.charCodeAt(i2++); + if (c === 61 && j > 1) + break; + if ((c = s64[c]) === void 0) + throw Error(invalidEncoding); + switch (j) { + case 0: + t = c; + j = 1; + break; + case 1: + buffer[offset++] = t << 2 | (c & 48) >> 4; + t = c; + j = 2; + break; + case 2: + buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2; + t = c; + j = 3; + break; + case 3: + buffer[offset++] = (t & 3) << 6 | c; + j = 0; + break; + } + } + if (j === 1) + throw Error(invalidEncoding); + return offset - start; + }; + base64.test = function test(string) { + return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string); + }; + } +}); + +// node_modules/@protobufjs/eventemitter/index.js +var require_eventemitter = __commonJS({ + "node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) { + "use strict"; + module2.exports = EventEmitter; + function EventEmitter() { + this._listeners = {}; + } + EventEmitter.prototype.on = function on(evt, fn, ctx) { + (this._listeners[evt] || (this._listeners[evt] = [])).push({ + fn, + ctx: ctx || this + }); + return this; + }; + EventEmitter.prototype.off = function off(evt, fn) { + if (evt === void 0) + this._listeners = {}; + else { + if (fn === void 0) + this._listeners[evt] = []; + else { + var listeners = this._listeners[evt]; + for (var i = 0; i < listeners.length; ) + if (listeners[i].fn === fn) + listeners.splice(i, 1); + else + ++i; + } + } + return this; + }; + EventEmitter.prototype.emit = function emit(evt) { + var listeners = this._listeners[evt]; + if (listeners) { + var args = [], i = 1; + for (; i < arguments.length; ) + args.push(arguments[i++]); + for (i = 0; i < listeners.length; ) + listeners[i].fn.apply(listeners[i++].ctx, args); + } + return this; + }; + } +}); + +// node_modules/@protobufjs/float/index.js +var require_float = __commonJS({ + "node_modules/@protobufjs/float/index.js"(exports2, module2) { + "use strict"; + module2.exports = factory(factory); + function factory(exports3) { + if (typeof Float32Array !== "undefined") + (function() { + var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128; + function writeFloat_f32_cpy(val, buf, pos) { + f32[0] = val; + buf[pos] = f8b[0]; + buf[pos + 1] = f8b[1]; + buf[pos + 2] = f8b[2]; + buf[pos + 3] = f8b[3]; + } + function writeFloat_f32_rev(val, buf, pos) { + f32[0] = val; + buf[pos] = f8b[3]; + buf[pos + 1] = f8b[2]; + buf[pos + 2] = f8b[1]; + buf[pos + 3] = f8b[0]; + } + exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev; + exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy; + function readFloat_f32_cpy(buf, pos) { + f8b[0] = buf[pos]; + f8b[1] = buf[pos + 1]; + f8b[2] = buf[pos + 2]; + f8b[3] = buf[pos + 3]; + return f32[0]; + } + function readFloat_f32_rev(buf, pos) { + f8b[3] = buf[pos]; + f8b[2] = buf[pos + 1]; + f8b[1] = buf[pos + 2]; + f8b[0] = buf[pos + 3]; + return f32[0]; + } + exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev; + exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy; + })(); + else + (function() { + function writeFloat_ieee754(writeUint, val, buf, pos) { + var sign = val < 0 ? 1 : 0; + if (sign) + val = -val; + if (val === 0) + writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos); + else if (isNaN(val)) + writeUint(2143289344, buf, pos); + else if (val > 34028234663852886e22) + writeUint((sign << 31 | 2139095040) >>> 0, buf, pos); + else if (val < 11754943508222875e-54) + writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos); + else { + var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607; + writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos); + } + } + exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE); + exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE); + function readFloat_ieee754(readUint, buf, pos) { + var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607; + return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608); + } + exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE); + exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE); + })(); + if (typeof Float64Array !== "undefined") + (function() { + var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128; + function writeDouble_f64_cpy(val, buf, pos) { + f64[0] = val; + buf[pos] = f8b[0]; + buf[pos + 1] = f8b[1]; + buf[pos + 2] = f8b[2]; + buf[pos + 3] = f8b[3]; + buf[pos + 4] = f8b[4]; + buf[pos + 5] = f8b[5]; + buf[pos + 6] = f8b[6]; + buf[pos + 7] = f8b[7]; + } + function writeDouble_f64_rev(val, buf, pos) { + f64[0] = val; + buf[pos] = f8b[7]; + buf[pos + 1] = f8b[6]; + buf[pos + 2] = f8b[5]; + buf[pos + 3] = f8b[4]; + buf[pos + 4] = f8b[3]; + buf[pos + 5] = f8b[2]; + buf[pos + 6] = f8b[1]; + buf[pos + 7] = f8b[0]; + } + exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev; + exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy; + function readDouble_f64_cpy(buf, pos) { + f8b[0] = buf[pos]; + f8b[1] = buf[pos + 1]; + f8b[2] = buf[pos + 2]; + f8b[3] = buf[pos + 3]; + f8b[4] = buf[pos + 4]; + f8b[5] = buf[pos + 5]; + f8b[6] = buf[pos + 6]; + f8b[7] = buf[pos + 7]; + return f64[0]; + } + function readDouble_f64_rev(buf, pos) { + f8b[7] = buf[pos]; + f8b[6] = buf[pos + 1]; + f8b[5] = buf[pos + 2]; + f8b[4] = buf[pos + 3]; + f8b[3] = buf[pos + 4]; + f8b[2] = buf[pos + 5]; + f8b[1] = buf[pos + 6]; + f8b[0] = buf[pos + 7]; + return f64[0]; + } + exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev; + exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy; + })(); + else + (function() { + function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) { + var sign = val < 0 ? 1 : 0; + if (sign) + val = -val; + if (val === 0) { + writeUint(0, buf, pos + off0); + writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos + off1); + } else if (isNaN(val)) { + writeUint(0, buf, pos + off0); + writeUint(2146959360, buf, pos + off1); + } else if (val > 17976931348623157e292) { + writeUint(0, buf, pos + off0); + writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1); + } else { + var mantissa; + if (val < 22250738585072014e-324) { + mantissa = val / 5e-324; + writeUint(mantissa >>> 0, buf, pos + off0); + writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1); + } else { + var exponent = Math.floor(Math.log(val) / Math.LN2); + if (exponent === 1024) + exponent = 1023; + mantissa = val * Math.pow(2, -exponent); + writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0); + writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1); + } + } + } + exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4); + exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0); + function readDouble_ieee754(readUint, off0, off1, buf, pos) { + var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1); + var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo; + return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496); + } + exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4); + exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0); + })(); + return exports3; + } + function writeUintLE(val, buf, pos) { + buf[pos] = val & 255; + buf[pos + 1] = val >>> 8 & 255; + buf[pos + 2] = val >>> 16 & 255; + buf[pos + 3] = val >>> 24; + } + function writeUintBE(val, buf, pos) { + buf[pos] = val >>> 24; + buf[pos + 1] = val >>> 16 & 255; + buf[pos + 2] = val >>> 8 & 255; + buf[pos + 3] = val & 255; + } + function readUintLE(buf, pos) { + return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0; + } + function readUintBE(buf, pos) { + return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0; + } + } +}); + +// node_modules/@protobufjs/inquire/index.js +var require_inquire = __commonJS({ + "node_modules/@protobufjs/inquire/index.js"(exports, module) { + "use strict"; + module.exports = inquire; + function inquire(moduleName) { + try { + var mod = eval("quire".replace(/^/, "re"))(moduleName); + if (mod && (mod.length || Object.keys(mod).length)) + return mod; + } catch (e) { + } + return null; + } + } +}); + +// node_modules/@protobufjs/utf8/index.js +var require_utf8 = __commonJS({ + "node_modules/@protobufjs/utf8/index.js"(exports2) { + "use strict"; + var utf8 = exports2; + utf8.length = function utf8_length(string) { + var len = 0, c = 0; + for (var i = 0; i < string.length; ++i) { + c = string.charCodeAt(i); + if (c < 128) + len += 1; + else if (c < 2048) + len += 2; + else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) { + ++i; + len += 4; + } else + len += 3; + } + return len; + }; + utf8.read = function utf8_read(buffer, start, end) { + var len = end - start; + if (len < 1) + return ""; + var parts = null, chunk = [], i = 0, t; + while (start < end) { + t = buffer[start++]; + if (t < 128) + chunk[i++] = t; + else if (t > 191 && t < 224) + chunk[i++] = (t & 31) << 6 | buffer[start++] & 63; + else if (t > 239 && t < 365) { + t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536; + chunk[i++] = 55296 + (t >> 10); + chunk[i++] = 56320 + (t & 1023); + } else + chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63; + if (i > 8191) { + (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk)); + i = 0; + } + } + if (parts) { + if (i) + parts.push(String.fromCharCode.apply(String, chunk.slice(0, i))); + return parts.join(""); + } + return String.fromCharCode.apply(String, chunk.slice(0, i)); + }; + utf8.write = function utf8_write(string, buffer, offset) { + var start = offset, c1, c2; + for (var i = 0; i < string.length; ++i) { + c1 = string.charCodeAt(i); + if (c1 < 128) { + buffer[offset++] = c1; + } else if (c1 < 2048) { + buffer[offset++] = c1 >> 6 | 192; + buffer[offset++] = c1 & 63 | 128; + } else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) { + c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023); + ++i; + buffer[offset++] = c1 >> 18 | 240; + buffer[offset++] = c1 >> 12 & 63 | 128; + buffer[offset++] = c1 >> 6 & 63 | 128; + buffer[offset++] = c1 & 63 | 128; + } else { + buffer[offset++] = c1 >> 12 | 224; + buffer[offset++] = c1 >> 6 & 63 | 128; + buffer[offset++] = c1 & 63 | 128; + } + } + return offset - start; + }; + } +}); + +// node_modules/@protobufjs/pool/index.js +var require_pool = __commonJS({ + "node_modules/@protobufjs/pool/index.js"(exports2, module2) { + "use strict"; + module2.exports = pool; + function pool(alloc, slice, size) { + var SIZE = size || 8192; + var MAX = SIZE >>> 1; + var slab = null; + var offset = SIZE; + return function pool_alloc(size2) { + if (size2 < 1 || size2 > MAX) + return alloc(size2); + if (offset + size2 > SIZE) { + slab = alloc(SIZE); + offset = 0; + } + var buf = slice.call(slab, offset, offset += size2); + if (offset & 7) + offset = (offset | 7) + 1; + return buf; + }; + } + } +}); + +// node_modules/@apollo/protobufjs/src/util/longbits.js +var require_longbits = __commonJS({ + "node_modules/@apollo/protobufjs/src/util/longbits.js"(exports2, module2) { + "use strict"; + module2.exports = LongBits; + var util = require_minimal(); + function LongBits(lo, hi) { + this.lo = lo >>> 0; + this.hi = hi >>> 0; + } + var zero = LongBits.zero = new LongBits(0, 0); + zero.toNumber = function() { + return 0; + }; + zero.zzEncode = zero.zzDecode = function() { + return this; + }; + zero.length = function() { + return 1; + }; + var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0"; + LongBits.fromNumber = function fromNumber(value) { + if (value === 0) + return zero; + var sign = value < 0; + if (sign) + value = -value; + var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0; + if (sign) { + hi = ~hi >>> 0; + lo = ~lo >>> 0; + if (++lo > 4294967295) { + lo = 0; + if (++hi > 4294967295) + hi = 0; + } + } + return new LongBits(lo, hi); + }; + LongBits.from = function from(value) { + if (typeof value === "number") + return LongBits.fromNumber(value); + if (util.isString(value)) { + if (util.Long) + value = util.Long.fromString(value); + else + return LongBits.fromNumber(parseInt(value, 10)); + } + return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero; + }; + LongBits.prototype.toNumber = function toNumber(unsigned) { + if (!unsigned && this.hi >>> 31) { + var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0; + if (!lo) + hi = hi + 1 >>> 0; + return -(lo + hi * 4294967296); + } + return this.lo + this.hi * 4294967296; + }; + LongBits.prototype.toLong = function toLong(unsigned) { + return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) }; + }; + var charCodeAt = String.prototype.charCodeAt; + LongBits.fromHash = function fromHash(hash) { + if (hash === zeroHash) + return zero; + return new LongBits((charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0, (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0); + }; + LongBits.prototype.toHash = function toHash() { + return String.fromCharCode(this.lo & 255, this.lo >>> 8 & 255, this.lo >>> 16 & 255, this.lo >>> 24, this.hi & 255, this.hi >>> 8 & 255, this.hi >>> 16 & 255, this.hi >>> 24); + }; + LongBits.prototype.zzEncode = function zzEncode() { + var mask = this.hi >> 31; + this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0; + this.lo = (this.lo << 1 ^ mask) >>> 0; + return this; + }; + LongBits.prototype.zzDecode = function zzDecode() { + var mask = -(this.lo & 1); + this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0; + this.hi = (this.hi >>> 1 ^ mask) >>> 0; + return this; + }; + LongBits.prototype.length = function length() { + var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24; + return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10; + }; + } +}); + +// node_modules/@apollo/protobufjs/src/util/minimal.js +var require_minimal = __commonJS({ + "node_modules/@apollo/protobufjs/src/util/minimal.js"(exports2) { + "use strict"; + var util = exports2; + util.asPromise = require_aspromise(); + util.base64 = require_base64(); + util.EventEmitter = require_eventemitter(); + util.float = require_float(); + util.inquire = require_inquire(); + util.utf8 = require_utf8(); + util.pool = require_pool(); + util.LongBits = require_longbits(); + util.global = typeof window !== "undefined" && window || typeof global !== "undefined" && global || typeof self !== "undefined" && self || exports2; + util.emptyArray = Object.freeze ? Object.freeze([]) : []; + util.emptyObject = Object.freeze ? Object.freeze({}) : {}; + util.isNode = Boolean(util.global.process && util.global.process.versions && util.global.process.versions.node); + util.isInteger = Number.isInteger || function isInteger(value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value; + }; + util.isString = function isString(value) { + return typeof value === "string" || value instanceof String; + }; + util.isObject = function isObject(value) { + return value && typeof value === "object"; + }; + util.isset = util.isSet = function isSet(obj, prop) { + var value = obj[prop]; + if (value != null && obj.hasOwnProperty(prop)) + return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0; + return false; + }; + util.Buffer = function() { + try { + var Buffer2 = util.inquire("buffer").Buffer; + return Buffer2.prototype.utf8Write ? Buffer2 : null; + } catch (e) { + return null; + } + }(); + util._Buffer_from = null; + util._Buffer_allocUnsafe = null; + util.newBuffer = function newBuffer(sizeOrArray) { + return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray); + }; + util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array; + util.Long = util.global.dcodeIO && util.global.dcodeIO.Long || util.global.Long || util.inquire("long"); + util.key2Re = /^true|false|0|1$/; + util.key32Re = /^-?(?:0|[1-9][0-9]*)$/; + util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/; + util.longToHash = function longToHash(value) { + return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash; + }; + util.longFromHash = function longFromHash(hash, unsigned) { + var bits = util.LongBits.fromHash(hash); + if (util.Long) + return util.Long.fromBits(bits.lo, bits.hi, unsigned); + return bits.toNumber(Boolean(unsigned)); + }; + function merge(dst, src, ifNotSet) { + for (var keys = Object.keys(src), i = 0; i < keys.length; ++i) + if (dst[keys[i]] === void 0 || !ifNotSet) + dst[keys[i]] = src[keys[i]]; + return dst; + } + util.merge = merge; + util.lcFirst = function lcFirst(str) { + return str.charAt(0).toLowerCase() + str.substring(1); + }; + function newError(name) { + function CustomError(message, properties) { + if (!(this instanceof CustomError)) + return new CustomError(message, properties); + Object.defineProperty(this, "message", { get: function() { + return message; + } }); + if (Error.captureStackTrace) + Error.captureStackTrace(this, CustomError); + else + Object.defineProperty(this, "stack", { value: new Error().stack || "" }); + if (properties) + merge(this, properties); + } + (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError; + Object.defineProperty(CustomError.prototype, "name", { get: function() { + return name; + } }); + CustomError.prototype.toString = function toString() { + return this.name + ": " + this.message; + }; + return CustomError; + } + util.newError = newError; + util.ProtocolError = newError("ProtocolError"); + util.oneOfGetter = function getOneOf(fieldNames) { + var fieldMap = {}; + for (var i = 0; i < fieldNames.length; ++i) + fieldMap[fieldNames[i]] = 1; + return function() { + for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2) + if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null) + return keys[i2]; + }; + }; + util.oneOfSetter = function setOneOf(fieldNames) { + return function(name) { + for (var i = 0; i < fieldNames.length; ++i) + if (fieldNames[i] !== name) + delete this[fieldNames[i]]; + }; + }; + util.toJSONOptions = { + longs: String, + enums: String, + bytes: String, + json: true + }; + util._configure = function() { + var Buffer2 = util.Buffer; + if (!Buffer2) { + util._Buffer_from = util._Buffer_allocUnsafe = null; + return; + } + util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || function Buffer_from(value, encoding) { + return new Buffer2(value, encoding); + }; + util._Buffer_allocUnsafe = Buffer2.allocUnsafe || function Buffer_allocUnsafe(size) { + return new Buffer2(size); + }; + }; + } +}); + +// node_modules/@apollo/protobufjs/src/writer.js +var require_writer = __commonJS({ + "node_modules/@apollo/protobufjs/src/writer.js"(exports2, module2) { + "use strict"; + module2.exports = Writer; + var util = require_minimal(); + var BufferWriter; + var LongBits = util.LongBits; + var base64 = util.base64; + var utf8 = util.utf8; + function Op(fn, len, val) { + this.fn = fn; + this.len = len; + this.next = void 0; + this.val = val; + } + function noop() { + } + function State(writer) { + this.head = writer.head; + this.tail = writer.tail; + this.len = writer.len; + this.next = writer.states; + } + function Writer() { + this.len = 0; + this.head = new Op(noop, 0, 0); + this.tail = this.head; + this.states = null; + } + Writer.create = util.Buffer ? function create_buffer_setup() { + return (Writer.create = function create_buffer() { + return new BufferWriter(); + })(); + } : function create_array() { + return new Writer(); + }; + Writer.alloc = function alloc(size) { + return new util.Array(size); + }; + if (util.Array !== Array) + Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray); + Writer.prototype._push = function push(fn, len, val) { + this.tail = this.tail.next = new Op(fn, len, val); + this.len += len; + return this; + }; + function writeByte(val, buf, pos) { + buf[pos] = val & 255; + } + function writeVarint32(val, buf, pos) { + while (val > 127) { + buf[pos++] = val & 127 | 128; + val >>>= 7; + } + buf[pos] = val; + } + function VarintOp(len, val) { + this.len = len; + this.next = void 0; + this.val = val; + } + VarintOp.prototype = Object.create(Op.prototype); + VarintOp.prototype.fn = writeVarint32; + Writer.prototype.uint32 = function write_uint32(value) { + this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len; + return this; + }; + Writer.prototype.int32 = function write_int32(value) { + return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value); + }; + Writer.prototype.sint32 = function write_sint32(value) { + return this.uint32((value << 1 ^ value >> 31) >>> 0); + }; + function writeVarint64(val, buf, pos) { + while (val.hi) { + buf[pos++] = val.lo & 127 | 128; + val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0; + val.hi >>>= 7; + } + while (val.lo > 127) { + buf[pos++] = val.lo & 127 | 128; + val.lo = val.lo >>> 7; + } + buf[pos++] = val.lo; + } + Writer.prototype.uint64 = function write_uint64(value) { + var bits = LongBits.from(value); + return this._push(writeVarint64, bits.length(), bits); + }; + Writer.prototype.int64 = Writer.prototype.uint64; + Writer.prototype.sint64 = function write_sint64(value) { + var bits = LongBits.from(value).zzEncode(); + return this._push(writeVarint64, bits.length(), bits); + }; + Writer.prototype.bool = function write_bool(value) { + return this._push(writeByte, 1, value ? 1 : 0); + }; + function writeFixed32(val, buf, pos) { + buf[pos] = val & 255; + buf[pos + 1] = val >>> 8 & 255; + buf[pos + 2] = val >>> 16 & 255; + buf[pos + 3] = val >>> 24; + } + Writer.prototype.fixed32 = function write_fixed32(value) { + return this._push(writeFixed32, 4, value >>> 0); + }; + Writer.prototype.sfixed32 = Writer.prototype.fixed32; + Writer.prototype.fixed64 = function write_fixed64(value) { + var bits = LongBits.from(value); + return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi); + }; + Writer.prototype.sfixed64 = Writer.prototype.fixed64; + Writer.prototype.float = function write_float(value) { + return this._push(util.float.writeFloatLE, 4, value); + }; + Writer.prototype.double = function write_double(value) { + return this._push(util.float.writeDoubleLE, 8, value); + }; + var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) { + buf.set(val, pos); + } : function writeBytes_for(val, buf, pos) { + for (var i = 0; i < val.length; ++i) + buf[pos + i] = val[i]; + }; + Writer.prototype.bytes = function write_bytes(value) { + var len = value.length >>> 0; + if (!len) + return this._push(writeByte, 1, 0); + if (util.isString(value)) { + var buf = Writer.alloc(len = base64.length(value)); + base64.decode(value, buf, 0); + value = buf; + } + return this.uint32(len)._push(writeBytes, len, value); + }; + Writer.prototype.string = function write_string(value) { + var len = utf8.length(value); + return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0); + }; + Writer.prototype.fork = function fork() { + this.states = new State(this); + this.head = this.tail = new Op(noop, 0, 0); + this.len = 0; + return this; + }; + Writer.prototype.reset = function reset() { + if (this.states) { + this.head = this.states.head; + this.tail = this.states.tail; + this.len = this.states.len; + this.states = this.states.next; + } else { + this.head = this.tail = new Op(noop, 0, 0); + this.len = 0; + } + return this; + }; + Writer.prototype.ldelim = function ldelim() { + var head = this.head, tail = this.tail, len = this.len; + this.reset().uint32(len); + if (len) { + this.tail.next = head.next; + this.tail = tail; + this.len += len; + } + return this; + }; + Writer.prototype.finish = function finish() { + var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0; + while (head) { + head.fn(head.val, buf, pos); + pos += head.len; + head = head.next; + } + return buf; + }; + Writer._configure = function(BufferWriter_) { + BufferWriter = BufferWriter_; + }; + } +}); + +// node_modules/@apollo/protobufjs/src/writer_buffer.js +var require_writer_buffer = __commonJS({ + "node_modules/@apollo/protobufjs/src/writer_buffer.js"(exports2, module2) { + "use strict"; + module2.exports = BufferWriter; + var Writer = require_writer(); + (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter; + var util = require_minimal(); + var Buffer2 = util.Buffer; + function BufferWriter() { + Writer.call(this); + } + BufferWriter.alloc = function alloc_buffer(size) { + return (BufferWriter.alloc = util._Buffer_allocUnsafe)(size); + }; + var writeBytesBuffer = Buffer2 && Buffer2.prototype instanceof Uint8Array && Buffer2.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) { + buf.set(val, pos); + } : function writeBytesBuffer_copy(val, buf, pos) { + if (val.copy) + val.copy(buf, pos, 0, val.length); + else + for (var i = 0; i < val.length; ) + buf[pos++] = val[i++]; + }; + BufferWriter.prototype.bytes = function write_bytes_buffer(value) { + if (util.isString(value)) + value = util._Buffer_from(value, "base64"); + var len = value.length >>> 0; + this.uint32(len); + if (len) + this._push(writeBytesBuffer, len, value); + return this; + }; + function writeStringBuffer(val, buf, pos) { + if (val.length < 40) + util.utf8.write(val, buf, pos); + else + buf.utf8Write(val, pos); + } + BufferWriter.prototype.string = function write_string_buffer(value) { + var len = Buffer2.byteLength(value); + this.uint32(len); + if (len) + this._push(writeStringBuffer, len, value); + return this; + }; + } +}); + +// node_modules/@apollo/protobufjs/src/reader.js +var require_reader = __commonJS({ + "node_modules/@apollo/protobufjs/src/reader.js"(exports2, module2) { + "use strict"; + module2.exports = Reader; + var util = require_minimal(); + var BufferReader; + var LongBits = util.LongBits; + var utf8 = util.utf8; + function indexOutOfRange(reader, writeLength) { + return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len); + } + function Reader(buffer) { + this.buf = buffer; + this.pos = 0; + this.len = buffer.length; + } + var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) { + if (buffer instanceof Uint8Array || Array.isArray(buffer)) + return new Reader(buffer); + throw Error("illegal buffer"); + } : function create_array2(buffer) { + if (Array.isArray(buffer)) + return new Reader(buffer); + throw Error("illegal buffer"); + }; + Reader.create = util.Buffer ? function create_buffer_setup(buffer) { + return (Reader.create = function create_buffer(buffer2) { + return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2); + })(buffer); + } : create_array; + Reader.prototype._slice = util.Array.prototype.subarray || util.Array.prototype.slice; + Reader.prototype.uint32 = function read_uint32_setup() { + var value = 4294967295; + return function read_uint32() { + value = (this.buf[this.pos] & 127) >>> 0; + if (this.buf[this.pos++] < 128) + return value; + value = (value | (this.buf[this.pos] & 127) << 7) >>> 0; + if (this.buf[this.pos++] < 128) + return value; + value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; + if (this.buf[this.pos++] < 128) + return value; + value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; + if (this.buf[this.pos++] < 128) + return value; + value = (value | (this.buf[this.pos] & 15) << 28) >>> 0; + if (this.buf[this.pos++] < 128) + return value; + if ((this.pos += 5) > this.len) { + this.pos = this.len; + throw indexOutOfRange(this, 10); + } + return value; + }; + }(); + Reader.prototype.int32 = function read_int32() { + return this.uint32() | 0; + }; + Reader.prototype.sint32 = function read_sint32() { + var value = this.uint32(); + return value >>> 1 ^ -(value & 1) | 0; + }; + function readLongVarint() { + var bits = new LongBits(0, 0); + var i = 0; + if (this.len - this.pos > 4) { + for (; i < 4; ++i) { + bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0; + if (this.buf[this.pos++] < 128) + return bits; + } + bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0; + bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0; + if (this.buf[this.pos++] < 128) + return bits; + i = 0; + } else { + for (; i < 3; ++i) { + if (this.pos >= this.len) + throw indexOutOfRange(this); + bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0; + if (this.buf[this.pos++] < 128) + return bits; + } + bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0; + return bits; + } + if (this.len - this.pos > 4) { + for (; i < 5; ++i) { + bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0; + if (this.buf[this.pos++] < 128) + return bits; + } + } else { + for (; i < 5; ++i) { + if (this.pos >= this.len) + throw indexOutOfRange(this); + bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0; + if (this.buf[this.pos++] < 128) + return bits; + } + } + throw Error("invalid varint encoding"); + } + Reader.prototype.bool = function read_bool() { + return this.uint32() !== 0; + }; + function readFixed32_end(buf, end) { + return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0; + } + Reader.prototype.fixed32 = function read_fixed32() { + if (this.pos + 4 > this.len) + throw indexOutOfRange(this, 4); + return readFixed32_end(this.buf, this.pos += 4); + }; + Reader.prototype.sfixed32 = function read_sfixed32() { + if (this.pos + 4 > this.len) + throw indexOutOfRange(this, 4); + return readFixed32_end(this.buf, this.pos += 4) | 0; + }; + function readFixed64() { + if (this.pos + 8 > this.len) + throw indexOutOfRange(this, 8); + return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4)); + } + Reader.prototype.float = function read_float() { + if (this.pos + 4 > this.len) + throw indexOutOfRange(this, 4); + var value = util.float.readFloatLE(this.buf, this.pos); + this.pos += 4; + return value; + }; + Reader.prototype.double = function read_double() { + if (this.pos + 8 > this.len) + throw indexOutOfRange(this, 4); + var value = util.float.readDoubleLE(this.buf, this.pos); + this.pos += 8; + return value; + }; + Reader.prototype.bytes = function read_bytes() { + var length = this.uint32(), start = this.pos, end = this.pos + length; + if (end > this.len) + throw indexOutOfRange(this, length); + this.pos += length; + if (Array.isArray(this.buf)) + return this.buf.slice(start, end); + return start === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start, end); + }; + Reader.prototype.string = function read_string() { + var bytes = this.bytes(); + return utf8.read(bytes, 0, bytes.length); + }; + Reader.prototype.skip = function skip(length) { + if (typeof length === "number") { + if (this.pos + length > this.len) + throw indexOutOfRange(this, length); + this.pos += length; + } else { + do { + if (this.pos >= this.len) + throw indexOutOfRange(this); + } while (this.buf[this.pos++] & 128); + } + return this; + }; + Reader.prototype.skipType = function(wireType) { + switch (wireType) { + case 0: + this.skip(); + break; + case 1: + this.skip(8); + break; + case 2: + this.skip(this.uint32()); + break; + case 3: + while ((wireType = this.uint32() & 7) !== 4) { + this.skipType(wireType); + } + break; + case 5: + this.skip(4); + break; + default: + throw Error("invalid wire type " + wireType + " at offset " + this.pos); + } + return this; + }; + Reader._configure = function(BufferReader_) { + BufferReader = BufferReader_; + var fn = util.Long ? "toLong" : "toNumber"; + util.merge(Reader.prototype, { + int64: function read_int64() { + return readLongVarint.call(this)[fn](false); + }, + uint64: function read_uint64() { + return readLongVarint.call(this)[fn](true); + }, + sint64: function read_sint64() { + return readLongVarint.call(this).zzDecode()[fn](false); + }, + fixed64: function read_fixed64() { + return readFixed64.call(this)[fn](true); + }, + sfixed64: function read_sfixed64() { + return readFixed64.call(this)[fn](false); + } + }); + }; + } +}); + +// node_modules/@apollo/protobufjs/src/reader_buffer.js +var require_reader_buffer = __commonJS({ + "node_modules/@apollo/protobufjs/src/reader_buffer.js"(exports2, module2) { + "use strict"; + module2.exports = BufferReader; + var Reader = require_reader(); + (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader; + var util = require_minimal(); + function BufferReader(buffer) { + Reader.call(this, buffer); + } + if (util.Buffer) + BufferReader.prototype._slice = util.Buffer.prototype.slice; + BufferReader.prototype.string = function read_string_buffer() { + var len = this.uint32(); + return this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)); + }; + } +}); + +// node_modules/@apollo/protobufjs/src/rpc/service.js +var require_service = __commonJS({ + "node_modules/@apollo/protobufjs/src/rpc/service.js"(exports2, module2) { + "use strict"; + module2.exports = Service; + var util = require_minimal(); + (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service; + function Service(rpcImpl, requestDelimited, responseDelimited) { + if (typeof rpcImpl !== "function") + throw TypeError("rpcImpl must be a function"); + util.EventEmitter.call(this); + this.rpcImpl = rpcImpl; + this.requestDelimited = Boolean(requestDelimited); + this.responseDelimited = Boolean(responseDelimited); + } + Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) { + if (!request) + throw TypeError("request must be specified"); + var self2 = this; + if (!callback) + return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request); + if (!self2.rpcImpl) { + setTimeout(function() { + callback(Error("already ended")); + }, 0); + return void 0; + } + try { + return self2.rpcImpl(method, requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), function rpcCallback(err, response) { + if (err) { + self2.emit("error", err, method); + return callback(err); + } + if (response === null) { + self2.end(true); + return void 0; + } + if (!(response instanceof responseCtor)) { + try { + response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response); + } catch (err2) { + self2.emit("error", err2, method); + return callback(err2); + } + } + self2.emit("data", response, method); + return callback(null, response); + }); + } catch (err) { + self2.emit("error", err, method); + setTimeout(function() { + callback(err); + }, 0); + return void 0; + } + }; + Service.prototype.end = function end(endedByRPC) { + if (this.rpcImpl) { + if (!endedByRPC) + this.rpcImpl(null, null, null); + this.rpcImpl = null; + this.emit("end").off(); + } + return this; + }; + } +}); + +// node_modules/@apollo/protobufjs/src/rpc.js +var require_rpc = __commonJS({ + "node_modules/@apollo/protobufjs/src/rpc.js"(exports2) { + "use strict"; + var rpc = exports2; + rpc.Service = require_service(); + } +}); + +// node_modules/@apollo/protobufjs/src/roots.js +var require_roots = __commonJS({ + "node_modules/@apollo/protobufjs/src/roots.js"(exports2, module2) { + "use strict"; + module2.exports = {}; + } +}); + +// node_modules/@apollo/protobufjs/src/index-minimal.js +var require_index_minimal = __commonJS({ + "node_modules/@apollo/protobufjs/src/index-minimal.js"(exports2) { + "use strict"; + var protobuf = exports2; + protobuf.build = "minimal"; + protobuf.Writer = require_writer(); + protobuf.BufferWriter = require_writer_buffer(); + protobuf.Reader = require_reader(); + protobuf.BufferReader = require_reader_buffer(); + protobuf.util = require_minimal(); + protobuf.rpc = require_rpc(); + protobuf.roots = require_roots(); + protobuf.configure = configure; + function configure() { + protobuf.Reader._configure(protobuf.BufferReader); + protobuf.util._configure(); + } + protobuf.Writer._configure(protobuf.BufferWriter); + configure(); + } +}); + +// node_modules/@apollo/protobufjs/minimal.js +var require_minimal2 = __commonJS({ + "node_modules/@apollo/protobufjs/minimal.js"(exports2, module2) { + "use strict"; + module2.exports = require_index_minimal(); + } +}); + +// node_modules/apollo-reporting-protobuf/generated/protobuf.js +var require_protobuf = __commonJS({ + "node_modules/apollo-reporting-protobuf/generated/protobuf.js"(exports2, module2) { + "use strict"; + var $protobuf = require_minimal2(); + var $Reader = $protobuf.Reader; + var $Writer = $protobuf.Writer; + var $util = $protobuf.util; + var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + $root.Trace = function() { + function Trace(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Trace.prototype.startTime = null; + Trace.prototype.endTime = null; + Trace.prototype.durationNs = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Trace.prototype.root = null; + Trace.prototype.signature = ""; + Trace.prototype.unexecutedOperationBody = ""; + Trace.prototype.unexecutedOperationName = ""; + Trace.prototype.details = null; + Trace.prototype.clientName = ""; + Trace.prototype.clientVersion = ""; + Trace.prototype.http = null; + Trace.prototype.cachePolicy = null; + Trace.prototype.queryPlan = null; + Trace.prototype.fullQueryCacheHit = false; + Trace.prototype.persistedQueryHit = false; + Trace.prototype.persistedQueryRegister = false; + Trace.prototype.registeredOperation = false; + Trace.prototype.forbiddenOperation = false; + Trace.prototype.fieldExecutionWeight = 0; + Trace.create = function create(properties) { + return new Trace(properties); + }; + Trace.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.endTime != null && Object.hasOwnProperty.call(message, "endTime")) + $root.google.protobuf.Timestamp.encode(message.endTime, writer.uint32(26).fork()).ldelim(); + if (message.startTime != null && Object.hasOwnProperty.call(message, "startTime")) + $root.google.protobuf.Timestamp.encode(message.startTime, writer.uint32(34).fork()).ldelim(); + if (message.details != null && Object.hasOwnProperty.call(message, "details")) + $root.Trace.Details.encode(message.details, writer.uint32(50).fork()).ldelim(); + if (message.clientName != null && Object.hasOwnProperty.call(message, "clientName")) + writer.uint32(58).string(message.clientName); + if (message.clientVersion != null && Object.hasOwnProperty.call(message, "clientVersion")) + writer.uint32(66).string(message.clientVersion); + if (message.http != null && Object.hasOwnProperty.call(message, "http")) + $root.Trace.HTTP.encode(message.http, writer.uint32(82).fork()).ldelim(); + if (message.durationNs != null && Object.hasOwnProperty.call(message, "durationNs")) + writer.uint32(88).uint64(message.durationNs); + if (message.root != null && Object.hasOwnProperty.call(message, "root")) + $root.Trace.Node.encode(message.root, writer.uint32(114).fork()).ldelim(); + if (message.cachePolicy != null && Object.hasOwnProperty.call(message, "cachePolicy")) + $root.Trace.CachePolicy.encode(message.cachePolicy, writer.uint32(146).fork()).ldelim(); + if (message.signature != null && Object.hasOwnProperty.call(message, "signature")) + writer.uint32(154).string(message.signature); + if (message.fullQueryCacheHit != null && Object.hasOwnProperty.call(message, "fullQueryCacheHit")) + writer.uint32(160).bool(message.fullQueryCacheHit); + if (message.persistedQueryHit != null && Object.hasOwnProperty.call(message, "persistedQueryHit")) + writer.uint32(168).bool(message.persistedQueryHit); + if (message.persistedQueryRegister != null && Object.hasOwnProperty.call(message, "persistedQueryRegister")) + writer.uint32(176).bool(message.persistedQueryRegister); + if (message.registeredOperation != null && Object.hasOwnProperty.call(message, "registeredOperation")) + writer.uint32(192).bool(message.registeredOperation); + if (message.forbiddenOperation != null && Object.hasOwnProperty.call(message, "forbiddenOperation")) + writer.uint32(200).bool(message.forbiddenOperation); + if (message.queryPlan != null && Object.hasOwnProperty.call(message, "queryPlan")) + $root.Trace.QueryPlanNode.encode(message.queryPlan, writer.uint32(210).fork()).ldelim(); + if (message.unexecutedOperationBody != null && Object.hasOwnProperty.call(message, "unexecutedOperationBody")) + writer.uint32(218).string(message.unexecutedOperationBody); + if (message.unexecutedOperationName != null && Object.hasOwnProperty.call(message, "unexecutedOperationName")) + writer.uint32(226).string(message.unexecutedOperationName); + if (message.fieldExecutionWeight != null && Object.hasOwnProperty.call(message, "fieldExecutionWeight")) + writer.uint32(249).double(message.fieldExecutionWeight); + return writer; + }; + Trace.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Trace.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 4: + message.startTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32()); + break; + case 3: + message.endTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32()); + break; + case 11: + message.durationNs = reader.uint64(); + break; + case 14: + message.root = $root.Trace.Node.decode(reader, reader.uint32()); + break; + case 19: + message.signature = reader.string(); + break; + case 27: + message.unexecutedOperationBody = reader.string(); + break; + case 28: + message.unexecutedOperationName = reader.string(); + break; + case 6: + message.details = $root.Trace.Details.decode(reader, reader.uint32()); + break; + case 7: + message.clientName = reader.string(); + break; + case 8: + message.clientVersion = reader.string(); + break; + case 10: + message.http = $root.Trace.HTTP.decode(reader, reader.uint32()); + break; + case 18: + message.cachePolicy = $root.Trace.CachePolicy.decode(reader, reader.uint32()); + break; + case 26: + message.queryPlan = $root.Trace.QueryPlanNode.decode(reader, reader.uint32()); + break; + case 20: + message.fullQueryCacheHit = reader.bool(); + break; + case 21: + message.persistedQueryHit = reader.bool(); + break; + case 22: + message.persistedQueryRegister = reader.bool(); + break; + case 24: + message.registeredOperation = reader.bool(); + break; + case 25: + message.forbiddenOperation = reader.bool(); + break; + case 31: + message.fieldExecutionWeight = reader.double(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Trace.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Trace.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.startTime != null && message.hasOwnProperty("startTime")) { + var error = $root.google.protobuf.Timestamp.verify(message.startTime); + if (error) + return "startTime." + error; + } + if (message.endTime != null && message.hasOwnProperty("endTime")) { + var error = $root.google.protobuf.Timestamp.verify(message.endTime); + if (error) + return "endTime." + error; + } + if (message.durationNs != null && message.hasOwnProperty("durationNs")) { + if (!$util.isInteger(message.durationNs) && !(message.durationNs && $util.isInteger(message.durationNs.low) && $util.isInteger(message.durationNs.high))) + return "durationNs: integer|Long expected"; + } + if (message.root != null && message.hasOwnProperty("root")) { + var error = $root.Trace.Node.verify(message.root); + if (error) + return "root." + error; + } + if (message.signature != null && message.hasOwnProperty("signature")) { + if (!$util.isString(message.signature)) + return "signature: string expected"; + } + if (message.unexecutedOperationBody != null && message.hasOwnProperty("unexecutedOperationBody")) { + if (!$util.isString(message.unexecutedOperationBody)) + return "unexecutedOperationBody: string expected"; + } + if (message.unexecutedOperationName != null && message.hasOwnProperty("unexecutedOperationName")) { + if (!$util.isString(message.unexecutedOperationName)) + return "unexecutedOperationName: string expected"; + } + if (message.details != null && message.hasOwnProperty("details")) { + var error = $root.Trace.Details.verify(message.details); + if (error) + return "details." + error; + } + if (message.clientName != null && message.hasOwnProperty("clientName")) { + if (!$util.isString(message.clientName)) + return "clientName: string expected"; + } + if (message.clientVersion != null && message.hasOwnProperty("clientVersion")) { + if (!$util.isString(message.clientVersion)) + return "clientVersion: string expected"; + } + if (message.http != null && message.hasOwnProperty("http")) { + var error = $root.Trace.HTTP.verify(message.http); + if (error) + return "http." + error; + } + if (message.cachePolicy != null && message.hasOwnProperty("cachePolicy")) { + var error = $root.Trace.CachePolicy.verify(message.cachePolicy); + if (error) + return "cachePolicy." + error; + } + if (message.queryPlan != null && message.hasOwnProperty("queryPlan")) { + var error = $root.Trace.QueryPlanNode.verify(message.queryPlan); + if (error) + return "queryPlan." + error; + } + if (message.fullQueryCacheHit != null && message.hasOwnProperty("fullQueryCacheHit")) { + if (typeof message.fullQueryCacheHit !== "boolean") + return "fullQueryCacheHit: boolean expected"; + } + if (message.persistedQueryHit != null && message.hasOwnProperty("persistedQueryHit")) { + if (typeof message.persistedQueryHit !== "boolean") + return "persistedQueryHit: boolean expected"; + } + if (message.persistedQueryRegister != null && message.hasOwnProperty("persistedQueryRegister")) { + if (typeof message.persistedQueryRegister !== "boolean") + return "persistedQueryRegister: boolean expected"; + } + if (message.registeredOperation != null && message.hasOwnProperty("registeredOperation")) { + if (typeof message.registeredOperation !== "boolean") + return "registeredOperation: boolean expected"; + } + if (message.forbiddenOperation != null && message.hasOwnProperty("forbiddenOperation")) { + if (typeof message.forbiddenOperation !== "boolean") + return "forbiddenOperation: boolean expected"; + } + if (message.fieldExecutionWeight != null && message.hasOwnProperty("fieldExecutionWeight")) { + if (typeof message.fieldExecutionWeight !== "number") + return "fieldExecutionWeight: number expected"; + } + return null; + }; + Trace.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.endTime = null; + object.startTime = null; + object.details = null; + object.clientName = ""; + object.clientVersion = ""; + object.http = null; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.durationNs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.durationNs = options.longs === String ? "0" : 0; + object.root = null; + object.cachePolicy = null; + object.signature = ""; + object.fullQueryCacheHit = false; + object.persistedQueryHit = false; + object.persistedQueryRegister = false; + object.registeredOperation = false; + object.forbiddenOperation = false; + object.queryPlan = null; + object.unexecutedOperationBody = ""; + object.unexecutedOperationName = ""; + object.fieldExecutionWeight = 0; + } + if (message.endTime != null && message.hasOwnProperty("endTime")) + object.endTime = $root.google.protobuf.Timestamp.toObject(message.endTime, options); + if (message.startTime != null && message.hasOwnProperty("startTime")) + object.startTime = $root.google.protobuf.Timestamp.toObject(message.startTime, options); + if (message.details != null && message.hasOwnProperty("details")) + object.details = $root.Trace.Details.toObject(message.details, options); + if (message.clientName != null && message.hasOwnProperty("clientName")) + object.clientName = message.clientName; + if (message.clientVersion != null && message.hasOwnProperty("clientVersion")) + object.clientVersion = message.clientVersion; + if (message.http != null && message.hasOwnProperty("http")) + object.http = $root.Trace.HTTP.toObject(message.http, options); + if (message.durationNs != null && message.hasOwnProperty("durationNs")) + if (typeof message.durationNs === "number") + object.durationNs = options.longs === String ? String(message.durationNs) : message.durationNs; + else + object.durationNs = options.longs === String ? $util.Long.prototype.toString.call(message.durationNs) : options.longs === Number ? new $util.LongBits(message.durationNs.low >>> 0, message.durationNs.high >>> 0).toNumber(true) : message.durationNs; + if (message.root != null && message.hasOwnProperty("root")) + object.root = $root.Trace.Node.toObject(message.root, options); + if (message.cachePolicy != null && message.hasOwnProperty("cachePolicy")) + object.cachePolicy = $root.Trace.CachePolicy.toObject(message.cachePolicy, options); + if (message.signature != null && message.hasOwnProperty("signature")) + object.signature = message.signature; + if (message.fullQueryCacheHit != null && message.hasOwnProperty("fullQueryCacheHit")) + object.fullQueryCacheHit = message.fullQueryCacheHit; + if (message.persistedQueryHit != null && message.hasOwnProperty("persistedQueryHit")) + object.persistedQueryHit = message.persistedQueryHit; + if (message.persistedQueryRegister != null && message.hasOwnProperty("persistedQueryRegister")) + object.persistedQueryRegister = message.persistedQueryRegister; + if (message.registeredOperation != null && message.hasOwnProperty("registeredOperation")) + object.registeredOperation = message.registeredOperation; + if (message.forbiddenOperation != null && message.hasOwnProperty("forbiddenOperation")) + object.forbiddenOperation = message.forbiddenOperation; + if (message.queryPlan != null && message.hasOwnProperty("queryPlan")) + object.queryPlan = $root.Trace.QueryPlanNode.toObject(message.queryPlan, options); + if (message.unexecutedOperationBody != null && message.hasOwnProperty("unexecutedOperationBody")) + object.unexecutedOperationBody = message.unexecutedOperationBody; + if (message.unexecutedOperationName != null && message.hasOwnProperty("unexecutedOperationName")) + object.unexecutedOperationName = message.unexecutedOperationName; + if (message.fieldExecutionWeight != null && message.hasOwnProperty("fieldExecutionWeight")) + object.fieldExecutionWeight = options.json && !isFinite(message.fieldExecutionWeight) ? String(message.fieldExecutionWeight) : message.fieldExecutionWeight; + return object; + }; + Trace.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + Trace.CachePolicy = function() { + function CachePolicy(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + CachePolicy.prototype.scope = 0; + CachePolicy.prototype.maxAgeNs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + CachePolicy.create = function create(properties) { + return new CachePolicy(properties); + }; + CachePolicy.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.scope != null && Object.hasOwnProperty.call(message, "scope")) + writer.uint32(8).int32(message.scope); + if (message.maxAgeNs != null && Object.hasOwnProperty.call(message, "maxAgeNs")) + writer.uint32(16).int64(message.maxAgeNs); + return writer; + }; + CachePolicy.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + CachePolicy.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.CachePolicy(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.scope = reader.int32(); + break; + case 2: + message.maxAgeNs = reader.int64(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + CachePolicy.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + CachePolicy.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.scope != null && message.hasOwnProperty("scope")) + switch (message.scope) { + default: + return "scope: enum value expected"; + case 0: + case 1: + case 2: + break; + } + if (message.maxAgeNs != null && message.hasOwnProperty("maxAgeNs")) { + if (!$util.isInteger(message.maxAgeNs) && !(message.maxAgeNs && $util.isInteger(message.maxAgeNs.low) && $util.isInteger(message.maxAgeNs.high))) + return "maxAgeNs: integer|Long expected"; + } + return null; + }; + CachePolicy.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.scope = options.enums === String ? "UNKNOWN" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, false); + object.maxAgeNs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.maxAgeNs = options.longs === String ? "0" : 0; + } + if (message.scope != null && message.hasOwnProperty("scope")) + object.scope = options.enums === String ? $root.Trace.CachePolicy.Scope[message.scope] : message.scope; + if (message.maxAgeNs != null && message.hasOwnProperty("maxAgeNs")) + if (typeof message.maxAgeNs === "number") + object.maxAgeNs = options.longs === String ? String(message.maxAgeNs) : message.maxAgeNs; + else + object.maxAgeNs = options.longs === String ? $util.Long.prototype.toString.call(message.maxAgeNs) : options.longs === Number ? new $util.LongBits(message.maxAgeNs.low >>> 0, message.maxAgeNs.high >>> 0).toNumber() : message.maxAgeNs; + return object; + }; + CachePolicy.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + CachePolicy.Scope = function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "UNKNOWN"] = 0; + values[valuesById[1] = "PUBLIC"] = 1; + values[valuesById[2] = "PRIVATE"] = 2; + return values; + }(); + return CachePolicy; + }(); + Trace.Details = function() { + function Details(properties) { + this.variablesJson = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Details.prototype.variablesJson = $util.emptyObject; + Details.prototype.operationName = ""; + Details.create = function create(properties) { + return new Details(properties); + }; + Details.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.operationName != null && Object.hasOwnProperty.call(message, "operationName")) + writer.uint32(26).string(message.operationName); + if (message.variablesJson != null && Object.hasOwnProperty.call(message, "variablesJson")) + for (var keys = Object.keys(message.variablesJson), i = 0; i < keys.length; ++i) + writer.uint32(34).fork().uint32(10).string(keys[i]).uint32(18).string(message.variablesJson[keys[i]]).ldelim(); + return writer; + }; + Details.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Details.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.Details(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 4: + reader.skip().pos++; + if (message.variablesJson === $util.emptyObject) + message.variablesJson = {}; + key = reader.string(); + reader.pos++; + message.variablesJson[key] = reader.string(); + break; + case 3: + message.operationName = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Details.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Details.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.variablesJson != null && message.hasOwnProperty("variablesJson")) { + if (!$util.isObject(message.variablesJson)) + return "variablesJson: object expected"; + var key = Object.keys(message.variablesJson); + for (var i = 0; i < key.length; ++i) + if (!$util.isString(message.variablesJson[key[i]])) + return "variablesJson: string{k:string} expected"; + } + if (message.operationName != null && message.hasOwnProperty("operationName")) { + if (!$util.isString(message.operationName)) + return "operationName: string expected"; + } + return null; + }; + Details.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) + object.variablesJson = {}; + if (options.defaults) + object.operationName = ""; + if (message.operationName != null && message.hasOwnProperty("operationName")) + object.operationName = message.operationName; + var keys2; + if (message.variablesJson && (keys2 = Object.keys(message.variablesJson)).length) { + object.variablesJson = {}; + for (var j = 0; j < keys2.length; ++j) + object.variablesJson[keys2[j]] = message.variablesJson[keys2[j]]; + } + return object; + }; + Details.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Details; + }(); + Trace.Error = function() { + function Error2(properties) { + this.location = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Error2.prototype.message = ""; + Error2.prototype.location = $util.emptyArray; + Error2.prototype.timeNs = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Error2.prototype.json = ""; + Error2.create = function create(properties) { + return new Error2(properties); + }; + Error2.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.message != null && Object.hasOwnProperty.call(message, "message")) + writer.uint32(10).string(message.message); + if (message.location != null && message.location.length) + for (var i = 0; i < message.location.length; ++i) + $root.Trace.Location.encode(message.location[i], writer.uint32(18).fork()).ldelim(); + if (message.timeNs != null && Object.hasOwnProperty.call(message, "timeNs")) + writer.uint32(24).uint64(message.timeNs); + if (message.json != null && Object.hasOwnProperty.call(message, "json")) + writer.uint32(34).string(message.json); + return writer; + }; + Error2.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Error2.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.Error(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.message = reader.string(); + break; + case 2: + if (!(message.location && message.location.length)) + message.location = []; + message.location.push($root.Trace.Location.decode(reader, reader.uint32())); + break; + case 3: + message.timeNs = reader.uint64(); + break; + case 4: + message.json = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Error2.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Error2.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.message != null && message.hasOwnProperty("message")) { + if (!$util.isString(message.message)) + return "message: string expected"; + } + if (message.location != null && message.hasOwnProperty("location")) { + if (!Array.isArray(message.location)) + return "location: array expected"; + for (var i = 0; i < message.location.length; ++i) { + var error = $root.Trace.Location.verify(message.location[i]); + if (error) + return "location." + error; + } + } + if (message.timeNs != null && message.hasOwnProperty("timeNs")) { + if (!$util.isInteger(message.timeNs) && !(message.timeNs && $util.isInteger(message.timeNs.low) && $util.isInteger(message.timeNs.high))) + return "timeNs: integer|Long expected"; + } + if (message.json != null && message.hasOwnProperty("json")) { + if (!$util.isString(message.json)) + return "json: string expected"; + } + return null; + }; + Error2.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.location = []; + if (options.defaults) { + object.message = ""; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.timeNs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.timeNs = options.longs === String ? "0" : 0; + object.json = ""; + } + if (message.message != null && message.hasOwnProperty("message")) + object.message = message.message; + if (message.location && message.location.length) { + object.location = []; + for (var j = 0; j < message.location.length; ++j) + object.location[j] = $root.Trace.Location.toObject(message.location[j], options); + } + if (message.timeNs != null && message.hasOwnProperty("timeNs")) + if (typeof message.timeNs === "number") + object.timeNs = options.longs === String ? String(message.timeNs) : message.timeNs; + else + object.timeNs = options.longs === String ? $util.Long.prototype.toString.call(message.timeNs) : options.longs === Number ? new $util.LongBits(message.timeNs.low >>> 0, message.timeNs.high >>> 0).toNumber(true) : message.timeNs; + if (message.json != null && message.hasOwnProperty("json")) + object.json = message.json; + return object; + }; + Error2.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Error2; + }(); + Trace.HTTP = function() { + function HTTP(properties) { + this.requestHeaders = {}; + this.responseHeaders = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + HTTP.prototype.method = 0; + HTTP.prototype.host = ""; + HTTP.prototype.path = ""; + HTTP.prototype.requestHeaders = $util.emptyObject; + HTTP.prototype.responseHeaders = $util.emptyObject; + HTTP.prototype.statusCode = 0; + HTTP.prototype.secure = false; + HTTP.prototype.protocol = ""; + HTTP.create = function create(properties) { + return new HTTP(properties); + }; + HTTP.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.method != null && Object.hasOwnProperty.call(message, "method")) + writer.uint32(8).int32(message.method); + if (message.host != null && Object.hasOwnProperty.call(message, "host")) + writer.uint32(18).string(message.host); + if (message.path != null && Object.hasOwnProperty.call(message, "path")) + writer.uint32(26).string(message.path); + if (message.requestHeaders != null && Object.hasOwnProperty.call(message, "requestHeaders")) + for (var keys = Object.keys(message.requestHeaders), i = 0; i < keys.length; ++i) { + writer.uint32(34).fork().uint32(10).string(keys[i]); + $root.Trace.HTTP.Values.encode(message.requestHeaders[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + if (message.responseHeaders != null && Object.hasOwnProperty.call(message, "responseHeaders")) + for (var keys = Object.keys(message.responseHeaders), i = 0; i < keys.length; ++i) { + writer.uint32(42).fork().uint32(10).string(keys[i]); + $root.Trace.HTTP.Values.encode(message.responseHeaders[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + if (message.statusCode != null && Object.hasOwnProperty.call(message, "statusCode")) + writer.uint32(48).uint32(message.statusCode); + if (message.secure != null && Object.hasOwnProperty.call(message, "secure")) + writer.uint32(64).bool(message.secure); + if (message.protocol != null && Object.hasOwnProperty.call(message, "protocol")) + writer.uint32(74).string(message.protocol); + return writer; + }; + HTTP.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + HTTP.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.HTTP(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.method = reader.int32(); + break; + case 2: + message.host = reader.string(); + break; + case 3: + message.path = reader.string(); + break; + case 4: + reader.skip().pos++; + if (message.requestHeaders === $util.emptyObject) + message.requestHeaders = {}; + key = reader.string(); + reader.pos++; + message.requestHeaders[key] = $root.Trace.HTTP.Values.decode(reader, reader.uint32()); + break; + case 5: + reader.skip().pos++; + if (message.responseHeaders === $util.emptyObject) + message.responseHeaders = {}; + key = reader.string(); + reader.pos++; + message.responseHeaders[key] = $root.Trace.HTTP.Values.decode(reader, reader.uint32()); + break; + case 6: + message.statusCode = reader.uint32(); + break; + case 8: + message.secure = reader.bool(); + break; + case 9: + message.protocol = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + HTTP.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + HTTP.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.method != null && message.hasOwnProperty("method")) + switch (message.method) { + default: + return "method: enum value expected"; + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + break; + } + if (message.host != null && message.hasOwnProperty("host")) { + if (!$util.isString(message.host)) + return "host: string expected"; + } + if (message.path != null && message.hasOwnProperty("path")) { + if (!$util.isString(message.path)) + return "path: string expected"; + } + if (message.requestHeaders != null && message.hasOwnProperty("requestHeaders")) { + if (!$util.isObject(message.requestHeaders)) + return "requestHeaders: object expected"; + var key = Object.keys(message.requestHeaders); + for (var i = 0; i < key.length; ++i) { + var error = $root.Trace.HTTP.Values.verify(message.requestHeaders[key[i]]); + if (error) + return "requestHeaders." + error; + } + } + if (message.responseHeaders != null && message.hasOwnProperty("responseHeaders")) { + if (!$util.isObject(message.responseHeaders)) + return "responseHeaders: object expected"; + var key = Object.keys(message.responseHeaders); + for (var i = 0; i < key.length; ++i) { + var error = $root.Trace.HTTP.Values.verify(message.responseHeaders[key[i]]); + if (error) + return "responseHeaders." + error; + } + } + if (message.statusCode != null && message.hasOwnProperty("statusCode")) { + if (!$util.isInteger(message.statusCode)) + return "statusCode: integer expected"; + } + if (message.secure != null && message.hasOwnProperty("secure")) { + if (typeof message.secure !== "boolean") + return "secure: boolean expected"; + } + if (message.protocol != null && message.hasOwnProperty("protocol")) { + if (!$util.isString(message.protocol)) + return "protocol: string expected"; + } + return null; + }; + HTTP.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) { + object.requestHeaders = {}; + object.responseHeaders = {}; + } + if (options.defaults) { + object.method = options.enums === String ? "UNKNOWN" : 0; + object.host = ""; + object.path = ""; + object.statusCode = 0; + object.secure = false; + object.protocol = ""; + } + if (message.method != null && message.hasOwnProperty("method")) + object.method = options.enums === String ? $root.Trace.HTTP.Method[message.method] : message.method; + if (message.host != null && message.hasOwnProperty("host")) + object.host = message.host; + if (message.path != null && message.hasOwnProperty("path")) + object.path = message.path; + var keys2; + if (message.requestHeaders && (keys2 = Object.keys(message.requestHeaders)).length) { + object.requestHeaders = {}; + for (var j = 0; j < keys2.length; ++j) + object.requestHeaders[keys2[j]] = $root.Trace.HTTP.Values.toObject(message.requestHeaders[keys2[j]], options); + } + if (message.responseHeaders && (keys2 = Object.keys(message.responseHeaders)).length) { + object.responseHeaders = {}; + for (var j = 0; j < keys2.length; ++j) + object.responseHeaders[keys2[j]] = $root.Trace.HTTP.Values.toObject(message.responseHeaders[keys2[j]], options); + } + if (message.statusCode != null && message.hasOwnProperty("statusCode")) + object.statusCode = message.statusCode; + if (message.secure != null && message.hasOwnProperty("secure")) + object.secure = message.secure; + if (message.protocol != null && message.hasOwnProperty("protocol")) + object.protocol = message.protocol; + return object; + }; + HTTP.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + HTTP.Values = function() { + function Values(properties) { + this.value = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Values.prototype.value = $util.emptyArray; + Values.create = function create(properties) { + return new Values(properties); + }; + Values.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.value != null && message.value.length) + for (var i = 0; i < message.value.length; ++i) + writer.uint32(10).string(message.value[i]); + return writer; + }; + Values.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Values.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.HTTP.Values(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.value && message.value.length)) + message.value = []; + message.value.push(reader.string()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Values.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Values.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.value != null && message.hasOwnProperty("value")) { + if (!Array.isArray(message.value)) + return "value: array expected"; + for (var i = 0; i < message.value.length; ++i) + if (!$util.isString(message.value[i])) + return "value: string[] expected"; + } + return null; + }; + Values.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.value = []; + if (message.value && message.value.length) { + object.value = []; + for (var j = 0; j < message.value.length; ++j) + object.value[j] = message.value[j]; + } + return object; + }; + Values.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Values; + }(); + HTTP.Method = function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "UNKNOWN"] = 0; + values[valuesById[1] = "OPTIONS"] = 1; + values[valuesById[2] = "GET"] = 2; + values[valuesById[3] = "HEAD"] = 3; + values[valuesById[4] = "POST"] = 4; + values[valuesById[5] = "PUT"] = 5; + values[valuesById[6] = "DELETE"] = 6; + values[valuesById[7] = "TRACE"] = 7; + values[valuesById[8] = "CONNECT"] = 8; + values[valuesById[9] = "PATCH"] = 9; + return values; + }(); + return HTTP; + }(); + Trace.Location = function() { + function Location(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Location.prototype.line = 0; + Location.prototype.column = 0; + Location.create = function create(properties) { + return new Location(properties); + }; + Location.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.line != null && Object.hasOwnProperty.call(message, "line")) + writer.uint32(8).uint32(message.line); + if (message.column != null && Object.hasOwnProperty.call(message, "column")) + writer.uint32(16).uint32(message.column); + return writer; + }; + Location.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Location.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.Location(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.line = reader.uint32(); + break; + case 2: + message.column = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Location.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Location.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.line != null && message.hasOwnProperty("line")) { + if (!$util.isInteger(message.line)) + return "line: integer expected"; + } + if (message.column != null && message.hasOwnProperty("column")) { + if (!$util.isInteger(message.column)) + return "column: integer expected"; + } + return null; + }; + Location.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.line = 0; + object.column = 0; + } + if (message.line != null && message.hasOwnProperty("line")) + object.line = message.line; + if (message.column != null && message.hasOwnProperty("column")) + object.column = message.column; + return object; + }; + Location.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Location; + }(); + Trace.Node = function() { + function Node(properties) { + this.error = []; + this.child = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Node.prototype.responseName = ""; + Node.prototype.index = 0; + Node.prototype.originalFieldName = ""; + Node.prototype.type = ""; + Node.prototype.parentType = ""; + Node.prototype.cachePolicy = null; + Node.prototype.startTime = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Node.prototype.endTime = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Node.prototype.error = $util.emptyArray; + Node.prototype.child = $util.emptyArray; + var $oneOfFields; + Object.defineProperty(Node.prototype, "id", { + get: $util.oneOfGetter($oneOfFields = ["responseName", "index"]), + set: $util.oneOfSetter($oneOfFields) + }); + Node.create = function create(properties) { + return new Node(properties); + }; + Node.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.responseName != null && Object.hasOwnProperty.call(message, "responseName")) + writer.uint32(10).string(message.responseName); + if (message.index != null && Object.hasOwnProperty.call(message, "index")) + writer.uint32(16).uint32(message.index); + if (message.type != null && Object.hasOwnProperty.call(message, "type")) + writer.uint32(26).string(message.type); + if (message.cachePolicy != null && Object.hasOwnProperty.call(message, "cachePolicy")) + $root.Trace.CachePolicy.encode(message.cachePolicy, writer.uint32(42).fork()).ldelim(); + if (message.startTime != null && Object.hasOwnProperty.call(message, "startTime")) + writer.uint32(64).uint64(message.startTime); + if (message.endTime != null && Object.hasOwnProperty.call(message, "endTime")) + writer.uint32(72).uint64(message.endTime); + if (message.error != null && message.error.length) + for (var i = 0; i < message.error.length; ++i) + $root.Trace.Error.encode(message.error[i], writer.uint32(90).fork()).ldelim(); + if (message.child != null && message.child.length) + for (var i = 0; i < message.child.length; ++i) + $root.Trace.Node.encode(message.child[i], writer.uint32(98).fork()).ldelim(); + if (message.parentType != null && Object.hasOwnProperty.call(message, "parentType")) + writer.uint32(106).string(message.parentType); + if (message.originalFieldName != null && Object.hasOwnProperty.call(message, "originalFieldName")) + writer.uint32(114).string(message.originalFieldName); + return writer; + }; + Node.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Node.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.Node(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.responseName = reader.string(); + break; + case 2: + message.index = reader.uint32(); + break; + case 14: + message.originalFieldName = reader.string(); + break; + case 3: + message.type = reader.string(); + break; + case 13: + message.parentType = reader.string(); + break; + case 5: + message.cachePolicy = $root.Trace.CachePolicy.decode(reader, reader.uint32()); + break; + case 8: + message.startTime = reader.uint64(); + break; + case 9: + message.endTime = reader.uint64(); + break; + case 11: + if (!(message.error && message.error.length)) + message.error = []; + message.error.push($root.Trace.Error.decode(reader, reader.uint32())); + break; + case 12: + if (!(message.child && message.child.length)) + message.child = []; + message.child.push($root.Trace.Node.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Node.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Node.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + var properties = {}; + if (message.responseName != null && message.hasOwnProperty("responseName")) { + properties.id = 1; + if (!$util.isString(message.responseName)) + return "responseName: string expected"; + } + if (message.index != null && message.hasOwnProperty("index")) { + if (properties.id === 1) + return "id: multiple values"; + properties.id = 1; + if (!$util.isInteger(message.index)) + return "index: integer expected"; + } + if (message.originalFieldName != null && message.hasOwnProperty("originalFieldName")) { + if (!$util.isString(message.originalFieldName)) + return "originalFieldName: string expected"; + } + if (message.type != null && message.hasOwnProperty("type")) { + if (!$util.isString(message.type)) + return "type: string expected"; + } + if (message.parentType != null && message.hasOwnProperty("parentType")) { + if (!$util.isString(message.parentType)) + return "parentType: string expected"; + } + if (message.cachePolicy != null && message.hasOwnProperty("cachePolicy")) { + var error = $root.Trace.CachePolicy.verify(message.cachePolicy); + if (error) + return "cachePolicy." + error; + } + if (message.startTime != null && message.hasOwnProperty("startTime")) { + if (!$util.isInteger(message.startTime) && !(message.startTime && $util.isInteger(message.startTime.low) && $util.isInteger(message.startTime.high))) + return "startTime: integer|Long expected"; + } + if (message.endTime != null && message.hasOwnProperty("endTime")) { + if (!$util.isInteger(message.endTime) && !(message.endTime && $util.isInteger(message.endTime.low) && $util.isInteger(message.endTime.high))) + return "endTime: integer|Long expected"; + } + if (message.error != null && message.hasOwnProperty("error")) { + if (!Array.isArray(message.error)) + return "error: array expected"; + for (var i = 0; i < message.error.length; ++i) { + var error = $root.Trace.Error.verify(message.error[i]); + if (error) + return "error." + error; + } + } + if (message.child != null && message.hasOwnProperty("child")) { + if (!Array.isArray(message.child)) + return "child: array expected"; + for (var i = 0; i < message.child.length; ++i) { + var error = $root.Trace.Node.verify(message.child[i]); + if (error) + return "child." + error; + } + } + return null; + }; + Node.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) { + object.error = []; + object.child = []; + } + if (options.defaults) { + object.type = ""; + object.cachePolicy = null; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.startTime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.startTime = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.endTime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.endTime = options.longs === String ? "0" : 0; + object.parentType = ""; + object.originalFieldName = ""; + } + if (message.responseName != null && message.hasOwnProperty("responseName")) { + object.responseName = message.responseName; + if (options.oneofs) + object.id = "responseName"; + } + if (message.index != null && message.hasOwnProperty("index")) { + object.index = message.index; + if (options.oneofs) + object.id = "index"; + } + if (message.type != null && message.hasOwnProperty("type")) + object.type = message.type; + if (message.cachePolicy != null && message.hasOwnProperty("cachePolicy")) + object.cachePolicy = $root.Trace.CachePolicy.toObject(message.cachePolicy, options); + if (message.startTime != null && message.hasOwnProperty("startTime")) + if (typeof message.startTime === "number") + object.startTime = options.longs === String ? String(message.startTime) : message.startTime; + else + object.startTime = options.longs === String ? $util.Long.prototype.toString.call(message.startTime) : options.longs === Number ? new $util.LongBits(message.startTime.low >>> 0, message.startTime.high >>> 0).toNumber(true) : message.startTime; + if (message.endTime != null && message.hasOwnProperty("endTime")) + if (typeof message.endTime === "number") + object.endTime = options.longs === String ? String(message.endTime) : message.endTime; + else + object.endTime = options.longs === String ? $util.Long.prototype.toString.call(message.endTime) : options.longs === Number ? new $util.LongBits(message.endTime.low >>> 0, message.endTime.high >>> 0).toNumber(true) : message.endTime; + if (message.error && message.error.length) { + object.error = []; + for (var j = 0; j < message.error.length; ++j) + object.error[j] = $root.Trace.Error.toObject(message.error[j], options); + } + if (message.child && message.child.length) { + object.child = []; + for (var j = 0; j < message.child.length; ++j) + object.child[j] = $root.Trace.Node.toObject(message.child[j], options); + } + if (message.parentType != null && message.hasOwnProperty("parentType")) + object.parentType = message.parentType; + if (message.originalFieldName != null && message.hasOwnProperty("originalFieldName")) + object.originalFieldName = message.originalFieldName; + return object; + }; + Node.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Node; + }(); + Trace.QueryPlanNode = function() { + function QueryPlanNode(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + QueryPlanNode.prototype.sequence = null; + QueryPlanNode.prototype.parallel = null; + QueryPlanNode.prototype.fetch = null; + QueryPlanNode.prototype.flatten = null; + var $oneOfFields; + Object.defineProperty(QueryPlanNode.prototype, "node", { + get: $util.oneOfGetter($oneOfFields = ["sequence", "parallel", "fetch", "flatten"]), + set: $util.oneOfSetter($oneOfFields) + }); + QueryPlanNode.create = function create(properties) { + return new QueryPlanNode(properties); + }; + QueryPlanNode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.sequence != null && Object.hasOwnProperty.call(message, "sequence")) + $root.Trace.QueryPlanNode.SequenceNode.encode(message.sequence, writer.uint32(10).fork()).ldelim(); + if (message.parallel != null && Object.hasOwnProperty.call(message, "parallel")) + $root.Trace.QueryPlanNode.ParallelNode.encode(message.parallel, writer.uint32(18).fork()).ldelim(); + if (message.fetch != null && Object.hasOwnProperty.call(message, "fetch")) + $root.Trace.QueryPlanNode.FetchNode.encode(message.fetch, writer.uint32(26).fork()).ldelim(); + if (message.flatten != null && Object.hasOwnProperty.call(message, "flatten")) + $root.Trace.QueryPlanNode.FlattenNode.encode(message.flatten, writer.uint32(34).fork()).ldelim(); + return writer; + }; + QueryPlanNode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + QueryPlanNode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.QueryPlanNode(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.sequence = $root.Trace.QueryPlanNode.SequenceNode.decode(reader, reader.uint32()); + break; + case 2: + message.parallel = $root.Trace.QueryPlanNode.ParallelNode.decode(reader, reader.uint32()); + break; + case 3: + message.fetch = $root.Trace.QueryPlanNode.FetchNode.decode(reader, reader.uint32()); + break; + case 4: + message.flatten = $root.Trace.QueryPlanNode.FlattenNode.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + QueryPlanNode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + QueryPlanNode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + var properties = {}; + if (message.sequence != null && message.hasOwnProperty("sequence")) { + properties.node = 1; + { + var error = $root.Trace.QueryPlanNode.SequenceNode.verify(message.sequence); + if (error) + return "sequence." + error; + } + } + if (message.parallel != null && message.hasOwnProperty("parallel")) { + if (properties.node === 1) + return "node: multiple values"; + properties.node = 1; + { + var error = $root.Trace.QueryPlanNode.ParallelNode.verify(message.parallel); + if (error) + return "parallel." + error; + } + } + if (message.fetch != null && message.hasOwnProperty("fetch")) { + if (properties.node === 1) + return "node: multiple values"; + properties.node = 1; + { + var error = $root.Trace.QueryPlanNode.FetchNode.verify(message.fetch); + if (error) + return "fetch." + error; + } + } + if (message.flatten != null && message.hasOwnProperty("flatten")) { + if (properties.node === 1) + return "node: multiple values"; + properties.node = 1; + { + var error = $root.Trace.QueryPlanNode.FlattenNode.verify(message.flatten); + if (error) + return "flatten." + error; + } + } + return null; + }; + QueryPlanNode.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (message.sequence != null && message.hasOwnProperty("sequence")) { + object.sequence = $root.Trace.QueryPlanNode.SequenceNode.toObject(message.sequence, options); + if (options.oneofs) + object.node = "sequence"; + } + if (message.parallel != null && message.hasOwnProperty("parallel")) { + object.parallel = $root.Trace.QueryPlanNode.ParallelNode.toObject(message.parallel, options); + if (options.oneofs) + object.node = "parallel"; + } + if (message.fetch != null && message.hasOwnProperty("fetch")) { + object.fetch = $root.Trace.QueryPlanNode.FetchNode.toObject(message.fetch, options); + if (options.oneofs) + object.node = "fetch"; + } + if (message.flatten != null && message.hasOwnProperty("flatten")) { + object.flatten = $root.Trace.QueryPlanNode.FlattenNode.toObject(message.flatten, options); + if (options.oneofs) + object.node = "flatten"; + } + return object; + }; + QueryPlanNode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + QueryPlanNode.SequenceNode = function() { + function SequenceNode(properties) { + this.nodes = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + SequenceNode.prototype.nodes = $util.emptyArray; + SequenceNode.create = function create(properties) { + return new SequenceNode(properties); + }; + SequenceNode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.nodes != null && message.nodes.length) + for (var i = 0; i < message.nodes.length; ++i) + $root.Trace.QueryPlanNode.encode(message.nodes[i], writer.uint32(10).fork()).ldelim(); + return writer; + }; + SequenceNode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + SequenceNode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.QueryPlanNode.SequenceNode(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.nodes && message.nodes.length)) + message.nodes = []; + message.nodes.push($root.Trace.QueryPlanNode.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + SequenceNode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + SequenceNode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.nodes != null && message.hasOwnProperty("nodes")) { + if (!Array.isArray(message.nodes)) + return "nodes: array expected"; + for (var i = 0; i < message.nodes.length; ++i) { + var error = $root.Trace.QueryPlanNode.verify(message.nodes[i]); + if (error) + return "nodes." + error; + } + } + return null; + }; + SequenceNode.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.nodes = []; + if (message.nodes && message.nodes.length) { + object.nodes = []; + for (var j = 0; j < message.nodes.length; ++j) + object.nodes[j] = $root.Trace.QueryPlanNode.toObject(message.nodes[j], options); + } + return object; + }; + SequenceNode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return SequenceNode; + }(); + QueryPlanNode.ParallelNode = function() { + function ParallelNode(properties) { + this.nodes = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ParallelNode.prototype.nodes = $util.emptyArray; + ParallelNode.create = function create(properties) { + return new ParallelNode(properties); + }; + ParallelNode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.nodes != null && message.nodes.length) + for (var i = 0; i < message.nodes.length; ++i) + $root.Trace.QueryPlanNode.encode(message.nodes[i], writer.uint32(10).fork()).ldelim(); + return writer; + }; + ParallelNode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ParallelNode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.QueryPlanNode.ParallelNode(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.nodes && message.nodes.length)) + message.nodes = []; + message.nodes.push($root.Trace.QueryPlanNode.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ParallelNode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ParallelNode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.nodes != null && message.hasOwnProperty("nodes")) { + if (!Array.isArray(message.nodes)) + return "nodes: array expected"; + for (var i = 0; i < message.nodes.length; ++i) { + var error = $root.Trace.QueryPlanNode.verify(message.nodes[i]); + if (error) + return "nodes." + error; + } + } + return null; + }; + ParallelNode.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.nodes = []; + if (message.nodes && message.nodes.length) { + object.nodes = []; + for (var j = 0; j < message.nodes.length; ++j) + object.nodes[j] = $root.Trace.QueryPlanNode.toObject(message.nodes[j], options); + } + return object; + }; + ParallelNode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ParallelNode; + }(); + QueryPlanNode.FetchNode = function() { + function FetchNode(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + FetchNode.prototype.serviceName = ""; + FetchNode.prototype.traceParsingFailed = false; + FetchNode.prototype.trace = null; + FetchNode.prototype.sentTimeOffset = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + FetchNode.prototype.sentTime = null; + FetchNode.prototype.receivedTime = null; + FetchNode.create = function create(properties) { + return new FetchNode(properties); + }; + FetchNode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.serviceName != null && Object.hasOwnProperty.call(message, "serviceName")) + writer.uint32(10).string(message.serviceName); + if (message.traceParsingFailed != null && Object.hasOwnProperty.call(message, "traceParsingFailed")) + writer.uint32(16).bool(message.traceParsingFailed); + if (message.trace != null && Object.hasOwnProperty.call(message, "trace")) + $root.Trace.encode(message.trace, writer.uint32(26).fork()).ldelim(); + if (message.sentTimeOffset != null && Object.hasOwnProperty.call(message, "sentTimeOffset")) + writer.uint32(32).uint64(message.sentTimeOffset); + if (message.sentTime != null && Object.hasOwnProperty.call(message, "sentTime")) + $root.google.protobuf.Timestamp.encode(message.sentTime, writer.uint32(42).fork()).ldelim(); + if (message.receivedTime != null && Object.hasOwnProperty.call(message, "receivedTime")) + $root.google.protobuf.Timestamp.encode(message.receivedTime, writer.uint32(50).fork()).ldelim(); + return writer; + }; + FetchNode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + FetchNode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.QueryPlanNode.FetchNode(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.serviceName = reader.string(); + break; + case 2: + message.traceParsingFailed = reader.bool(); + break; + case 3: + message.trace = $root.Trace.decode(reader, reader.uint32()); + break; + case 4: + message.sentTimeOffset = reader.uint64(); + break; + case 5: + message.sentTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32()); + break; + case 6: + message.receivedTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + FetchNode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + FetchNode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.serviceName != null && message.hasOwnProperty("serviceName")) { + if (!$util.isString(message.serviceName)) + return "serviceName: string expected"; + } + if (message.traceParsingFailed != null && message.hasOwnProperty("traceParsingFailed")) { + if (typeof message.traceParsingFailed !== "boolean") + return "traceParsingFailed: boolean expected"; + } + if (message.trace != null && message.hasOwnProperty("trace")) { + var error = $root.Trace.verify(message.trace); + if (error) + return "trace." + error; + } + if (message.sentTimeOffset != null && message.hasOwnProperty("sentTimeOffset")) { + if (!$util.isInteger(message.sentTimeOffset) && !(message.sentTimeOffset && $util.isInteger(message.sentTimeOffset.low) && $util.isInteger(message.sentTimeOffset.high))) + return "sentTimeOffset: integer|Long expected"; + } + if (message.sentTime != null && message.hasOwnProperty("sentTime")) { + var error = $root.google.protobuf.Timestamp.verify(message.sentTime); + if (error) + return "sentTime." + error; + } + if (message.receivedTime != null && message.hasOwnProperty("receivedTime")) { + var error = $root.google.protobuf.Timestamp.verify(message.receivedTime); + if (error) + return "receivedTime." + error; + } + return null; + }; + FetchNode.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.serviceName = ""; + object.traceParsingFailed = false; + object.trace = null; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.sentTimeOffset = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.sentTimeOffset = options.longs === String ? "0" : 0; + object.sentTime = null; + object.receivedTime = null; + } + if (message.serviceName != null && message.hasOwnProperty("serviceName")) + object.serviceName = message.serviceName; + if (message.traceParsingFailed != null && message.hasOwnProperty("traceParsingFailed")) + object.traceParsingFailed = message.traceParsingFailed; + if (message.trace != null && message.hasOwnProperty("trace")) + object.trace = $root.Trace.toObject(message.trace, options); + if (message.sentTimeOffset != null && message.hasOwnProperty("sentTimeOffset")) + if (typeof message.sentTimeOffset === "number") + object.sentTimeOffset = options.longs === String ? String(message.sentTimeOffset) : message.sentTimeOffset; + else + object.sentTimeOffset = options.longs === String ? $util.Long.prototype.toString.call(message.sentTimeOffset) : options.longs === Number ? new $util.LongBits(message.sentTimeOffset.low >>> 0, message.sentTimeOffset.high >>> 0).toNumber(true) : message.sentTimeOffset; + if (message.sentTime != null && message.hasOwnProperty("sentTime")) + object.sentTime = $root.google.protobuf.Timestamp.toObject(message.sentTime, options); + if (message.receivedTime != null && message.hasOwnProperty("receivedTime")) + object.receivedTime = $root.google.protobuf.Timestamp.toObject(message.receivedTime, options); + return object; + }; + FetchNode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return FetchNode; + }(); + QueryPlanNode.FlattenNode = function() { + function FlattenNode(properties) { + this.responsePath = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + FlattenNode.prototype.responsePath = $util.emptyArray; + FlattenNode.prototype.node = null; + FlattenNode.create = function create(properties) { + return new FlattenNode(properties); + }; + FlattenNode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.responsePath != null && message.responsePath.length) + for (var i = 0; i < message.responsePath.length; ++i) + $root.Trace.QueryPlanNode.ResponsePathElement.encode(message.responsePath[i], writer.uint32(10).fork()).ldelim(); + if (message.node != null && Object.hasOwnProperty.call(message, "node")) + $root.Trace.QueryPlanNode.encode(message.node, writer.uint32(18).fork()).ldelim(); + return writer; + }; + FlattenNode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + FlattenNode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.QueryPlanNode.FlattenNode(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.responsePath && message.responsePath.length)) + message.responsePath = []; + message.responsePath.push($root.Trace.QueryPlanNode.ResponsePathElement.decode(reader, reader.uint32())); + break; + case 2: + message.node = $root.Trace.QueryPlanNode.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + FlattenNode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + FlattenNode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.responsePath != null && message.hasOwnProperty("responsePath")) { + if (!Array.isArray(message.responsePath)) + return "responsePath: array expected"; + for (var i = 0; i < message.responsePath.length; ++i) { + var error = $root.Trace.QueryPlanNode.ResponsePathElement.verify(message.responsePath[i]); + if (error) + return "responsePath." + error; + } + } + if (message.node != null && message.hasOwnProperty("node")) { + var error = $root.Trace.QueryPlanNode.verify(message.node); + if (error) + return "node." + error; + } + return null; + }; + FlattenNode.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.responsePath = []; + if (options.defaults) + object.node = null; + if (message.responsePath && message.responsePath.length) { + object.responsePath = []; + for (var j = 0; j < message.responsePath.length; ++j) + object.responsePath[j] = $root.Trace.QueryPlanNode.ResponsePathElement.toObject(message.responsePath[j], options); + } + if (message.node != null && message.hasOwnProperty("node")) + object.node = $root.Trace.QueryPlanNode.toObject(message.node, options); + return object; + }; + FlattenNode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return FlattenNode; + }(); + QueryPlanNode.ResponsePathElement = function() { + function ResponsePathElement(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ResponsePathElement.prototype.fieldName = ""; + ResponsePathElement.prototype.index = 0; + var $oneOfFields2; + Object.defineProperty(ResponsePathElement.prototype, "id", { + get: $util.oneOfGetter($oneOfFields2 = ["fieldName", "index"]), + set: $util.oneOfSetter($oneOfFields2) + }); + ResponsePathElement.create = function create(properties) { + return new ResponsePathElement(properties); + }; + ResponsePathElement.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.fieldName != null && Object.hasOwnProperty.call(message, "fieldName")) + writer.uint32(10).string(message.fieldName); + if (message.index != null && Object.hasOwnProperty.call(message, "index")) + writer.uint32(16).uint32(message.index); + return writer; + }; + ResponsePathElement.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ResponsePathElement.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Trace.QueryPlanNode.ResponsePathElement(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.fieldName = reader.string(); + break; + case 2: + message.index = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ResponsePathElement.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ResponsePathElement.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + var properties = {}; + if (message.fieldName != null && message.hasOwnProperty("fieldName")) { + properties.id = 1; + if (!$util.isString(message.fieldName)) + return "fieldName: string expected"; + } + if (message.index != null && message.hasOwnProperty("index")) { + if (properties.id === 1) + return "id: multiple values"; + properties.id = 1; + if (!$util.isInteger(message.index)) + return "index: integer expected"; + } + return null; + }; + ResponsePathElement.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (message.fieldName != null && message.hasOwnProperty("fieldName")) { + object.fieldName = message.fieldName; + if (options.oneofs) + object.id = "fieldName"; + } + if (message.index != null && message.hasOwnProperty("index")) { + object.index = message.index; + if (options.oneofs) + object.id = "index"; + } + return object; + }; + ResponsePathElement.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ResponsePathElement; + }(); + return QueryPlanNode; + }(); + return Trace; + }(); + $root.ReportHeader = function() { + function ReportHeader(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ReportHeader.prototype.graphRef = ""; + ReportHeader.prototype.hostname = ""; + ReportHeader.prototype.agentVersion = ""; + ReportHeader.prototype.serviceVersion = ""; + ReportHeader.prototype.runtimeVersion = ""; + ReportHeader.prototype.uname = ""; + ReportHeader.prototype.executableSchemaId = ""; + ReportHeader.create = function create(properties) { + return new ReportHeader(properties); + }; + ReportHeader.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.hostname != null && Object.hasOwnProperty.call(message, "hostname")) + writer.uint32(42).string(message.hostname); + if (message.agentVersion != null && Object.hasOwnProperty.call(message, "agentVersion")) + writer.uint32(50).string(message.agentVersion); + if (message.serviceVersion != null && Object.hasOwnProperty.call(message, "serviceVersion")) + writer.uint32(58).string(message.serviceVersion); + if (message.runtimeVersion != null && Object.hasOwnProperty.call(message, "runtimeVersion")) + writer.uint32(66).string(message.runtimeVersion); + if (message.uname != null && Object.hasOwnProperty.call(message, "uname")) + writer.uint32(74).string(message.uname); + if (message.executableSchemaId != null && Object.hasOwnProperty.call(message, "executableSchemaId")) + writer.uint32(90).string(message.executableSchemaId); + if (message.graphRef != null && Object.hasOwnProperty.call(message, "graphRef")) + writer.uint32(98).string(message.graphRef); + return writer; + }; + ReportHeader.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ReportHeader.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ReportHeader(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 12: + message.graphRef = reader.string(); + break; + case 5: + message.hostname = reader.string(); + break; + case 6: + message.agentVersion = reader.string(); + break; + case 7: + message.serviceVersion = reader.string(); + break; + case 8: + message.runtimeVersion = reader.string(); + break; + case 9: + message.uname = reader.string(); + break; + case 11: + message.executableSchemaId = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ReportHeader.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ReportHeader.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.graphRef != null && message.hasOwnProperty("graphRef")) { + if (!$util.isString(message.graphRef)) + return "graphRef: string expected"; + } + if (message.hostname != null && message.hasOwnProperty("hostname")) { + if (!$util.isString(message.hostname)) + return "hostname: string expected"; + } + if (message.agentVersion != null && message.hasOwnProperty("agentVersion")) { + if (!$util.isString(message.agentVersion)) + return "agentVersion: string expected"; + } + if (message.serviceVersion != null && message.hasOwnProperty("serviceVersion")) { + if (!$util.isString(message.serviceVersion)) + return "serviceVersion: string expected"; + } + if (message.runtimeVersion != null && message.hasOwnProperty("runtimeVersion")) { + if (!$util.isString(message.runtimeVersion)) + return "runtimeVersion: string expected"; + } + if (message.uname != null && message.hasOwnProperty("uname")) { + if (!$util.isString(message.uname)) + return "uname: string expected"; + } + if (message.executableSchemaId != null && message.hasOwnProperty("executableSchemaId")) { + if (!$util.isString(message.executableSchemaId)) + return "executableSchemaId: string expected"; + } + return null; + }; + ReportHeader.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.hostname = ""; + object.agentVersion = ""; + object.serviceVersion = ""; + object.runtimeVersion = ""; + object.uname = ""; + object.executableSchemaId = ""; + object.graphRef = ""; + } + if (message.hostname != null && message.hasOwnProperty("hostname")) + object.hostname = message.hostname; + if (message.agentVersion != null && message.hasOwnProperty("agentVersion")) + object.agentVersion = message.agentVersion; + if (message.serviceVersion != null && message.hasOwnProperty("serviceVersion")) + object.serviceVersion = message.serviceVersion; + if (message.runtimeVersion != null && message.hasOwnProperty("runtimeVersion")) + object.runtimeVersion = message.runtimeVersion; + if (message.uname != null && message.hasOwnProperty("uname")) + object.uname = message.uname; + if (message.executableSchemaId != null && message.hasOwnProperty("executableSchemaId")) + object.executableSchemaId = message.executableSchemaId; + if (message.graphRef != null && message.hasOwnProperty("graphRef")) + object.graphRef = message.graphRef; + return object; + }; + ReportHeader.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ReportHeader; + }(); + $root.PathErrorStats = function() { + function PathErrorStats(properties) { + this.children = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + PathErrorStats.prototype.children = $util.emptyObject; + PathErrorStats.prototype.errorsCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + PathErrorStats.prototype.requestsWithErrorsCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + PathErrorStats.create = function create(properties) { + return new PathErrorStats(properties); + }; + PathErrorStats.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.children != null && Object.hasOwnProperty.call(message, "children")) + for (var keys = Object.keys(message.children), i = 0; i < keys.length; ++i) { + writer.uint32(10).fork().uint32(10).string(keys[i]); + $root.PathErrorStats.encode(message.children[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + if (message.errorsCount != null && Object.hasOwnProperty.call(message, "errorsCount")) + writer.uint32(32).uint64(message.errorsCount); + if (message.requestsWithErrorsCount != null && Object.hasOwnProperty.call(message, "requestsWithErrorsCount")) + writer.uint32(40).uint64(message.requestsWithErrorsCount); + return writer; + }; + PathErrorStats.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + PathErrorStats.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.PathErrorStats(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + reader.skip().pos++; + if (message.children === $util.emptyObject) + message.children = {}; + key = reader.string(); + reader.pos++; + message.children[key] = $root.PathErrorStats.decode(reader, reader.uint32()); + break; + case 4: + message.errorsCount = reader.uint64(); + break; + case 5: + message.requestsWithErrorsCount = reader.uint64(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + PathErrorStats.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + PathErrorStats.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.children != null && message.hasOwnProperty("children")) { + if (!$util.isObject(message.children)) + return "children: object expected"; + var key = Object.keys(message.children); + for (var i = 0; i < key.length; ++i) { + var error = $root.PathErrorStats.verify(message.children[key[i]]); + if (error) + return "children." + error; + } + } + if (message.errorsCount != null && message.hasOwnProperty("errorsCount")) { + if (!$util.isInteger(message.errorsCount) && !(message.errorsCount && $util.isInteger(message.errorsCount.low) && $util.isInteger(message.errorsCount.high))) + return "errorsCount: integer|Long expected"; + } + if (message.requestsWithErrorsCount != null && message.hasOwnProperty("requestsWithErrorsCount")) { + if (!$util.isInteger(message.requestsWithErrorsCount) && !(message.requestsWithErrorsCount && $util.isInteger(message.requestsWithErrorsCount.low) && $util.isInteger(message.requestsWithErrorsCount.high))) + return "requestsWithErrorsCount: integer|Long expected"; + } + return null; + }; + PathErrorStats.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) + object.children = {}; + if (options.defaults) { + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.errorsCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.errorsCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.requestsWithErrorsCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.requestsWithErrorsCount = options.longs === String ? "0" : 0; + } + var keys2; + if (message.children && (keys2 = Object.keys(message.children)).length) { + object.children = {}; + for (var j = 0; j < keys2.length; ++j) + object.children[keys2[j]] = $root.PathErrorStats.toObject(message.children[keys2[j]], options); + } + if (message.errorsCount != null && message.hasOwnProperty("errorsCount")) + if (typeof message.errorsCount === "number") + object.errorsCount = options.longs === String ? String(message.errorsCount) : message.errorsCount; + else + object.errorsCount = options.longs === String ? $util.Long.prototype.toString.call(message.errorsCount) : options.longs === Number ? new $util.LongBits(message.errorsCount.low >>> 0, message.errorsCount.high >>> 0).toNumber(true) : message.errorsCount; + if (message.requestsWithErrorsCount != null && message.hasOwnProperty("requestsWithErrorsCount")) + if (typeof message.requestsWithErrorsCount === "number") + object.requestsWithErrorsCount = options.longs === String ? String(message.requestsWithErrorsCount) : message.requestsWithErrorsCount; + else + object.requestsWithErrorsCount = options.longs === String ? $util.Long.prototype.toString.call(message.requestsWithErrorsCount) : options.longs === Number ? new $util.LongBits(message.requestsWithErrorsCount.low >>> 0, message.requestsWithErrorsCount.high >>> 0).toNumber(true) : message.requestsWithErrorsCount; + return object; + }; + PathErrorStats.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return PathErrorStats; + }(); + $root.QueryLatencyStats = function() { + function QueryLatencyStats(properties) { + this.latencyCount = []; + this.cacheLatencyCount = []; + this.publicCacheTtlCount = []; + this.privateCacheTtlCount = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + QueryLatencyStats.prototype.latencyCount = $util.emptyArray; + QueryLatencyStats.prototype.requestCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.cacheHits = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.persistedQueryHits = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.persistedQueryMisses = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.cacheLatencyCount = $util.emptyArray; + QueryLatencyStats.prototype.rootErrorStats = null; + QueryLatencyStats.prototype.requestsWithErrorsCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.publicCacheTtlCount = $util.emptyArray; + QueryLatencyStats.prototype.privateCacheTtlCount = $util.emptyArray; + QueryLatencyStats.prototype.registeredOperationCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.forbiddenOperationCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.prototype.requestsWithoutFieldInstrumentation = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryLatencyStats.create = function create(properties) { + return new QueryLatencyStats(properties); + }; + QueryLatencyStats.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.requestCount != null && Object.hasOwnProperty.call(message, "requestCount")) + writer.uint32(16).uint64(message.requestCount); + if (message.cacheHits != null && Object.hasOwnProperty.call(message, "cacheHits")) + writer.uint32(24).uint64(message.cacheHits); + if (message.persistedQueryHits != null && Object.hasOwnProperty.call(message, "persistedQueryHits")) + writer.uint32(32).uint64(message.persistedQueryHits); + if (message.persistedQueryMisses != null && Object.hasOwnProperty.call(message, "persistedQueryMisses")) + writer.uint32(40).uint64(message.persistedQueryMisses); + if (message.rootErrorStats != null && Object.hasOwnProperty.call(message, "rootErrorStats")) + $root.PathErrorStats.encode(message.rootErrorStats, writer.uint32(58).fork()).ldelim(); + if (message.requestsWithErrorsCount != null && Object.hasOwnProperty.call(message, "requestsWithErrorsCount")) + writer.uint32(64).uint64(message.requestsWithErrorsCount); + if (message.registeredOperationCount != null && Object.hasOwnProperty.call(message, "registeredOperationCount")) + writer.uint32(88).uint64(message.registeredOperationCount); + if (message.forbiddenOperationCount != null && Object.hasOwnProperty.call(message, "forbiddenOperationCount")) + writer.uint32(96).uint64(message.forbiddenOperationCount); + var array13; + if (message.latencyCount != null && message.latencyCount.toArray) + array13 = message.latencyCount.toArray(); + else + array13 = message.latencyCount; + if (array13 != null && array13.length) { + writer.uint32(106).fork(); + for (var i = 0; i < array13.length; ++i) + writer.sint64(array13[i]); + writer.ldelim(); + } + var array14; + if (message.cacheLatencyCount != null && message.cacheLatencyCount.toArray) + array14 = message.cacheLatencyCount.toArray(); + else + array14 = message.cacheLatencyCount; + if (array14 != null && array14.length) { + writer.uint32(114).fork(); + for (var i = 0; i < array14.length; ++i) + writer.sint64(array14[i]); + writer.ldelim(); + } + var array15; + if (message.publicCacheTtlCount != null && message.publicCacheTtlCount.toArray) + array15 = message.publicCacheTtlCount.toArray(); + else + array15 = message.publicCacheTtlCount; + if (array15 != null && array15.length) { + writer.uint32(122).fork(); + for (var i = 0; i < array15.length; ++i) + writer.sint64(array15[i]); + writer.ldelim(); + } + var array16; + if (message.privateCacheTtlCount != null && message.privateCacheTtlCount.toArray) + array16 = message.privateCacheTtlCount.toArray(); + else + array16 = message.privateCacheTtlCount; + if (array16 != null && array16.length) { + writer.uint32(130).fork(); + for (var i = 0; i < array16.length; ++i) + writer.sint64(array16[i]); + writer.ldelim(); + } + if (message.requestsWithoutFieldInstrumentation != null && Object.hasOwnProperty.call(message, "requestsWithoutFieldInstrumentation")) + writer.uint32(136).uint64(message.requestsWithoutFieldInstrumentation); + return writer; + }; + QueryLatencyStats.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + QueryLatencyStats.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.QueryLatencyStats(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 13: + if (!(message.latencyCount && message.latencyCount.length)) + message.latencyCount = []; + if ((tag & 7) === 2) { + var end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.latencyCount.push(reader.sint64()); + } else + message.latencyCount.push(reader.sint64()); + break; + case 2: + message.requestCount = reader.uint64(); + break; + case 3: + message.cacheHits = reader.uint64(); + break; + case 4: + message.persistedQueryHits = reader.uint64(); + break; + case 5: + message.persistedQueryMisses = reader.uint64(); + break; + case 14: + if (!(message.cacheLatencyCount && message.cacheLatencyCount.length)) + message.cacheLatencyCount = []; + if ((tag & 7) === 2) { + var end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.cacheLatencyCount.push(reader.sint64()); + } else + message.cacheLatencyCount.push(reader.sint64()); + break; + case 7: + message.rootErrorStats = $root.PathErrorStats.decode(reader, reader.uint32()); + break; + case 8: + message.requestsWithErrorsCount = reader.uint64(); + break; + case 15: + if (!(message.publicCacheTtlCount && message.publicCacheTtlCount.length)) + message.publicCacheTtlCount = []; + if ((tag & 7) === 2) { + var end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.publicCacheTtlCount.push(reader.sint64()); + } else + message.publicCacheTtlCount.push(reader.sint64()); + break; + case 16: + if (!(message.privateCacheTtlCount && message.privateCacheTtlCount.length)) + message.privateCacheTtlCount = []; + if ((tag & 7) === 2) { + var end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.privateCacheTtlCount.push(reader.sint64()); + } else + message.privateCacheTtlCount.push(reader.sint64()); + break; + case 11: + message.registeredOperationCount = reader.uint64(); + break; + case 12: + message.forbiddenOperationCount = reader.uint64(); + break; + case 17: + message.requestsWithoutFieldInstrumentation = reader.uint64(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + QueryLatencyStats.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + QueryLatencyStats.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.latencyCount != null && message.hasOwnProperty("latencyCount")) { + var array13; + if (message.latencyCount != null && message.latencyCount.toArray) + array13 = message.latencyCount.toArray(); + else + array13 = message.latencyCount; + if (!Array.isArray(array13)) + return "latencyCount: array expected"; + for (var i = 0; i < array13.length; ++i) + if (!$util.isInteger(array13[i]) && !(array13[i] && $util.isInteger(array13[i].low) && $util.isInteger(array13[i].high))) + return "latencyCount: integer|Long[] expected"; + } + if (message.requestCount != null && message.hasOwnProperty("requestCount")) { + if (!$util.isInteger(message.requestCount) && !(message.requestCount && $util.isInteger(message.requestCount.low) && $util.isInteger(message.requestCount.high))) + return "requestCount: integer|Long expected"; + } + if (message.cacheHits != null && message.hasOwnProperty("cacheHits")) { + if (!$util.isInteger(message.cacheHits) && !(message.cacheHits && $util.isInteger(message.cacheHits.low) && $util.isInteger(message.cacheHits.high))) + return "cacheHits: integer|Long expected"; + } + if (message.persistedQueryHits != null && message.hasOwnProperty("persistedQueryHits")) { + if (!$util.isInteger(message.persistedQueryHits) && !(message.persistedQueryHits && $util.isInteger(message.persistedQueryHits.low) && $util.isInteger(message.persistedQueryHits.high))) + return "persistedQueryHits: integer|Long expected"; + } + if (message.persistedQueryMisses != null && message.hasOwnProperty("persistedQueryMisses")) { + if (!$util.isInteger(message.persistedQueryMisses) && !(message.persistedQueryMisses && $util.isInteger(message.persistedQueryMisses.low) && $util.isInteger(message.persistedQueryMisses.high))) + return "persistedQueryMisses: integer|Long expected"; + } + if (message.cacheLatencyCount != null && message.hasOwnProperty("cacheLatencyCount")) { + var array14; + if (message.cacheLatencyCount != null && message.cacheLatencyCount.toArray) + array14 = message.cacheLatencyCount.toArray(); + else + array14 = message.cacheLatencyCount; + if (!Array.isArray(array14)) + return "cacheLatencyCount: array expected"; + for (var i = 0; i < array14.length; ++i) + if (!$util.isInteger(array14[i]) && !(array14[i] && $util.isInteger(array14[i].low) && $util.isInteger(array14[i].high))) + return "cacheLatencyCount: integer|Long[] expected"; + } + if (message.rootErrorStats != null && message.hasOwnProperty("rootErrorStats")) { + var error = $root.PathErrorStats.verify(message.rootErrorStats); + if (error) + return "rootErrorStats." + error; + } + if (message.requestsWithErrorsCount != null && message.hasOwnProperty("requestsWithErrorsCount")) { + if (!$util.isInteger(message.requestsWithErrorsCount) && !(message.requestsWithErrorsCount && $util.isInteger(message.requestsWithErrorsCount.low) && $util.isInteger(message.requestsWithErrorsCount.high))) + return "requestsWithErrorsCount: integer|Long expected"; + } + if (message.publicCacheTtlCount != null && message.hasOwnProperty("publicCacheTtlCount")) { + var array15; + if (message.publicCacheTtlCount != null && message.publicCacheTtlCount.toArray) + array15 = message.publicCacheTtlCount.toArray(); + else + array15 = message.publicCacheTtlCount; + if (!Array.isArray(array15)) + return "publicCacheTtlCount: array expected"; + for (var i = 0; i < array15.length; ++i) + if (!$util.isInteger(array15[i]) && !(array15[i] && $util.isInteger(array15[i].low) && $util.isInteger(array15[i].high))) + return "publicCacheTtlCount: integer|Long[] expected"; + } + if (message.privateCacheTtlCount != null && message.hasOwnProperty("privateCacheTtlCount")) { + var array16; + if (message.privateCacheTtlCount != null && message.privateCacheTtlCount.toArray) + array16 = message.privateCacheTtlCount.toArray(); + else + array16 = message.privateCacheTtlCount; + if (!Array.isArray(array16)) + return "privateCacheTtlCount: array expected"; + for (var i = 0; i < array16.length; ++i) + if (!$util.isInteger(array16[i]) && !(array16[i] && $util.isInteger(array16[i].low) && $util.isInteger(array16[i].high))) + return "privateCacheTtlCount: integer|Long[] expected"; + } + if (message.registeredOperationCount != null && message.hasOwnProperty("registeredOperationCount")) { + if (!$util.isInteger(message.registeredOperationCount) && !(message.registeredOperationCount && $util.isInteger(message.registeredOperationCount.low) && $util.isInteger(message.registeredOperationCount.high))) + return "registeredOperationCount: integer|Long expected"; + } + if (message.forbiddenOperationCount != null && message.hasOwnProperty("forbiddenOperationCount")) { + if (!$util.isInteger(message.forbiddenOperationCount) && !(message.forbiddenOperationCount && $util.isInteger(message.forbiddenOperationCount.low) && $util.isInteger(message.forbiddenOperationCount.high))) + return "forbiddenOperationCount: integer|Long expected"; + } + if (message.requestsWithoutFieldInstrumentation != null && message.hasOwnProperty("requestsWithoutFieldInstrumentation")) { + if (!$util.isInteger(message.requestsWithoutFieldInstrumentation) && !(message.requestsWithoutFieldInstrumentation && $util.isInteger(message.requestsWithoutFieldInstrumentation.low) && $util.isInteger(message.requestsWithoutFieldInstrumentation.high))) + return "requestsWithoutFieldInstrumentation: integer|Long expected"; + } + return null; + }; + QueryLatencyStats.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) { + object.latencyCount = []; + object.cacheLatencyCount = []; + object.publicCacheTtlCount = []; + object.privateCacheTtlCount = []; + } + if (options.defaults) { + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.requestCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.requestCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.cacheHits = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.cacheHits = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.persistedQueryHits = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.persistedQueryHits = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.persistedQueryMisses = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.persistedQueryMisses = options.longs === String ? "0" : 0; + object.rootErrorStats = null; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.requestsWithErrorsCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.requestsWithErrorsCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.registeredOperationCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.registeredOperationCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.forbiddenOperationCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.forbiddenOperationCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.requestsWithoutFieldInstrumentation = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.requestsWithoutFieldInstrumentation = options.longs === String ? "0" : 0; + } + if (message.requestCount != null && message.hasOwnProperty("requestCount")) + if (typeof message.requestCount === "number") + object.requestCount = options.longs === String ? String(message.requestCount) : message.requestCount; + else + object.requestCount = options.longs === String ? $util.Long.prototype.toString.call(message.requestCount) : options.longs === Number ? new $util.LongBits(message.requestCount.low >>> 0, message.requestCount.high >>> 0).toNumber(true) : message.requestCount; + if (message.cacheHits != null && message.hasOwnProperty("cacheHits")) + if (typeof message.cacheHits === "number") + object.cacheHits = options.longs === String ? String(message.cacheHits) : message.cacheHits; + else + object.cacheHits = options.longs === String ? $util.Long.prototype.toString.call(message.cacheHits) : options.longs === Number ? new $util.LongBits(message.cacheHits.low >>> 0, message.cacheHits.high >>> 0).toNumber(true) : message.cacheHits; + if (message.persistedQueryHits != null && message.hasOwnProperty("persistedQueryHits")) + if (typeof message.persistedQueryHits === "number") + object.persistedQueryHits = options.longs === String ? String(message.persistedQueryHits) : message.persistedQueryHits; + else + object.persistedQueryHits = options.longs === String ? $util.Long.prototype.toString.call(message.persistedQueryHits) : options.longs === Number ? new $util.LongBits(message.persistedQueryHits.low >>> 0, message.persistedQueryHits.high >>> 0).toNumber(true) : message.persistedQueryHits; + if (message.persistedQueryMisses != null && message.hasOwnProperty("persistedQueryMisses")) + if (typeof message.persistedQueryMisses === "number") + object.persistedQueryMisses = options.longs === String ? String(message.persistedQueryMisses) : message.persistedQueryMisses; + else + object.persistedQueryMisses = options.longs === String ? $util.Long.prototype.toString.call(message.persistedQueryMisses) : options.longs === Number ? new $util.LongBits(message.persistedQueryMisses.low >>> 0, message.persistedQueryMisses.high >>> 0).toNumber(true) : message.persistedQueryMisses; + if (message.rootErrorStats != null && message.hasOwnProperty("rootErrorStats")) + object.rootErrorStats = $root.PathErrorStats.toObject(message.rootErrorStats, options); + if (message.requestsWithErrorsCount != null && message.hasOwnProperty("requestsWithErrorsCount")) + if (typeof message.requestsWithErrorsCount === "number") + object.requestsWithErrorsCount = options.longs === String ? String(message.requestsWithErrorsCount) : message.requestsWithErrorsCount; + else + object.requestsWithErrorsCount = options.longs === String ? $util.Long.prototype.toString.call(message.requestsWithErrorsCount) : options.longs === Number ? new $util.LongBits(message.requestsWithErrorsCount.low >>> 0, message.requestsWithErrorsCount.high >>> 0).toNumber(true) : message.requestsWithErrorsCount; + if (message.registeredOperationCount != null && message.hasOwnProperty("registeredOperationCount")) + if (typeof message.registeredOperationCount === "number") + object.registeredOperationCount = options.longs === String ? String(message.registeredOperationCount) : message.registeredOperationCount; + else + object.registeredOperationCount = options.longs === String ? $util.Long.prototype.toString.call(message.registeredOperationCount) : options.longs === Number ? new $util.LongBits(message.registeredOperationCount.low >>> 0, message.registeredOperationCount.high >>> 0).toNumber(true) : message.registeredOperationCount; + if (message.forbiddenOperationCount != null && message.hasOwnProperty("forbiddenOperationCount")) + if (typeof message.forbiddenOperationCount === "number") + object.forbiddenOperationCount = options.longs === String ? String(message.forbiddenOperationCount) : message.forbiddenOperationCount; + else + object.forbiddenOperationCount = options.longs === String ? $util.Long.prototype.toString.call(message.forbiddenOperationCount) : options.longs === Number ? new $util.LongBits(message.forbiddenOperationCount.low >>> 0, message.forbiddenOperationCount.high >>> 0).toNumber(true) : message.forbiddenOperationCount; + if (message.latencyCount && message.latencyCount.length) { + object.latencyCount = []; + for (var j = 0; j < message.latencyCount.length; ++j) + if (typeof message.latencyCount[j] === "number") + object.latencyCount[j] = options.longs === String ? String(message.latencyCount[j]) : message.latencyCount[j]; + else + object.latencyCount[j] = options.longs === String ? $util.Long.prototype.toString.call(message.latencyCount[j]) : options.longs === Number ? new $util.LongBits(message.latencyCount[j].low >>> 0, message.latencyCount[j].high >>> 0).toNumber() : message.latencyCount[j]; + } + if (message.cacheLatencyCount && message.cacheLatencyCount.length) { + object.cacheLatencyCount = []; + for (var j = 0; j < message.cacheLatencyCount.length; ++j) + if (typeof message.cacheLatencyCount[j] === "number") + object.cacheLatencyCount[j] = options.longs === String ? String(message.cacheLatencyCount[j]) : message.cacheLatencyCount[j]; + else + object.cacheLatencyCount[j] = options.longs === String ? $util.Long.prototype.toString.call(message.cacheLatencyCount[j]) : options.longs === Number ? new $util.LongBits(message.cacheLatencyCount[j].low >>> 0, message.cacheLatencyCount[j].high >>> 0).toNumber() : message.cacheLatencyCount[j]; + } + if (message.publicCacheTtlCount && message.publicCacheTtlCount.length) { + object.publicCacheTtlCount = []; + for (var j = 0; j < message.publicCacheTtlCount.length; ++j) + if (typeof message.publicCacheTtlCount[j] === "number") + object.publicCacheTtlCount[j] = options.longs === String ? String(message.publicCacheTtlCount[j]) : message.publicCacheTtlCount[j]; + else + object.publicCacheTtlCount[j] = options.longs === String ? $util.Long.prototype.toString.call(message.publicCacheTtlCount[j]) : options.longs === Number ? new $util.LongBits(message.publicCacheTtlCount[j].low >>> 0, message.publicCacheTtlCount[j].high >>> 0).toNumber() : message.publicCacheTtlCount[j]; + } + if (message.privateCacheTtlCount && message.privateCacheTtlCount.length) { + object.privateCacheTtlCount = []; + for (var j = 0; j < message.privateCacheTtlCount.length; ++j) + if (typeof message.privateCacheTtlCount[j] === "number") + object.privateCacheTtlCount[j] = options.longs === String ? String(message.privateCacheTtlCount[j]) : message.privateCacheTtlCount[j]; + else + object.privateCacheTtlCount[j] = options.longs === String ? $util.Long.prototype.toString.call(message.privateCacheTtlCount[j]) : options.longs === Number ? new $util.LongBits(message.privateCacheTtlCount[j].low >>> 0, message.privateCacheTtlCount[j].high >>> 0).toNumber() : message.privateCacheTtlCount[j]; + } + if (message.requestsWithoutFieldInstrumentation != null && message.hasOwnProperty("requestsWithoutFieldInstrumentation")) + if (typeof message.requestsWithoutFieldInstrumentation === "number") + object.requestsWithoutFieldInstrumentation = options.longs === String ? String(message.requestsWithoutFieldInstrumentation) : message.requestsWithoutFieldInstrumentation; + else + object.requestsWithoutFieldInstrumentation = options.longs === String ? $util.Long.prototype.toString.call(message.requestsWithoutFieldInstrumentation) : options.longs === Number ? new $util.LongBits(message.requestsWithoutFieldInstrumentation.low >>> 0, message.requestsWithoutFieldInstrumentation.high >>> 0).toNumber(true) : message.requestsWithoutFieldInstrumentation; + return object; + }; + QueryLatencyStats.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return QueryLatencyStats; + }(); + $root.StatsContext = function() { + function StatsContext(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + StatsContext.prototype.clientName = ""; + StatsContext.prototype.clientVersion = ""; + StatsContext.create = function create(properties) { + return new StatsContext(properties); + }; + StatsContext.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.clientName != null && Object.hasOwnProperty.call(message, "clientName")) + writer.uint32(18).string(message.clientName); + if (message.clientVersion != null && Object.hasOwnProperty.call(message, "clientVersion")) + writer.uint32(26).string(message.clientVersion); + return writer; + }; + StatsContext.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + StatsContext.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.StatsContext(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 2: + message.clientName = reader.string(); + break; + case 3: + message.clientVersion = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + StatsContext.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + StatsContext.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.clientName != null && message.hasOwnProperty("clientName")) { + if (!$util.isString(message.clientName)) + return "clientName: string expected"; + } + if (message.clientVersion != null && message.hasOwnProperty("clientVersion")) { + if (!$util.isString(message.clientVersion)) + return "clientVersion: string expected"; + } + return null; + }; + StatsContext.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.clientName = ""; + object.clientVersion = ""; + } + if (message.clientName != null && message.hasOwnProperty("clientName")) + object.clientName = message.clientName; + if (message.clientVersion != null && message.hasOwnProperty("clientVersion")) + object.clientVersion = message.clientVersion; + return object; + }; + StatsContext.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return StatsContext; + }(); + $root.ContextualizedQueryLatencyStats = function() { + function ContextualizedQueryLatencyStats(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ContextualizedQueryLatencyStats.prototype.queryLatencyStats = null; + ContextualizedQueryLatencyStats.prototype.context = null; + ContextualizedQueryLatencyStats.create = function create(properties) { + return new ContextualizedQueryLatencyStats(properties); + }; + ContextualizedQueryLatencyStats.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.queryLatencyStats != null && Object.hasOwnProperty.call(message, "queryLatencyStats")) + $root.QueryLatencyStats.encode(message.queryLatencyStats, writer.uint32(10).fork()).ldelim(); + if (message.context != null && Object.hasOwnProperty.call(message, "context")) + $root.StatsContext.encode(message.context, writer.uint32(18).fork()).ldelim(); + return writer; + }; + ContextualizedQueryLatencyStats.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ContextualizedQueryLatencyStats.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ContextualizedQueryLatencyStats(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.queryLatencyStats = $root.QueryLatencyStats.decode(reader, reader.uint32()); + break; + case 2: + message.context = $root.StatsContext.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ContextualizedQueryLatencyStats.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ContextualizedQueryLatencyStats.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.queryLatencyStats != null && message.hasOwnProperty("queryLatencyStats")) { + var error = $root.QueryLatencyStats.verify(message.queryLatencyStats); + if (error) + return "queryLatencyStats." + error; + } + if (message.context != null && message.hasOwnProperty("context")) { + var error = $root.StatsContext.verify(message.context); + if (error) + return "context." + error; + } + return null; + }; + ContextualizedQueryLatencyStats.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.queryLatencyStats = null; + object.context = null; + } + if (message.queryLatencyStats != null && message.hasOwnProperty("queryLatencyStats")) + object.queryLatencyStats = $root.QueryLatencyStats.toObject(message.queryLatencyStats, options); + if (message.context != null && message.hasOwnProperty("context")) + object.context = $root.StatsContext.toObject(message.context, options); + return object; + }; + ContextualizedQueryLatencyStats.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ContextualizedQueryLatencyStats; + }(); + $root.ContextualizedTypeStats = function() { + function ContextualizedTypeStats(properties) { + this.perTypeStat = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ContextualizedTypeStats.prototype.context = null; + ContextualizedTypeStats.prototype.perTypeStat = $util.emptyObject; + ContextualizedTypeStats.create = function create(properties) { + return new ContextualizedTypeStats(properties); + }; + ContextualizedTypeStats.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.context != null && Object.hasOwnProperty.call(message, "context")) + $root.StatsContext.encode(message.context, writer.uint32(10).fork()).ldelim(); + if (message.perTypeStat != null && Object.hasOwnProperty.call(message, "perTypeStat")) + for (var keys = Object.keys(message.perTypeStat), i = 0; i < keys.length; ++i) { + writer.uint32(18).fork().uint32(10).string(keys[i]); + $root.TypeStat.encode(message.perTypeStat[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + return writer; + }; + ContextualizedTypeStats.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ContextualizedTypeStats.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ContextualizedTypeStats(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.context = $root.StatsContext.decode(reader, reader.uint32()); + break; + case 2: + reader.skip().pos++; + if (message.perTypeStat === $util.emptyObject) + message.perTypeStat = {}; + key = reader.string(); + reader.pos++; + message.perTypeStat[key] = $root.TypeStat.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ContextualizedTypeStats.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ContextualizedTypeStats.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.context != null && message.hasOwnProperty("context")) { + var error = $root.StatsContext.verify(message.context); + if (error) + return "context." + error; + } + if (message.perTypeStat != null && message.hasOwnProperty("perTypeStat")) { + if (!$util.isObject(message.perTypeStat)) + return "perTypeStat: object expected"; + var key = Object.keys(message.perTypeStat); + for (var i = 0; i < key.length; ++i) { + var error = $root.TypeStat.verify(message.perTypeStat[key[i]]); + if (error) + return "perTypeStat." + error; + } + } + return null; + }; + ContextualizedTypeStats.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) + object.perTypeStat = {}; + if (options.defaults) + object.context = null; + if (message.context != null && message.hasOwnProperty("context")) + object.context = $root.StatsContext.toObject(message.context, options); + var keys2; + if (message.perTypeStat && (keys2 = Object.keys(message.perTypeStat)).length) { + object.perTypeStat = {}; + for (var j = 0; j < keys2.length; ++j) + object.perTypeStat[keys2[j]] = $root.TypeStat.toObject(message.perTypeStat[keys2[j]], options); + } + return object; + }; + ContextualizedTypeStats.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ContextualizedTypeStats; + }(); + $root.FieldStat = function() { + function FieldStat(properties) { + this.latencyCount = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + FieldStat.prototype.returnType = ""; + FieldStat.prototype.errorsCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + FieldStat.prototype.observedExecutionCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + FieldStat.prototype.estimatedExecutionCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + FieldStat.prototype.requestsWithErrorsCount = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + FieldStat.prototype.latencyCount = $util.emptyArray; + FieldStat.create = function create(properties) { + return new FieldStat(properties); + }; + FieldStat.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.returnType != null && Object.hasOwnProperty.call(message, "returnType")) + writer.uint32(26).string(message.returnType); + if (message.errorsCount != null && Object.hasOwnProperty.call(message, "errorsCount")) + writer.uint32(32).uint64(message.errorsCount); + if (message.observedExecutionCount != null && Object.hasOwnProperty.call(message, "observedExecutionCount")) + writer.uint32(40).uint64(message.observedExecutionCount); + if (message.requestsWithErrorsCount != null && Object.hasOwnProperty.call(message, "requestsWithErrorsCount")) + writer.uint32(48).uint64(message.requestsWithErrorsCount); + var array9; + if (message.latencyCount != null && message.latencyCount.toArray) + array9 = message.latencyCount.toArray(); + else + array9 = message.latencyCount; + if (array9 != null && array9.length) { + writer.uint32(74).fork(); + for (var i = 0; i < array9.length; ++i) + writer.sint64(array9[i]); + writer.ldelim(); + } + if (message.estimatedExecutionCount != null && Object.hasOwnProperty.call(message, "estimatedExecutionCount")) + writer.uint32(80).uint64(message.estimatedExecutionCount); + return writer; + }; + FieldStat.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + FieldStat.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.FieldStat(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 3: + message.returnType = reader.string(); + break; + case 4: + message.errorsCount = reader.uint64(); + break; + case 5: + message.observedExecutionCount = reader.uint64(); + break; + case 10: + message.estimatedExecutionCount = reader.uint64(); + break; + case 6: + message.requestsWithErrorsCount = reader.uint64(); + break; + case 9: + if (!(message.latencyCount && message.latencyCount.length)) + message.latencyCount = []; + if ((tag & 7) === 2) { + var end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.latencyCount.push(reader.sint64()); + } else + message.latencyCount.push(reader.sint64()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + FieldStat.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + FieldStat.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.returnType != null && message.hasOwnProperty("returnType")) { + if (!$util.isString(message.returnType)) + return "returnType: string expected"; + } + if (message.errorsCount != null && message.hasOwnProperty("errorsCount")) { + if (!$util.isInteger(message.errorsCount) && !(message.errorsCount && $util.isInteger(message.errorsCount.low) && $util.isInteger(message.errorsCount.high))) + return "errorsCount: integer|Long expected"; + } + if (message.observedExecutionCount != null && message.hasOwnProperty("observedExecutionCount")) { + if (!$util.isInteger(message.observedExecutionCount) && !(message.observedExecutionCount && $util.isInteger(message.observedExecutionCount.low) && $util.isInteger(message.observedExecutionCount.high))) + return "observedExecutionCount: integer|Long expected"; + } + if (message.estimatedExecutionCount != null && message.hasOwnProperty("estimatedExecutionCount")) { + if (!$util.isInteger(message.estimatedExecutionCount) && !(message.estimatedExecutionCount && $util.isInteger(message.estimatedExecutionCount.low) && $util.isInteger(message.estimatedExecutionCount.high))) + return "estimatedExecutionCount: integer|Long expected"; + } + if (message.requestsWithErrorsCount != null && message.hasOwnProperty("requestsWithErrorsCount")) { + if (!$util.isInteger(message.requestsWithErrorsCount) && !(message.requestsWithErrorsCount && $util.isInteger(message.requestsWithErrorsCount.low) && $util.isInteger(message.requestsWithErrorsCount.high))) + return "requestsWithErrorsCount: integer|Long expected"; + } + if (message.latencyCount != null && message.hasOwnProperty("latencyCount")) { + var array9; + if (message.latencyCount != null && message.latencyCount.toArray) + array9 = message.latencyCount.toArray(); + else + array9 = message.latencyCount; + if (!Array.isArray(array9)) + return "latencyCount: array expected"; + for (var i = 0; i < array9.length; ++i) + if (!$util.isInteger(array9[i]) && !(array9[i] && $util.isInteger(array9[i].low) && $util.isInteger(array9[i].high))) + return "latencyCount: integer|Long[] expected"; + } + return null; + }; + FieldStat.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.latencyCount = []; + if (options.defaults) { + object.returnType = ""; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.errorsCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.errorsCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.observedExecutionCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.observedExecutionCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.requestsWithErrorsCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.requestsWithErrorsCount = options.longs === String ? "0" : 0; + if ($util.Long) { + var long = new $util.Long(0, 0, true); + object.estimatedExecutionCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.estimatedExecutionCount = options.longs === String ? "0" : 0; + } + if (message.returnType != null && message.hasOwnProperty("returnType")) + object.returnType = message.returnType; + if (message.errorsCount != null && message.hasOwnProperty("errorsCount")) + if (typeof message.errorsCount === "number") + object.errorsCount = options.longs === String ? String(message.errorsCount) : message.errorsCount; + else + object.errorsCount = options.longs === String ? $util.Long.prototype.toString.call(message.errorsCount) : options.longs === Number ? new $util.LongBits(message.errorsCount.low >>> 0, message.errorsCount.high >>> 0).toNumber(true) : message.errorsCount; + if (message.observedExecutionCount != null && message.hasOwnProperty("observedExecutionCount")) + if (typeof message.observedExecutionCount === "number") + object.observedExecutionCount = options.longs === String ? String(message.observedExecutionCount) : message.observedExecutionCount; + else + object.observedExecutionCount = options.longs === String ? $util.Long.prototype.toString.call(message.observedExecutionCount) : options.longs === Number ? new $util.LongBits(message.observedExecutionCount.low >>> 0, message.observedExecutionCount.high >>> 0).toNumber(true) : message.observedExecutionCount; + if (message.requestsWithErrorsCount != null && message.hasOwnProperty("requestsWithErrorsCount")) + if (typeof message.requestsWithErrorsCount === "number") + object.requestsWithErrorsCount = options.longs === String ? String(message.requestsWithErrorsCount) : message.requestsWithErrorsCount; + else + object.requestsWithErrorsCount = options.longs === String ? $util.Long.prototype.toString.call(message.requestsWithErrorsCount) : options.longs === Number ? new $util.LongBits(message.requestsWithErrorsCount.low >>> 0, message.requestsWithErrorsCount.high >>> 0).toNumber(true) : message.requestsWithErrorsCount; + if (message.latencyCount && message.latencyCount.length) { + object.latencyCount = []; + for (var j = 0; j < message.latencyCount.length; ++j) + if (typeof message.latencyCount[j] === "number") + object.latencyCount[j] = options.longs === String ? String(message.latencyCount[j]) : message.latencyCount[j]; + else + object.latencyCount[j] = options.longs === String ? $util.Long.prototype.toString.call(message.latencyCount[j]) : options.longs === Number ? new $util.LongBits(message.latencyCount[j].low >>> 0, message.latencyCount[j].high >>> 0).toNumber() : message.latencyCount[j]; + } + if (message.estimatedExecutionCount != null && message.hasOwnProperty("estimatedExecutionCount")) + if (typeof message.estimatedExecutionCount === "number") + object.estimatedExecutionCount = options.longs === String ? String(message.estimatedExecutionCount) : message.estimatedExecutionCount; + else + object.estimatedExecutionCount = options.longs === String ? $util.Long.prototype.toString.call(message.estimatedExecutionCount) : options.longs === Number ? new $util.LongBits(message.estimatedExecutionCount.low >>> 0, message.estimatedExecutionCount.high >>> 0).toNumber(true) : message.estimatedExecutionCount; + return object; + }; + FieldStat.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return FieldStat; + }(); + $root.TypeStat = function() { + function TypeStat(properties) { + this.perFieldStat = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + TypeStat.prototype.perFieldStat = $util.emptyObject; + TypeStat.create = function create(properties) { + return new TypeStat(properties); + }; + TypeStat.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.perFieldStat != null && Object.hasOwnProperty.call(message, "perFieldStat")) + for (var keys = Object.keys(message.perFieldStat), i = 0; i < keys.length; ++i) { + writer.uint32(26).fork().uint32(10).string(keys[i]); + $root.FieldStat.encode(message.perFieldStat[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + return writer; + }; + TypeStat.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + TypeStat.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.TypeStat(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 3: + reader.skip().pos++; + if (message.perFieldStat === $util.emptyObject) + message.perFieldStat = {}; + key = reader.string(); + reader.pos++; + message.perFieldStat[key] = $root.FieldStat.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + TypeStat.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + TypeStat.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.perFieldStat != null && message.hasOwnProperty("perFieldStat")) { + if (!$util.isObject(message.perFieldStat)) + return "perFieldStat: object expected"; + var key = Object.keys(message.perFieldStat); + for (var i = 0; i < key.length; ++i) { + var error = $root.FieldStat.verify(message.perFieldStat[key[i]]); + if (error) + return "perFieldStat." + error; + } + } + return null; + }; + TypeStat.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) + object.perFieldStat = {}; + var keys2; + if (message.perFieldStat && (keys2 = Object.keys(message.perFieldStat)).length) { + object.perFieldStat = {}; + for (var j = 0; j < keys2.length; ++j) + object.perFieldStat[keys2[j]] = $root.FieldStat.toObject(message.perFieldStat[keys2[j]], options); + } + return object; + }; + TypeStat.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return TypeStat; + }(); + $root.ReferencedFieldsForType = function() { + function ReferencedFieldsForType(properties) { + this.fieldNames = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ReferencedFieldsForType.prototype.fieldNames = $util.emptyArray; + ReferencedFieldsForType.prototype.isInterface = false; + ReferencedFieldsForType.create = function create(properties) { + return new ReferencedFieldsForType(properties); + }; + ReferencedFieldsForType.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.fieldNames != null && message.fieldNames.length) + for (var i = 0; i < message.fieldNames.length; ++i) + writer.uint32(10).string(message.fieldNames[i]); + if (message.isInterface != null && Object.hasOwnProperty.call(message, "isInterface")) + writer.uint32(16).bool(message.isInterface); + return writer; + }; + ReferencedFieldsForType.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ReferencedFieldsForType.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ReferencedFieldsForType(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.fieldNames && message.fieldNames.length)) + message.fieldNames = []; + message.fieldNames.push(reader.string()); + break; + case 2: + message.isInterface = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ReferencedFieldsForType.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ReferencedFieldsForType.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.fieldNames != null && message.hasOwnProperty("fieldNames")) { + if (!Array.isArray(message.fieldNames)) + return "fieldNames: array expected"; + for (var i = 0; i < message.fieldNames.length; ++i) + if (!$util.isString(message.fieldNames[i])) + return "fieldNames: string[] expected"; + } + if (message.isInterface != null && message.hasOwnProperty("isInterface")) { + if (typeof message.isInterface !== "boolean") + return "isInterface: boolean expected"; + } + return null; + }; + ReferencedFieldsForType.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.fieldNames = []; + if (options.defaults) + object.isInterface = false; + if (message.fieldNames && message.fieldNames.length) { + object.fieldNames = []; + for (var j = 0; j < message.fieldNames.length; ++j) + object.fieldNames[j] = message.fieldNames[j]; + } + if (message.isInterface != null && message.hasOwnProperty("isInterface")) + object.isInterface = message.isInterface; + return object; + }; + ReferencedFieldsForType.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ReferencedFieldsForType; + }(); + $root.Report = function() { + function Report(properties) { + this.tracesPerQuery = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Report.prototype.header = null; + Report.prototype.tracesPerQuery = $util.emptyObject; + Report.prototype.endTime = null; + Report.create = function create(properties) { + return new Report(properties); + }; + Report.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.header != null && Object.hasOwnProperty.call(message, "header")) + $root.ReportHeader.encode(message.header, writer.uint32(10).fork()).ldelim(); + if (message.endTime != null && Object.hasOwnProperty.call(message, "endTime")) + $root.google.protobuf.Timestamp.encode(message.endTime, writer.uint32(18).fork()).ldelim(); + if (message.tracesPerQuery != null && Object.hasOwnProperty.call(message, "tracesPerQuery")) + for (var keys = Object.keys(message.tracesPerQuery), i = 0; i < keys.length; ++i) { + writer.uint32(42).fork().uint32(10).string(keys[i]); + $root.TracesAndStats.encode(message.tracesPerQuery[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + return writer; + }; + Report.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Report.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Report(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.header = $root.ReportHeader.decode(reader, reader.uint32()); + break; + case 5: + reader.skip().pos++; + if (message.tracesPerQuery === $util.emptyObject) + message.tracesPerQuery = {}; + key = reader.string(); + reader.pos++; + message.tracesPerQuery[key] = $root.TracesAndStats.decode(reader, reader.uint32()); + break; + case 2: + message.endTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Report.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Report.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.header != null && message.hasOwnProperty("header")) { + var error = $root.ReportHeader.verify(message.header); + if (error) + return "header." + error; + } + if (message.tracesPerQuery != null && message.hasOwnProperty("tracesPerQuery")) { + if (!$util.isObject(message.tracesPerQuery)) + return "tracesPerQuery: object expected"; + var key = Object.keys(message.tracesPerQuery); + for (var i = 0; i < key.length; ++i) { + var error = $root.TracesAndStats.verify(message.tracesPerQuery[key[i]]); + if (error) + return "tracesPerQuery." + error; + } + } + if (message.endTime != null && message.hasOwnProperty("endTime")) { + var error = $root.google.protobuf.Timestamp.verify(message.endTime); + if (error) + return "endTime." + error; + } + return null; + }; + Report.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) + object.tracesPerQuery = {}; + if (options.defaults) { + object.header = null; + object.endTime = null; + } + if (message.header != null && message.hasOwnProperty("header")) + object.header = $root.ReportHeader.toObject(message.header, options); + if (message.endTime != null && message.hasOwnProperty("endTime")) + object.endTime = $root.google.protobuf.Timestamp.toObject(message.endTime, options); + var keys2; + if (message.tracesPerQuery && (keys2 = Object.keys(message.tracesPerQuery)).length) { + object.tracesPerQuery = {}; + for (var j = 0; j < keys2.length; ++j) + object.tracesPerQuery[keys2[j]] = $root.TracesAndStats.toObject(message.tracesPerQuery[keys2[j]], options); + } + return object; + }; + Report.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Report; + }(); + $root.ContextualizedStats = function() { + function ContextualizedStats(properties) { + this.perTypeStat = {}; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + ContextualizedStats.prototype.context = null; + ContextualizedStats.prototype.queryLatencyStats = null; + ContextualizedStats.prototype.perTypeStat = $util.emptyObject; + ContextualizedStats.create = function create(properties) { + return new ContextualizedStats(properties); + }; + ContextualizedStats.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.context != null && Object.hasOwnProperty.call(message, "context")) + $root.StatsContext.encode(message.context, writer.uint32(10).fork()).ldelim(); + if (message.queryLatencyStats != null && Object.hasOwnProperty.call(message, "queryLatencyStats")) + $root.QueryLatencyStats.encode(message.queryLatencyStats, writer.uint32(18).fork()).ldelim(); + if (message.perTypeStat != null && Object.hasOwnProperty.call(message, "perTypeStat")) + for (var keys = Object.keys(message.perTypeStat), i = 0; i < keys.length; ++i) { + writer.uint32(26).fork().uint32(10).string(keys[i]); + $root.TypeStat.encode(message.perTypeStat[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + return writer; + }; + ContextualizedStats.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + ContextualizedStats.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ContextualizedStats(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.context = $root.StatsContext.decode(reader, reader.uint32()); + break; + case 2: + message.queryLatencyStats = $root.QueryLatencyStats.decode(reader, reader.uint32()); + break; + case 3: + reader.skip().pos++; + if (message.perTypeStat === $util.emptyObject) + message.perTypeStat = {}; + key = reader.string(); + reader.pos++; + message.perTypeStat[key] = $root.TypeStat.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + ContextualizedStats.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + ContextualizedStats.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.context != null && message.hasOwnProperty("context")) { + var error = $root.StatsContext.verify(message.context); + if (error) + return "context." + error; + } + if (message.queryLatencyStats != null && message.hasOwnProperty("queryLatencyStats")) { + var error = $root.QueryLatencyStats.verify(message.queryLatencyStats); + if (error) + return "queryLatencyStats." + error; + } + if (message.perTypeStat != null && message.hasOwnProperty("perTypeStat")) { + if (!$util.isObject(message.perTypeStat)) + return "perTypeStat: object expected"; + var key = Object.keys(message.perTypeStat); + for (var i = 0; i < key.length; ++i) { + var error = $root.TypeStat.verify(message.perTypeStat[key[i]]); + if (error) + return "perTypeStat." + error; + } + } + return null; + }; + ContextualizedStats.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.objects || options.defaults) + object.perTypeStat = {}; + if (options.defaults) { + object.context = null; + object.queryLatencyStats = null; + } + if (message.context != null && message.hasOwnProperty("context")) + object.context = $root.StatsContext.toObject(message.context, options); + if (message.queryLatencyStats != null && message.hasOwnProperty("queryLatencyStats")) + object.queryLatencyStats = $root.QueryLatencyStats.toObject(message.queryLatencyStats, options); + var keys2; + if (message.perTypeStat && (keys2 = Object.keys(message.perTypeStat)).length) { + object.perTypeStat = {}; + for (var j = 0; j < keys2.length; ++j) + object.perTypeStat[keys2[j]] = $root.TypeStat.toObject(message.perTypeStat[keys2[j]], options); + } + return object; + }; + ContextualizedStats.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return ContextualizedStats; + }(); + $root.TracesAndStats = function() { + function TracesAndStats(properties) { + this.trace = []; + this.statsWithContext = []; + this.referencedFieldsByType = {}; + this.internalTracesContributingToStats = []; + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + TracesAndStats.prototype.trace = $util.emptyArray; + TracesAndStats.prototype.statsWithContext = $util.emptyArray; + TracesAndStats.prototype.referencedFieldsByType = $util.emptyObject; + TracesAndStats.prototype.internalTracesContributingToStats = $util.emptyArray; + TracesAndStats.create = function create(properties) { + return new TracesAndStats(properties); + }; + TracesAndStats.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.trace != null && message.trace.length) + for (var i = 0; i < message.trace.length; ++i) + if (message.trace[i] instanceof Uint8Array) { + writer.uint32(10); + writer.bytes(message.trace[i]); + } else + $root.Trace.encode(message.trace[i], writer.uint32(10).fork()).ldelim(); + var array2; + if (message.statsWithContext != null && message.statsWithContext.toArray) + array2 = message.statsWithContext.toArray(); + else + array2 = message.statsWithContext; + if (array2 != null && array2.length) + for (var i = 0; i < array2.length; ++i) + $root.ContextualizedStats.encode(array2[i], writer.uint32(18).fork()).ldelim(); + if (message.internalTracesContributingToStats != null && message.internalTracesContributingToStats.length) + for (var i = 0; i < message.internalTracesContributingToStats.length; ++i) + if (message.internalTracesContributingToStats[i] instanceof Uint8Array) { + writer.uint32(26); + writer.bytes(message.internalTracesContributingToStats[i]); + } else + $root.Trace.encode(message.internalTracesContributingToStats[i], writer.uint32(26).fork()).ldelim(); + if (message.referencedFieldsByType != null && Object.hasOwnProperty.call(message, "referencedFieldsByType")) + for (var keys = Object.keys(message.referencedFieldsByType), i = 0; i < keys.length; ++i) { + writer.uint32(34).fork().uint32(10).string(keys[i]); + $root.ReferencedFieldsForType.encode(message.referencedFieldsByType[keys[i]], writer.uint32(18).fork()).ldelim().ldelim(); + } + return writer; + }; + TracesAndStats.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + TracesAndStats.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.TracesAndStats(), key; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.trace && message.trace.length)) + message.trace = []; + message.trace.push($root.Trace.decode(reader, reader.uint32())); + break; + case 2: + if (!(message.statsWithContext && message.statsWithContext.length)) + message.statsWithContext = []; + message.statsWithContext.push($root.ContextualizedStats.decode(reader, reader.uint32())); + break; + case 4: + reader.skip().pos++; + if (message.referencedFieldsByType === $util.emptyObject) + message.referencedFieldsByType = {}; + key = reader.string(); + reader.pos++; + message.referencedFieldsByType[key] = $root.ReferencedFieldsForType.decode(reader, reader.uint32()); + break; + case 3: + if (!(message.internalTracesContributingToStats && message.internalTracesContributingToStats.length)) + message.internalTracesContributingToStats = []; + message.internalTracesContributingToStats.push($root.Trace.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + TracesAndStats.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + TracesAndStats.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.trace != null && message.hasOwnProperty("trace")) { + if (!Array.isArray(message.trace)) + return "trace: array expected"; + for (var i = 0; i < message.trace.length; ++i) + if (!(message.trace[i] instanceof Uint8Array)) { + var error = $root.Trace.verify(message.trace[i]); + if (error) + return "trace." + error; + } + } + if (message.statsWithContext != null && message.hasOwnProperty("statsWithContext")) { + var array2; + if (message.statsWithContext != null && message.statsWithContext.toArray) + array2 = message.statsWithContext.toArray(); + else + array2 = message.statsWithContext; + if (!Array.isArray(array2)) + return "statsWithContext: array expected"; + for (var i = 0; i < array2.length; ++i) { + var error = $root.ContextualizedStats.verify(array2[i]); + if (error) + return "statsWithContext." + error; + } + } + if (message.referencedFieldsByType != null && message.hasOwnProperty("referencedFieldsByType")) { + if (!$util.isObject(message.referencedFieldsByType)) + return "referencedFieldsByType: object expected"; + var key = Object.keys(message.referencedFieldsByType); + for (var i = 0; i < key.length; ++i) { + var error = $root.ReferencedFieldsForType.verify(message.referencedFieldsByType[key[i]]); + if (error) + return "referencedFieldsByType." + error; + } + } + if (message.internalTracesContributingToStats != null && message.hasOwnProperty("internalTracesContributingToStats")) { + if (!Array.isArray(message.internalTracesContributingToStats)) + return "internalTracesContributingToStats: array expected"; + for (var i = 0; i < message.internalTracesContributingToStats.length; ++i) + if (!(message.internalTracesContributingToStats[i] instanceof Uint8Array)) { + var error = $root.Trace.verify(message.internalTracesContributingToStats[i]); + if (error) + return "internalTracesContributingToStats." + error; + } + } + return null; + }; + TracesAndStats.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) { + object.trace = []; + object.statsWithContext = []; + object.internalTracesContributingToStats = []; + } + if (options.objects || options.defaults) + object.referencedFieldsByType = {}; + if (message.trace && message.trace.length) { + object.trace = []; + for (var j = 0; j < message.trace.length; ++j) + object.trace[j] = $root.Trace.toObject(message.trace[j], options); + } + if (message.statsWithContext && message.statsWithContext.length) { + object.statsWithContext = []; + for (var j = 0; j < message.statsWithContext.length; ++j) + object.statsWithContext[j] = $root.ContextualizedStats.toObject(message.statsWithContext[j], options); + } + if (message.internalTracesContributingToStats && message.internalTracesContributingToStats.length) { + object.internalTracesContributingToStats = []; + for (var j = 0; j < message.internalTracesContributingToStats.length; ++j) + object.internalTracesContributingToStats[j] = $root.Trace.toObject(message.internalTracesContributingToStats[j], options); + } + var keys2; + if (message.referencedFieldsByType && (keys2 = Object.keys(message.referencedFieldsByType)).length) { + object.referencedFieldsByType = {}; + for (var j = 0; j < keys2.length; ++j) + object.referencedFieldsByType[keys2[j]] = $root.ReferencedFieldsForType.toObject(message.referencedFieldsByType[keys2[j]], options); + } + return object; + }; + TracesAndStats.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return TracesAndStats; + }(); + $root.google = function() { + var google = {}; + google.protobuf = function() { + var protobuf = {}; + protobuf.Timestamp = function() { + function Timestamp(properties) { + if (properties) { + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + } + Timestamp.prototype.seconds = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Timestamp.prototype.nanos = 0; + Timestamp.create = function create(properties) { + return new Timestamp(properties); + }; + Timestamp.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.seconds != null && Object.hasOwnProperty.call(message, "seconds")) + writer.uint32(8).int64(message.seconds); + if (message.nanos != null && Object.hasOwnProperty.call(message, "nanos")) + writer.uint32(16).int32(message.nanos); + return writer; + }; + Timestamp.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + Timestamp.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.google.protobuf.Timestamp(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.seconds = reader.int64(); + break; + case 2: + message.nanos = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + Timestamp.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + Timestamp.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.seconds != null && message.hasOwnProperty("seconds")) { + if (!$util.isInteger(message.seconds) && !(message.seconds && $util.isInteger(message.seconds.low) && $util.isInteger(message.seconds.high))) + return "seconds: integer|Long expected"; + } + if (message.nanos != null && message.hasOwnProperty("nanos")) { + if (!$util.isInteger(message.nanos)) + return "nanos: integer expected"; + } + return null; + }; + Timestamp.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + if ($util.Long) { + var long = new $util.Long(0, 0, false); + object.seconds = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.seconds = options.longs === String ? "0" : 0; + object.nanos = 0; + } + if (message.seconds != null && message.hasOwnProperty("seconds")) + if (typeof message.seconds === "number") + object.seconds = options.longs === String ? String(message.seconds) : message.seconds; + else + object.seconds = options.longs === String ? $util.Long.prototype.toString.call(message.seconds) : options.longs === Number ? new $util.LongBits(message.seconds.low >>> 0, message.seconds.high >>> 0).toNumber() : message.seconds; + if (message.nanos != null && message.hasOwnProperty("nanos")) + object.nanos = message.nanos; + return object; + }; + Timestamp.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + return Timestamp; + }(); + return protobuf; + }(); + return google; + }(); + module2.exports = $root; + } +}); + +// node_modules/apollo-reporting-protobuf/generated/index.js +var require_generated = __commonJS({ + "node_modules/apollo-reporting-protobuf/generated/index.js"(exports2, module2) { + var protobuf = require_protobuf(); + var protobufJS = require_minimal2(); + protobufJS.util.Long = void 0; + protobufJS.configure(); + module2.exports = protobuf; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/operationDerivedDataCache.js +var require_operationDerivedDataCache = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/operationDerivedDataCache.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.operationDerivedDataCacheKey = exports2.createOperationDerivedDataCache = void 0; + var lru_cache_1 = __importDefault(require_lru_cache()); + function createOperationDerivedDataCache({ logger }) { + let lastWarn; + let lastDisposals = 0; + return new lru_cache_1.default({ + length(obj) { + return Buffer.byteLength(JSON.stringify(obj), "utf8"); + }, + max: Math.pow(2, 20) * 10, + dispose() { + lastDisposals++; + if (!lastWarn || new Date().getTime() - lastWarn.getTime() > 6e4) { + lastWarn = new Date(); + logger.warn([ + "This server is processing a high number of unique operations. ", + `A total of ${lastDisposals} records have been `, + "ejected from the ApolloServerPluginUsageReporting signature cache in the past ", + "interval. If you see this warning frequently, please open an ", + "issue on the Apollo Server repository." + ].join("")); + lastDisposals = 0; + } + } + }); + } + exports2.createOperationDerivedDataCache = createOperationDerivedDataCache; + function operationDerivedDataCacheKey(queryHash, operationName) { + return `${queryHash}${operationName && ":" + operationName}`; + } + exports2.operationDerivedDataCacheKey = operationDerivedDataCacheKey; + } +}); + +// node_modules/lodash.sortby/index.js +var require_lodash = __commonJS({ + "node_modules/lodash.sortby/index.js"(exports2, module2) { + var LARGE_ARRAY_SIZE = 200; + var FUNC_ERROR_TEXT = "Expected a function"; + var HASH_UNDEFINED = "__lodash_hash_undefined__"; + var UNORDERED_COMPARE_FLAG = 1; + var PARTIAL_COMPARE_FLAG = 2; + var INFINITY = 1 / 0; + var MAX_SAFE_INTEGER = 9007199254740991; + var argsTag = "[object Arguments]"; + var arrayTag = "[object Array]"; + var boolTag = "[object Boolean]"; + var dateTag = "[object Date]"; + var errorTag = "[object Error]"; + var funcTag = "[object Function]"; + var genTag = "[object GeneratorFunction]"; + var mapTag = "[object Map]"; + var numberTag = "[object Number]"; + var objectTag = "[object Object]"; + var promiseTag = "[object Promise]"; + var regexpTag = "[object RegExp]"; + var setTag = "[object Set]"; + var stringTag = "[object String]"; + var symbolTag = "[object Symbol]"; + var weakMapTag = "[object WeakMap]"; + var arrayBufferTag = "[object ArrayBuffer]"; + var dataViewTag = "[object DataView]"; + var float32Tag = "[object Float32Array]"; + var float64Tag = "[object Float64Array]"; + var int8Tag = "[object Int8Array]"; + var int16Tag = "[object Int16Array]"; + var int32Tag = "[object Int32Array]"; + var uint8Tag = "[object Uint8Array]"; + var uint8ClampedTag = "[object Uint8ClampedArray]"; + var uint16Tag = "[object Uint16Array]"; + var uint32Tag = "[object Uint32Array]"; + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/; + var reIsPlainProp = /^\w*$/; + var reLeadingDot = /^\./; + var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + var reEscapeChar = /\\(\\)?/g; + var reIsHostCtor = /^\[object .+?Constructor\]$/; + var reIsUint = /^(?:0|[1-9]\d*)$/; + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; + var freeGlobal = typeof global == "object" && global && global.Object === Object && global; + var freeSelf = typeof self == "object" && self && self.Object === Object && self; + var root = freeGlobal || freeSelf || Function("return this")(); + var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2; + var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2; + var moduleExports = freeModule && freeModule.exports === freeExports; + var freeProcess = moduleExports && freeGlobal.process; + var nodeUtil = function() { + try { + return freeProcess && freeProcess.binding("util"); + } catch (e) { + } + }(); + var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + function apply(func, thisArg, args) { + switch (args.length) { + case 0: + return func.call(thisArg); + case 1: + return func.call(thisArg, args[0]); + case 2: + return func.call(thisArg, args[0], args[1]); + case 3: + return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); + } + function arrayMap(array, iteratee) { + var index = -1, length = array ? array.length : 0, result = Array(length); + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + function arrayPush(array, values) { + var index = -1, length = values.length, offset = array.length; + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + function arraySome(array, predicate) { + var index = -1, length = array ? array.length : 0; + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + function baseProperty(key) { + return function(object) { + return object == null ? void 0 : object[key]; + }; + } + function baseSortBy(array, comparer) { + var length = array.length; + array.sort(comparer); + while (length--) { + array[length] = array[length].value; + } + return array; + } + function baseTimes(n, iteratee) { + var index = -1, result = Array(n); + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + function baseUnary(func) { + return function(value) { + return func(value); + }; + } + function getValue(object, key) { + return object == null ? void 0 : object[key]; + } + function isHostObject(value) { + var result = false; + if (value != null && typeof value.toString != "function") { + try { + result = !!(value + ""); + } catch (e) { + } + } + return result; + } + function mapToArray(map) { + var index = -1, result = Array(map.size); + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + function setToArray(set) { + var index = -1, result = Array(set.size); + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + var arrayProto = Array.prototype; + var funcProto = Function.prototype; + var objectProto = Object.prototype; + var coreJsData = root["__core-js_shared__"]; + var maskSrcKey = function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; + }(); + var funcToString = funcProto.toString; + var hasOwnProperty = objectProto.hasOwnProperty; + var objectToString = objectProto.toString; + var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"); + var Symbol2 = root.Symbol; + var Uint8Array2 = root.Uint8Array; + var propertyIsEnumerable = objectProto.propertyIsEnumerable; + var splice = arrayProto.splice; + var spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : void 0; + var nativeKeys = overArg(Object.keys, Object); + var nativeMax = Math.max; + var DataView = getNative(root, "DataView"); + var Map2 = getNative(root, "Map"); + var Promise2 = getNative(root, "Promise"); + var Set2 = getNative(root, "Set"); + var WeakMap2 = getNative(root, "WeakMap"); + var nativeCreate = getNative(Object, "create"); + var dataViewCtorString = toSource(DataView); + var mapCtorString = toSource(Map2); + var promiseCtorString = toSource(Promise2); + var setCtorString = toSource(Set2); + var weakMapCtorString = toSource(WeakMap2); + var symbolProto = Symbol2 ? Symbol2.prototype : void 0; + var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0; + var symbolToString = symbolProto ? symbolProto.toString : void 0; + function Hash(entries) { + var index = -1, length = entries ? entries.length : 0; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + } + function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; + } + function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? void 0 : result; + } + return hasOwnProperty.call(data, key) ? data[key] : void 0; + } + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key); + } + function hashSet(key, value) { + var data = this.__data__; + data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value; + return this; + } + Hash.prototype.clear = hashClear; + Hash.prototype["delete"] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + function ListCache(entries) { + var index = -1, length = entries ? entries.length : 0; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + function listCacheClear() { + this.__data__ = []; + } + function listCacheDelete(key) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; + } + function listCacheGet(key) { + var data = this.__data__, index = assocIndexOf(data, key); + return index < 0 ? void 0 : data[index][1]; + } + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + function listCacheSet(key, value) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + ListCache.prototype.clear = listCacheClear; + ListCache.prototype["delete"] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + function MapCache(entries) { + var index = -1, length = entries ? entries.length : 0; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + function mapCacheClear() { + this.__data__ = { + "hash": new Hash(), + "map": new (Map2 || ListCache)(), + "string": new Hash() + }; + } + function mapCacheDelete(key) { + return getMapData(this, key)["delete"](key); + } + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; + } + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype["delete"] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + function SetCache(values) { + var index = -1, length = values ? values.length : 0; + this.__data__ = new MapCache(); + while (++index < length) { + this.add(values[index]); + } + } + function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; + } + function setCacheHas(value) { + return this.__data__.has(value); + } + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + function Stack(entries) { + this.__data__ = new ListCache(entries); + } + function stackClear() { + this.__data__ = new ListCache(); + } + function stackDelete(key) { + return this.__data__["delete"](key); + } + function stackGet(key) { + return this.__data__.get(key); + } + function stackHas(key) { + return this.__data__.has(key); + } + function stackSet(key, value) { + var cache = this.__data__; + if (cache instanceof ListCache) { + var pairs = cache.__data__; + if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) { + pairs.push([key, value]); + return this; + } + cache = this.__data__ = new MapCache(pairs); + } + cache.set(key, value); + return this; + } + Stack.prototype.clear = stackClear; + Stack.prototype["delete"] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + function arrayLikeKeys(value, inherited) { + var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : []; + var length = result.length, skipIndexes = !!length; + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isIndex(key, length)))) { + result.push(key); + } + } + return result; + } + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + var baseEach = createBaseEach(baseForOwn); + function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, length = array.length; + predicate || (predicate = isFlattenable); + result || (result = []); + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; + } + var baseFor = createBaseFor(); + function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); + } + function baseGet(object, path) { + path = isKey(path, object) ? [path] : castPath(path); + var index = 0, length = path.length; + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return index && index == length ? object : void 0; + } + function baseGetTag(value) { + return objectToString.call(value); + } + function baseHasIn(object, key) { + return object != null && key in Object(object); + } + function baseIsEqual(value, other, customizer, bitmask, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || !isObject(value) && !isObjectLike(other)) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack); + } + function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) { + var objIsArr = isArray(object), othIsArr = isArray(other), objTag = arrayTag, othTag = arrayTag; + if (!objIsArr) { + objTag = getTag(object); + objTag = objTag == argsTag ? objectTag : objTag; + } + if (!othIsArr) { + othTag = getTag(other); + othTag = othTag == argsTag ? objectTag : othTag; + } + var objIsObj = objTag == objectTag && !isHostObject(object), othIsObj = othTag == objectTag && !isHostObject(other), isSameTag = objTag == othTag; + if (isSameTag && !objIsObj) { + stack || (stack = new Stack()); + return objIsArr || isTypedArray(object) ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack); + } + if (!(bitmask & PARTIAL_COMPARE_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__"); + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other; + stack || (stack = new Stack()); + return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack()); + return equalObjects(object, other, equalFunc, customizer, bitmask, stack); + } + function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, length = index, noCustomizer = !customizer; + if (object == null) { + return !length; + } + object = Object(object); + while (index--) { + var data = matchData[index]; + if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], objValue = object[key], srcValue = data[1]; + if (noCustomizer && data[2]) { + if (objValue === void 0 && !(key in object)) { + return false; + } + } else { + var stack = new Stack(); + if (customizer) { + var result = customizer(objValue, srcValue, key, object, source, stack); + } + if (!(result === void 0 ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) { + return false; + } + } + } + return true; + } + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + function baseIsTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objectToString.call(value)]; + } + function baseIteratee(value) { + if (typeof value == "function") { + return value; + } + if (value == null) { + return identity; + } + if (typeof value == "object") { + return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value); + } + return property(value); + } + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != "constructor") { + result.push(key); + } + } + return result; + } + function baseMap(collection, iteratee) { + var index = -1, result = isArrayLike(collection) ? Array(collection.length) : []; + baseEach(collection, function(value, key, collection2) { + result[++index] = iteratee(value, key, collection2); + }); + return result; + } + function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + return function(object) { + return object === source || baseIsMatch(object, source, matchData); + }; + } + function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + return function(object) { + var objValue = get(object, path); + return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG); + }; + } + function baseOrderBy(collection, iteratees, orders) { + var index = -1; + iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee)); + var result = baseMap(collection, function(value, key, collection2) { + var criteria = arrayMap(iteratees, function(iteratee) { + return iteratee(value); + }); + return { "criteria": criteria, "index": ++index, "value": value }; + }); + return baseSortBy(result, function(object, other) { + return compareMultiple(object, other, orders); + }); + } + function basePropertyDeep(path) { + return function(object) { + return baseGet(object, path); + }; + } + function baseRest(func, start) { + start = nativeMax(start === void 0 ? func.length - 1 : start, 0); + return function() { + var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length); + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = array; + return apply(func, this, otherArgs); + }; + } + function baseToString(value) { + if (typeof value == "string") { + return value; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ""; + } + var result = value + ""; + return result == "0" && 1 / value == -INFINITY ? "-0" : result; + } + function castPath(value) { + return isArray(value) ? value : stringToPath(value); + } + function compareAscending(value, other) { + if (value !== other) { + var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value); + var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other); + if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) { + return 1; + } + if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) { + return -1; + } + } + return 0; + } + function compareMultiple(object, other, orders) { + var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length; + while (++index < length) { + var result = compareAscending(objCriteria[index], othCriteria[index]); + if (result) { + if (index >= ordersLength) { + return result; + } + var order = orders[index]; + return result * (order == "desc" ? -1 : 1); + } + } + return object.index - other.index; + } + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection); + while (fromRight ? index-- : ++index < length) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + function equalArrays(array, other, equalFunc, customizer, bitmask, stack) { + var isPartial = bitmask & PARTIAL_COMPARE_FLAG, arrLength = array.length, othLength = other.length; + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + var stacked = stack.get(array); + if (stacked && stack.get(other)) { + return stacked == other; + } + var index = -1, result = true, seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : void 0; + stack.set(array, other); + stack.set(other, array); + while (++index < arrLength) { + var arrValue = array[index], othValue = other[index]; + if (customizer) { + var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== void 0) { + if (compared) { + continue; + } + result = false; + break; + } + if (seen) { + if (!arraySome(other, function(othValue2, othIndex) { + if (!seen.has(othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, customizer, bitmask, stack))) { + return seen.add(othIndex); + } + })) { + result = false; + break; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) { + result = false; + break; + } + } + stack["delete"](array); + stack["delete"](other); + return result; + } + function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) { + switch (tag) { + case dataViewTag: + if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) { + return false; + } + object = object.buffer; + other = other.buffer; + case arrayBufferTag: + if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) { + return false; + } + return true; + case boolTag: + case dateTag: + case numberTag: + return eq(+object, +other); + case errorTag: + return object.name == other.name && object.message == other.message; + case regexpTag: + case stringTag: + return object == other + ""; + case mapTag: + var convert = mapToArray; + case setTag: + var isPartial = bitmask & PARTIAL_COMPARE_FLAG; + convert || (convert = setToArray); + if (object.size != other.size && !isPartial) { + return false; + } + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= UNORDERED_COMPARE_FLAG; + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack); + stack["delete"](object); + return result; + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; + } + function equalObjects(object, other, equalFunc, customizer, bitmask, stack) { + var isPartial = bitmask & PARTIAL_COMPARE_FLAG, objProps = keys(object), objLength = objProps.length, othProps = keys(other), othLength = othProps.length; + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + var stacked = stack.get(object); + if (stacked && stack.get(other)) { + return stacked == other; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], othValue = other[key]; + if (customizer) { + var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); + } + if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack) : compared)) { + result = false; + break; + } + skipCtor || (skipCtor = key == "constructor"); + } + if (result && !skipCtor) { + var objCtor = object.constructor, othCtor = other.constructor; + if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) { + result = false; + } + } + stack["delete"](object); + stack["delete"](other); + return result; + } + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map; + } + function getMatchData(object) { + var result = keys(object), length = result.length; + while (length--) { + var key = result[length], value = object[key]; + result[length] = [key, value, isStrictComparable(value)]; + } + return result; + } + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : void 0; + } + var getTag = baseGetTag; + if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) { + getTag = function(value) { + var result = objectToString.call(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : void 0; + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: + return dataViewTag; + case mapCtorString: + return mapTag; + case promiseCtorString: + return promiseTag; + case setCtorString: + return setTag; + case weakMapCtorString: + return weakMapTag; + } + } + return result; + }; + } + function hasPath(object, path, hasFunc) { + path = isKey(path, object) ? [path] : castPath(path); + var result, index = -1, length = path.length; + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result) { + return result; + } + var length = object ? object.length : 0; + return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object)); + } + function isFlattenable(value) { + return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]); + } + function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length); + } + function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) { + return eq(object[index], value); + } + return false; + } + function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object); + } + function isKeyable(value) { + var type = typeof value; + return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null; + } + function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; + } + function isPrototype(value) { + var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto; + return value === proto; + } + function isStrictComparable(value) { + return value === value && !isObject(value); + } + function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && (srcValue !== void 0 || key in Object(object)); + }; + } + var stringToPath = memoize(function(string) { + string = toString(string); + var result = []; + if (reLeadingDot.test(string)) { + result.push(""); + } + string.replace(rePropName, function(match, number, quote, string2) { + result.push(quote ? string2.replace(reEscapeChar, "$1") : number || match); + }); + return result; + }); + function toKey(value) { + if (typeof value == "string" || isSymbol(value)) { + return value; + } + var result = value + ""; + return result == "0" && 1 / value == -INFINITY ? "-0" : result; + } + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) { + } + try { + return func + ""; + } catch (e) { + } + } + return ""; + } + var sortBy = baseRest(function(collection, iteratees) { + if (collection == null) { + return []; + } + var length = iteratees.length; + if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { + iteratees = []; + } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { + iteratees = [iteratees[0]]; + } + return baseOrderBy(collection, baseFlatten(iteratees, 1), []); + }); + function memoize(func, resolver) { + if (typeof func != "function" || resolver && typeof resolver != "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result); + return result; + }; + memoized.cache = new (memoize.Cache || MapCache)(); + return memoized; + } + memoize.Cache = MapCache; + function eq(value, other) { + return value === other || value !== value && other !== other; + } + function isArguments(value) { + return isArrayLikeObject(value) && hasOwnProperty.call(value, "callee") && (!propertyIsEnumerable.call(value, "callee") || objectToString.call(value) == argsTag); + } + var isArray = Array.isArray; + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + function isFunction(value) { + var tag = isObject(value) ? objectToString.call(value) : ""; + return tag == funcTag || tag == genTag; + } + function isLength(value) { + return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + function isObject(value) { + var type = typeof value; + return !!value && (type == "object" || type == "function"); + } + function isObjectLike(value) { + return !!value && typeof value == "object"; + } + function isSymbol(value) { + return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag; + } + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + function toString(value) { + return value == null ? "" : baseToString(value); + } + function get(object, path, defaultValue) { + var result = object == null ? void 0 : baseGet(object, path); + return result === void 0 ? defaultValue : result; + } + function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); + } + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + function identity(value) { + return value; + } + function property(path) { + return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); + } + module2.exports = sortBy; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/defaultUsageReportingSignature.js +var require_defaultUsageReportingSignature = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/defaultUsageReportingSignature.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.defaultUsageReportingSignature = void 0; + var graphql_1 = require_graphql2(); + var lodash_sortby_1 = __importDefault(require_lodash()); + function defaultUsageReportingSignature(ast, operationName) { + return printWithReducedWhitespace(sortAST(removeAliases(hideLiterals(dropUnusedDefinitions(ast, operationName))))); + } + exports2.defaultUsageReportingSignature = defaultUsageReportingSignature; + function printWithReducedWhitespace(ast) { + const sanitizedAST = (0, graphql_1.visit)(ast, { + StringValue(node) { + return __spreadProps(__spreadValues({}, node), { + value: Buffer.from(node.value, "utf8").toString("hex"), + block: false + }); + } + }); + const withWhitespace = (0, graphql_1.print)(sanitizedAST); + const minimizedButStillHex = withWhitespace.replace(/\s+/g, " ").replace(/([^_a-zA-Z0-9]) /g, (_, c) => c).replace(/ ([^_a-zA-Z0-9])/g, (_, c) => c); + return minimizedButStillHex.replace(/"([a-f0-9]+)"/g, (_, hex) => JSON.stringify(Buffer.from(hex, "hex").toString("utf8"))); + } + function sortAST(ast) { + return (0, graphql_1.visit)(ast, { + Document(node) { + return __spreadProps(__spreadValues({}, node), { + definitions: (0, lodash_sortby_1.default)(node.definitions, "kind", "name.value") + }); + }, + OperationDefinition(node) { + return __spreadProps(__spreadValues({}, node), { + variableDefinitions: sorted(node.variableDefinitions, "variable.name.value") + }); + }, + SelectionSet(node) { + return __spreadProps(__spreadValues({}, node), { + selections: (0, lodash_sortby_1.default)(node.selections, "kind", "name.value") + }); + }, + Field(node) { + return __spreadProps(__spreadValues({}, node), { + arguments: sorted(node.arguments, "name.value") + }); + }, + FragmentSpread(node) { + return __spreadProps(__spreadValues({}, node), { directives: sorted(node.directives, "name.value") }); + }, + InlineFragment(node) { + return __spreadProps(__spreadValues({}, node), { directives: sorted(node.directives, "name.value") }); + }, + FragmentDefinition(node) { + return __spreadProps(__spreadValues({}, node), { + directives: sorted(node.directives, "name.value"), + variableDefinitions: sorted(node.variableDefinitions, "variable.name.value") + }); + }, + Directive(node) { + return __spreadProps(__spreadValues({}, node), { arguments: sorted(node.arguments, "name.value") }); + } + }); + } + function sorted(items, ...iteratees) { + if (items) { + return (0, lodash_sortby_1.default)(items, ...iteratees); + } + return void 0; + } + function removeAliases(ast) { + return (0, graphql_1.visit)(ast, { + Field(node) { + return __spreadProps(__spreadValues({}, node), { + alias: void 0 + }); + } + }); + } + function hideLiterals(ast) { + return (0, graphql_1.visit)(ast, { + IntValue(node) { + return __spreadProps(__spreadValues({}, node), { value: "0" }); + }, + FloatValue(node) { + return __spreadProps(__spreadValues({}, node), { value: "0" }); + }, + StringValue(node) { + return __spreadProps(__spreadValues({}, node), { value: "", block: false }); + }, + ListValue(node) { + return __spreadProps(__spreadValues({}, node), { values: [] }); + }, + ObjectValue(node) { + return __spreadProps(__spreadValues({}, node), { fields: [] }); + } + }); + } + function dropUnusedDefinitions(ast, operationName) { + const separated = (0, graphql_1.separateOperations)(ast)[operationName]; + if (!separated) { + return ast; + } + return separated; + } + } +}); + +// node_modules/apollo-server-core/dist/plugin/traceTreeBuilder.js +var require_traceTreeBuilder = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/traceTreeBuilder.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.dateToProtoTimestamp = exports2.TraceTreeBuilder = void 0; + var graphql_1 = require_graphql2(); + var apollo_reporting_protobuf_1 = require_generated(); + function internalError(message) { + return new Error(`[internal apollo-server error] ${message}`); + } + var TraceTreeBuilder = class { + constructor(options) { + this.rootNode = new apollo_reporting_protobuf_1.Trace.Node(); + this.logger = console; + this.trace = new apollo_reporting_protobuf_1.Trace({ root: this.rootNode }); + this.stopped = false; + this.nodes = new Map([ + [responsePathAsString(), this.rootNode] + ]); + this.rewriteError = options.rewriteError; + if (options.logger) + this.logger = options.logger; + } + startTiming() { + if (this.startHrTime) { + throw internalError("startTiming called twice!"); + } + if (this.stopped) { + throw internalError("startTiming called after stopTiming!"); + } + this.trace.startTime = dateToProtoTimestamp(new Date()); + this.startHrTime = process.hrtime(); + } + stopTiming() { + if (!this.startHrTime) { + throw internalError("stopTiming called before startTiming!"); + } + if (this.stopped) { + throw internalError("stopTiming called twice!"); + } + this.trace.durationNs = durationHrTimeToNanos(process.hrtime(this.startHrTime)); + this.trace.endTime = dateToProtoTimestamp(new Date()); + this.stopped = true; + } + willResolveField(info) { + if (!this.startHrTime) { + throw internalError("willResolveField called before startTiming!"); + } + if (this.stopped) { + throw internalError("willResolveField called after stopTiming!"); + } + const path = info.path; + const node = this.newNode(path); + node.type = info.returnType.toString(); + node.parentType = info.parentType.toString(); + node.startTime = durationHrTimeToNanos(process.hrtime(this.startHrTime)); + if (typeof path.key === "string" && path.key !== info.fieldName) { + node.originalFieldName = info.fieldName; + } + return () => { + node.endTime = durationHrTimeToNanos(process.hrtime(this.startHrTime)); + }; + } + didEncounterErrors(errors) { + errors.forEach((err) => { + var _a; + if ((_a = err.extensions) === null || _a === void 0 ? void 0 : _a.serviceName) { + return; + } + const errorForReporting = this.rewriteAndNormalizeError(err); + if (errorForReporting === null) { + return; + } + this.addProtobufError(errorForReporting.path, errorToProtobufError(errorForReporting)); + }); + } + addProtobufError(path, error) { + if (!this.startHrTime) { + throw internalError("addProtobufError called before startTiming!"); + } + if (this.stopped) { + throw internalError("addProtobufError called after stopTiming!"); + } + let node = this.rootNode; + if (Array.isArray(path)) { + const specificNode = this.nodes.get(path.join(".")); + if (specificNode) { + node = specificNode; + } else { + this.logger.warn(`Could not find node with path ${path.join(".")}; defaulting to put errors on root node.`); + } + } + node.error.push(error); + } + newNode(path) { + const node = new apollo_reporting_protobuf_1.Trace.Node(); + const id = path.key; + if (typeof id === "number") { + node.index = id; + } else { + node.responseName = id; + } + this.nodes.set(responsePathAsString(path), node); + const parentNode = this.ensureParentNode(path); + parentNode.child.push(node); + return node; + } + ensureParentNode(path) { + const parentPath = responsePathAsString(path.prev); + const parentNode = this.nodes.get(parentPath); + if (parentNode) { + return parentNode; + } + return this.newNode(path.prev); + } + rewriteAndNormalizeError(err) { + if (this.rewriteError) { + const clonedError = Object.assign(Object.create(Object.getPrototypeOf(err)), err); + const rewrittenError = this.rewriteError(clonedError); + if (rewrittenError === null) { + return null; + } + if (!(rewrittenError instanceof graphql_1.GraphQLError)) { + return err; + } + return new graphql_1.GraphQLError(rewrittenError.message, err.nodes, err.source, err.positions, err.path, err.originalError, rewrittenError.extensions || err.extensions); + } + return err; + } + }; + exports2.TraceTreeBuilder = TraceTreeBuilder; + function durationHrTimeToNanos(hrtime) { + return hrtime[0] * 1e9 + hrtime[1]; + } + function responsePathAsString(p) { + if (p === void 0) { + return ""; + } + let res = String(p.key); + while ((p = p.prev) !== void 0) { + res = `${p.key}.${res}`; + } + return res; + } + function errorToProtobufError(error) { + return new apollo_reporting_protobuf_1.Trace.Error({ + message: error.message, + location: (error.locations || []).map(({ line, column }) => new apollo_reporting_protobuf_1.Trace.Location({ line, column })), + json: JSON.stringify(error) + }); + } + function dateToProtoTimestamp(date) { + const totalMillis = +date; + const millis = totalMillis % 1e3; + return new apollo_reporting_protobuf_1.google.protobuf.Timestamp({ + seconds: (totalMillis - millis) / 1e3, + nanos: millis * 1e6 + }); + } + exports2.dateToProtoTimestamp = dateToProtoTimestamp; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/traceDetails.js +var require_traceDetails = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/traceDetails.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.makeTraceDetails = void 0; + var apollo_reporting_protobuf_1 = require_generated(); + function makeTraceDetails(variables, sendVariableValues, operationString) { + const details = new apollo_reporting_protobuf_1.Trace.Details(); + const variablesToRecord = (() => { + if (sendVariableValues && "transform" in sendVariableValues) { + const originalKeys = Object.keys(variables); + try { + const modifiedVariables = sendVariableValues.transform({ + variables, + operationString + }); + return cleanModifiedVariables(originalKeys, modifiedVariables); + } catch (e) { + return handleVariableValueTransformError(originalKeys); + } + } else { + return variables; + } + })(); + Object.keys(variablesToRecord).forEach((name) => { + if (!sendVariableValues || "none" in sendVariableValues && sendVariableValues.none || "all" in sendVariableValues && !sendVariableValues.all || "exceptNames" in sendVariableValues && sendVariableValues.exceptNames.includes(name) || "onlyNames" in sendVariableValues && !sendVariableValues.onlyNames.includes(name)) { + details.variablesJson[name] = ""; + } else { + try { + details.variablesJson[name] = typeof variablesToRecord[name] === "undefined" ? "" : JSON.stringify(variablesToRecord[name]); + } catch (e) { + details.variablesJson[name] = JSON.stringify("[Unable to convert value to JSON]"); + } + } + }); + return details; + } + exports2.makeTraceDetails = makeTraceDetails; + function handleVariableValueTransformError(variableNames) { + const modifiedVariables = Object.create(null); + variableNames.forEach((name) => { + modifiedVariables[name] = "[PREDICATE_FUNCTION_ERROR]"; + }); + return modifiedVariables; + } + function cleanModifiedVariables(originalKeys, modifiedVariables) { + const cleanedVariables = Object.create(null); + originalKeys.forEach((name) => { + cleanedVariables[name] = modifiedVariables[name]; + }); + return cleanedVariables; + } + } +}); + +// node_modules/uuid/dist/rng.js +var require_rng = __commonJS({ + "node_modules/uuid/dist/rng.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = rng; + var _crypto = _interopRequireDefault(require("crypto")); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var rnds8Pool = new Uint8Array(256); + var poolPtr = rnds8Pool.length; + function rng() { + if (poolPtr > rnds8Pool.length - 16) { + _crypto.default.randomFillSync(rnds8Pool); + poolPtr = 0; + } + return rnds8Pool.slice(poolPtr, poolPtr += 16); + } + } +}); + +// node_modules/uuid/dist/regex.js +var require_regex = __commonJS({ + "node_modules/uuid/dist/regex.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/validate.js +var require_validate3 = __commonJS({ + "node_modules/uuid/dist/validate.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _regex = _interopRequireDefault(require_regex()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function validate(uuid) { + return typeof uuid === "string" && _regex.default.test(uuid); + } + var _default = validate; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/stringify.js +var require_stringify = __commonJS({ + "node_modules/uuid/dist/stringify.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _validate = _interopRequireDefault(require_validate3()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var byteToHex = []; + for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 256).toString(16).substr(1)); + } + function stringify(arr, offset = 0) { + const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); + if (!(0, _validate.default)(uuid)) { + throw TypeError("Stringified UUID is invalid"); + } + return uuid; + } + var _default = stringify; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/v1.js +var require_v1 = __commonJS({ + "node_modules/uuid/dist/v1.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _rng = _interopRequireDefault(require_rng()); + var _stringify = _interopRequireDefault(require_stringify()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var _nodeId; + var _clockseq; + var _lastMSecs = 0; + var _lastNSecs = 0; + function v1(options, buf, offset) { + let i = buf && offset || 0; + const b = buf || new Array(16); + options = options || {}; + let node = options.node || _nodeId; + let clockseq = options.clockseq !== void 0 ? options.clockseq : _clockseq; + if (node == null || clockseq == null) { + const seedBytes = options.random || (options.rng || _rng.default)(); + if (node == null) { + node = _nodeId = [seedBytes[0] | 1, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; + } + if (clockseq == null) { + clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 16383; + } + } + let msecs = options.msecs !== void 0 ? options.msecs : Date.now(); + let nsecs = options.nsecs !== void 0 ? options.nsecs : _lastNSecs + 1; + const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 1e4; + if (dt < 0 && options.clockseq === void 0) { + clockseq = clockseq + 1 & 16383; + } + if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === void 0) { + nsecs = 0; + } + if (nsecs >= 1e4) { + throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); + } + _lastMSecs = msecs; + _lastNSecs = nsecs; + _clockseq = clockseq; + msecs += 122192928e5; + const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296; + b[i++] = tl >>> 24 & 255; + b[i++] = tl >>> 16 & 255; + b[i++] = tl >>> 8 & 255; + b[i++] = tl & 255; + const tmh = msecs / 4294967296 * 1e4 & 268435455; + b[i++] = tmh >>> 8 & 255; + b[i++] = tmh & 255; + b[i++] = tmh >>> 24 & 15 | 16; + b[i++] = tmh >>> 16 & 255; + b[i++] = clockseq >>> 8 | 128; + b[i++] = clockseq & 255; + for (let n = 0; n < 6; ++n) { + b[i + n] = node[n]; + } + return buf || (0, _stringify.default)(b); + } + var _default = v1; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/parse.js +var require_parse = __commonJS({ + "node_modules/uuid/dist/parse.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _validate = _interopRequireDefault(require_validate3()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function parse(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError("Invalid UUID"); + } + let v; + const arr = new Uint8Array(16); + arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; + arr[1] = v >>> 16 & 255; + arr[2] = v >>> 8 & 255; + arr[3] = v & 255; + arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; + arr[5] = v & 255; + arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; + arr[7] = v & 255; + arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; + arr[9] = v & 255; + arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255; + arr[11] = v / 4294967296 & 255; + arr[12] = v >>> 24 & 255; + arr[13] = v >>> 16 & 255; + arr[14] = v >>> 8 & 255; + arr[15] = v & 255; + return arr; + } + var _default = parse; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/v35.js +var require_v35 = __commonJS({ + "node_modules/uuid/dist/v35.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = _default; + exports2.URL = exports2.DNS = void 0; + var _stringify = _interopRequireDefault(require_stringify()); + var _parse = _interopRequireDefault(require_parse()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function stringToBytes(str) { + str = unescape(encodeURIComponent(str)); + const bytes = []; + for (let i = 0; i < str.length; ++i) { + bytes.push(str.charCodeAt(i)); + } + return bytes; + } + var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"; + exports2.DNS = DNS; + var URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"; + exports2.URL = URL; + function _default(name, version, hashfunc) { + function generateUUID(value, namespace, buf, offset) { + if (typeof value === "string") { + value = stringToBytes(value); + } + if (typeof namespace === "string") { + namespace = (0, _parse.default)(namespace); + } + if (namespace.length !== 16) { + throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)"); + } + let bytes = new Uint8Array(16 + value.length); + bytes.set(namespace); + bytes.set(value, namespace.length); + bytes = hashfunc(bytes); + bytes[6] = bytes[6] & 15 | version; + bytes[8] = bytes[8] & 63 | 128; + if (buf) { + offset = offset || 0; + for (let i = 0; i < 16; ++i) { + buf[offset + i] = bytes[i]; + } + return buf; + } + return (0, _stringify.default)(bytes); + } + try { + generateUUID.name = name; + } catch (err) { + } + generateUUID.DNS = DNS; + generateUUID.URL = URL; + return generateUUID; + } + } +}); + +// node_modules/uuid/dist/md5.js +var require_md5 = __commonJS({ + "node_modules/uuid/dist/md5.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _crypto = _interopRequireDefault(require("crypto")); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function md5(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === "string") { + bytes = Buffer.from(bytes, "utf8"); + } + return _crypto.default.createHash("md5").update(bytes).digest(); + } + var _default = md5; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/v3.js +var require_v3 = __commonJS({ + "node_modules/uuid/dist/v3.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _v = _interopRequireDefault(require_v35()); + var _md = _interopRequireDefault(require_md5()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var v3 = (0, _v.default)("v3", 48, _md.default); + var _default = v3; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/v4.js +var require_v4 = __commonJS({ + "node_modules/uuid/dist/v4.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _rng = _interopRequireDefault(require_rng()); + var _stringify = _interopRequireDefault(require_stringify()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function v4(options, buf, offset) { + options = options || {}; + const rnds = options.random || (options.rng || _rng.default)(); + rnds[6] = rnds[6] & 15 | 64; + rnds[8] = rnds[8] & 63 | 128; + if (buf) { + offset = offset || 0; + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + return buf; + } + return (0, _stringify.default)(rnds); + } + var _default = v4; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/sha1.js +var require_sha12 = __commonJS({ + "node_modules/uuid/dist/sha1.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _crypto = _interopRequireDefault(require("crypto")); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function sha1(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === "string") { + bytes = Buffer.from(bytes, "utf8"); + } + return _crypto.default.createHash("sha1").update(bytes).digest(); + } + var _default = sha1; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/v5.js +var require_v5 = __commonJS({ + "node_modules/uuid/dist/v5.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _v = _interopRequireDefault(require_v35()); + var _sha = _interopRequireDefault(require_sha12()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var v5 = (0, _v.default)("v5", 80, _sha.default); + var _default = v5; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/nil.js +var require_nil = __commonJS({ + "node_modules/uuid/dist/nil.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _default = "00000000-0000-0000-0000-000000000000"; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/version.js +var require_version2 = __commonJS({ + "node_modules/uuid/dist/version.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = void 0; + var _validate = _interopRequireDefault(require_validate3()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function version(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError("Invalid UUID"); + } + return parseInt(uuid.substr(14, 1), 16); + } + var _default = version; + exports2.default = _default; + } +}); + +// node_modules/uuid/dist/index.js +var require_dist5 = __commonJS({ + "node_modules/uuid/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { + value: true + }); + Object.defineProperty(exports2, "v1", { + enumerable: true, + get: function() { + return _v.default; + } + }); + Object.defineProperty(exports2, "v3", { + enumerable: true, + get: function() { + return _v2.default; + } + }); + Object.defineProperty(exports2, "v4", { + enumerable: true, + get: function() { + return _v3.default; + } + }); + Object.defineProperty(exports2, "v5", { + enumerable: true, + get: function() { + return _v4.default; + } + }); + Object.defineProperty(exports2, "NIL", { + enumerable: true, + get: function() { + return _nil.default; + } + }); + Object.defineProperty(exports2, "version", { + enumerable: true, + get: function() { + return _version.default; + } + }); + Object.defineProperty(exports2, "validate", { + enumerable: true, + get: function() { + return _validate.default; + } + }); + Object.defineProperty(exports2, "stringify", { + enumerable: true, + get: function() { + return _stringify.default; + } + }); + Object.defineProperty(exports2, "parse", { + enumerable: true, + get: function() { + return _parse.default; + } + }); + var _v = _interopRequireDefault(require_v1()); + var _v2 = _interopRequireDefault(require_v3()); + var _v3 = _interopRequireDefault(require_v4()); + var _v4 = _interopRequireDefault(require_v5()); + var _nil = _interopRequireDefault(require_nil()); + var _version = _interopRequireDefault(require_version2()); + var _validate = _interopRequireDefault(require_validate3()); + var _stringify = _interopRequireDefault(require_stringify()); + var _parse = _interopRequireDefault(require_parse()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + } +}); + +// node_modules/graphql-tag/node_modules/tslib/tslib.js +var require_tslib = __commonJS({ + "node_modules/graphql-tag/node_modules/tslib/tslib.js"(exports2, module2) { + var __extends; + var __assign; + var __rest; + var __decorate; + var __param; + var __metadata; + var __awaiter; + var __generator; + var __exportStar; + var __values; + var __read; + var __spread; + var __spreadArrays; + var __spreadArray; + var __await; + var __asyncGenerator; + var __asyncDelegator; + var __asyncValues; + var __makeTemplateObject; + var __importStar; + var __importDefault; + var __classPrivateFieldGet; + var __classPrivateFieldSet; + var __createBinding; + (function(factory) { + var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {}; + if (typeof define === "function" && define.amd) { + define("tslib", ["exports"], function(exports3) { + factory(createExporter(root, createExporter(exports3))); + }); + } else if (typeof module2 === "object" && typeof module2.exports === "object") { + factory(createExporter(root, createExporter(module2.exports))); + } else { + factory(createExporter(root)); + } + function createExporter(exports3, previous) { + if (exports3 !== root) { + if (typeof Object.create === "function") { + Object.defineProperty(exports3, "__esModule", { value: true }); + } else { + exports3.__esModule = true; + } + } + return function(id, v) { + return exports3[id] = previous ? previous(id, v) : v; + }; + } + })(function(exporter) { + var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) { + d.__proto__ = b; + } || function(d, b) { + for (var p in b) + if (Object.prototype.hasOwnProperty.call(b, p)) + d[p] = b[p]; + }; + __extends = function(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + __rest = function(s, e) { + var t = {}; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; + }; + __decorate = function(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + r = Reflect.decorate(decorators, target, key, desc); + else + for (var i = decorators.length - 1; i >= 0; i--) + if (d = decorators[i]) + r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + }; + __param = function(paramIndex, decorator) { + return function(target, key) { + decorator(target, key, paramIndex); + }; + }; + __metadata = function(metadataKey, metadataValue) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(metadataKey, metadataValue); + }; + __awaiter = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + __generator = function(thisArg, body) { + var _ = { label: 0, sent: function() { + if (t[0] & 1) + throw t[1]; + return t[1]; + }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { + return this; + }), g; + function verb(n) { + return function(v) { + return step([n, v]); + }; + } + function step(op) { + if (f) + throw new TypeError("Generator is already executing."); + while (_) + try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) + return t; + if (y = 0, t) + op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: + case 1: + t = op; + break; + case 4: + _.label++; + return { value: op[1], done: false }; + case 5: + _.label++; + y = op[1]; + op = [0]; + continue; + case 7: + op = _.ops.pop(); + _.trys.pop(); + continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { + _ = 0; + continue; + } + if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { + _.label = op[1]; + break; + } + if (op[0] === 6 && _.label < t[1]) { + _.label = t[1]; + t = op; + break; + } + if (t && _.label < t[2]) { + _.label = t[2]; + _.ops.push(op); + break; + } + if (t[2]) + _.ops.pop(); + _.trys.pop(); + continue; + } + op = body.call(thisArg, _); + } catch (e) { + op = [6, e]; + y = 0; + } finally { + f = t = 0; + } + if (op[0] & 5) + throw op[1]; + return { value: op[0] ? op[1] : void 0, done: true }; + } + }; + __exportStar = function(m, o) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) + __createBinding(o, m, p); + }; + __createBinding = Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }; + __values = function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) + return m.call(o); + if (o && typeof o.length === "number") + return { + next: function() { + if (o && i >= o.length) + o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); + }; + __read = function(o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) + return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) + ar.push(r.value); + } catch (error) { + e = { error }; + } finally { + try { + if (r && !r.done && (m = i["return"])) + m.call(i); + } finally { + if (e) + throw e.error; + } + } + return ar; + }; + __spread = function() { + for (var ar = [], i = 0; i < arguments.length; i++) + ar = ar.concat(__read(arguments[i])); + return ar; + }; + __spreadArrays = function() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) + s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; + }; + __spreadArray = function(to, from, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) + ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); + }; + __await = function(v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); + }; + __asyncGenerator = function(thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) + throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { + return this; + }, i; + function verb(n) { + if (g[n]) + i[n] = function(v) { + return new Promise(function(a, b) { + q.push([n, v, a, b]) > 1 || resume(n, v); + }); + }; + } + function resume(n, v) { + try { + step(g[n](v)); + } catch (e) { + settle(q[0][3], e); + } + } + function step(r) { + r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); + } + function fulfill(value) { + resume("next", value); + } + function reject(value) { + resume("throw", value); + } + function settle(f, v) { + if (f(v), q.shift(), q.length) + resume(q[0][0], q[0][1]); + } + }; + __asyncDelegator = function(o) { + var i, p; + return i = {}, verb("next"), verb("throw", function(e) { + throw e; + }), verb("return"), i[Symbol.iterator] = function() { + return this; + }, i; + function verb(n, f) { + i[n] = o[n] ? function(v) { + return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; + } : f; + } + }; + __asyncValues = function(o) { + if (!Symbol.asyncIterator) + throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { + return this; + }, i); + function verb(n) { + i[n] = o[n] && function(v) { + return new Promise(function(resolve, reject) { + v = o[n](v), settle(resolve, reject, v.done, v.value); + }); + }; + } + function settle(resolve, reject, d, v) { + Promise.resolve(v).then(function(v2) { + resolve({ value: v2, done: d }); + }, reject); + } + }; + __makeTemplateObject = function(cooked, raw) { + if (Object.defineProperty) { + Object.defineProperty(cooked, "raw", { value: raw }); + } else { + cooked.raw = raw; + } + return cooked; + }; + var __setModuleDefault = Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }; + __importStar = function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + __importDefault = function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + __classPrivateFieldGet = function(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + }; + __classPrivateFieldSet = function(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; + }; + exporter("__extends", __extends); + exporter("__assign", __assign); + exporter("__rest", __rest); + exporter("__decorate", __decorate); + exporter("__param", __param); + exporter("__metadata", __metadata); + exporter("__awaiter", __awaiter); + exporter("__generator", __generator); + exporter("__exportStar", __exportStar); + exporter("__createBinding", __createBinding); + exporter("__values", __values); + exporter("__read", __read); + exporter("__spread", __spread); + exporter("__spreadArrays", __spreadArrays); + exporter("__spreadArray", __spreadArray); + exporter("__await", __await); + exporter("__asyncGenerator", __asyncGenerator); + exporter("__asyncDelegator", __asyncDelegator); + exporter("__asyncValues", __asyncValues); + exporter("__makeTemplateObject", __makeTemplateObject); + exporter("__importStar", __importStar); + exporter("__importDefault", __importDefault); + exporter("__classPrivateFieldGet", __classPrivateFieldGet); + exporter("__classPrivateFieldSet", __classPrivateFieldSet); + }); + } +}); + +// node_modules/graphql-tag/lib/graphql-tag.umd.js +var require_graphql_tag_umd = __commonJS({ + "node_modules/graphql-tag/lib/graphql-tag.umd.js"(exports2, module2) { + (function(global2, factory) { + typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2, require_tslib(), require_graphql2()) : typeof define === "function" && define.amd ? define(["exports", "tslib", "graphql"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2["graphql-tag"] = {}, global2.tslib, global2.graphql)); + })(exports2, function(exports3, tslib, graphql) { + "use strict"; + var docCache = new Map(); + var fragmentSourceMap = new Map(); + var printFragmentWarnings = true; + var experimentalFragmentVariables = false; + function normalize(string) { + return string.replace(/[\s,]+/g, " ").trim(); + } + function cacheKeyFromLoc(loc) { + return normalize(loc.source.body.substring(loc.start, loc.end)); + } + function processFragments(ast) { + var seenKeys = new Set(); + var definitions = []; + ast.definitions.forEach(function(fragmentDefinition) { + if (fragmentDefinition.kind === "FragmentDefinition") { + var fragmentName = fragmentDefinition.name.value; + var sourceKey = cacheKeyFromLoc(fragmentDefinition.loc); + var sourceKeySet = fragmentSourceMap.get(fragmentName); + if (sourceKeySet && !sourceKeySet.has(sourceKey)) { + if (printFragmentWarnings) { + console.warn("Warning: fragment with name " + fragmentName + " already exists.\ngraphql-tag enforces all fragment names across your application to be unique; read more about\nthis in the docs: http://dev.apollodata.com/core/fragments.html#unique-names"); + } + } else if (!sourceKeySet) { + fragmentSourceMap.set(fragmentName, sourceKeySet = new Set()); + } + sourceKeySet.add(sourceKey); + if (!seenKeys.has(sourceKey)) { + seenKeys.add(sourceKey); + definitions.push(fragmentDefinition); + } + } else { + definitions.push(fragmentDefinition); + } + }); + return tslib.__assign(tslib.__assign({}, ast), { definitions }); + } + function stripLoc(doc) { + var workSet = new Set(doc.definitions); + workSet.forEach(function(node) { + if (node.loc) + delete node.loc; + Object.keys(node).forEach(function(key) { + var value = node[key]; + if (value && typeof value === "object") { + workSet.add(value); + } + }); + }); + var loc = doc.loc; + if (loc) { + delete loc.startToken; + delete loc.endToken; + } + return doc; + } + function parseDocument(source) { + var cacheKey = normalize(source); + if (!docCache.has(cacheKey)) { + var parsed = graphql.parse(source, { + experimentalFragmentVariables, + allowLegacyFragmentVariables: experimentalFragmentVariables + }); + if (!parsed || parsed.kind !== "Document") { + throw new Error("Not a valid GraphQL document."); + } + docCache.set(cacheKey, stripLoc(processFragments(parsed))); + } + return docCache.get(cacheKey); + } + function gql2(literals) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + if (typeof literals === "string") { + literals = [literals]; + } + var result = literals[0]; + args.forEach(function(arg, i) { + if (arg && arg.kind === "Document") { + result += arg.loc.source.body; + } else { + result += arg; + } + result += literals[i + 1]; + }); + return parseDocument(result); + } + function resetCaches() { + docCache.clear(); + fragmentSourceMap.clear(); + } + function disableFragmentWarnings() { + printFragmentWarnings = false; + } + function enableExperimentalFragmentVariables() { + experimentalFragmentVariables = true; + } + function disableExperimentalFragmentVariables() { + experimentalFragmentVariables = false; + } + var extras = { + gql: gql2, + resetCaches, + disableFragmentWarnings, + enableExperimentalFragmentVariables, + disableExperimentalFragmentVariables + }; + (function(gql_1) { + gql_1.gql = extras.gql, gql_1.resetCaches = extras.resetCaches, gql_1.disableFragmentWarnings = extras.disableFragmentWarnings, gql_1.enableExperimentalFragmentVariables = extras.enableExperimentalFragmentVariables, gql_1.disableExperimentalFragmentVariables = extras.disableExperimentalFragmentVariables; + })(gql2 || (gql2 = {})); + gql2["default"] = gql2; + var gql$1 = gql2; + exports3.default = gql$1; + exports3.disableExperimentalFragmentVariables = disableExperimentalFragmentVariables; + exports3.disableFragmentWarnings = disableFragmentWarnings; + exports3.enableExperimentalFragmentVariables = enableExperimentalFragmentVariables; + exports3.gql = gql2; + exports3.resetCaches = resetCaches; + Object.defineProperty(exports3, "__esModule", { value: true }); + }); + } +}); + +// node_modules/graphql-tag/main.js +var require_main = __commonJS({ + "node_modules/graphql-tag/main.js"(exports2, module2) { + module2.exports = require_graphql_tag_umd().gql; + } +}); + +// node_modules/apollo-server-core/dist/gql.js +var require_gql = __commonJS({ + "node_modules/apollo-server-core/dist/gql.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.gql = void 0; + var graphql_tag_1 = __importDefault(require_main()); + exports2.gql = graphql_tag_1.default; + } +}); + +// node_modules/apollo-server-core/package.json +var require_package = __commonJS({ + "node_modules/apollo-server-core/package.json"(exports2, module2) { + module2.exports = { + name: "apollo-server-core", + version: "3.6.3", + description: "Core engine for Apollo GraphQL server", + main: "dist/index.js", + types: "dist/index.d.ts", + repository: { + type: "git", + url: "https://github.com/apollographql/apollo-server", + directory: "packages/apollo-server-core" + }, + keywords: [ + "GraphQL", + "Apollo", + "Server", + "Javascript" + ], + author: "Apollo ", + license: "MIT", + bugs: { + url: "https://github.com/apollographql/apollo-server/issues" + }, + homepage: "https://github.com/apollographql/apollo-server#readme", + engines: { + node: ">=12.0" + }, + dependencies: { + "@apollographql/apollo-tools": "^0.5.1", + "@apollographql/graphql-playground-html": "1.6.29", + "@graphql-tools/mock": "^8.1.2", + "@graphql-tools/schema": "^8.0.0", + "@josephg/resolvable": "^1.0.0", + "apollo-datasource": "^3.3.1", + "apollo-reporting-protobuf": "^3.3.0", + "apollo-server-caching": "^3.3.0", + "apollo-server-env": "^4.2.1", + "apollo-server-errors": "^3.3.1", + "apollo-server-plugin-base": "^3.5.1", + "apollo-server-types": "^3.5.1", + "async-retry": "^1.2.1", + "fast-json-stable-stringify": "^2.1.0", + "graphql-tag": "^2.11.0", + "lodash.sortby": "^4.7.0", + loglevel: "^1.6.8", + "lru-cache": "^6.0.0", + "sha.js": "^2.4.11", + uuid: "^8.0.0" + }, + peerDependencies: { + graphql: "^15.3.0 || ^16.0.0" + }, + gitHead: "289acad0e3777bd0010506763c3fd6e4c0289813" + }; + } +}); + +// node_modules/apollo-server-core/dist/plugin/schemaReporting/schemaReporter.js +var require_schemaReporter = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/schemaReporting/schemaReporter.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SchemaReporter = exports2.schemaReportGql = void 0; + var gql_1 = require_gql(); + var apollo_server_env_1 = require_dist(); + var graphql_1 = require_graphql2(); + exports2.schemaReportGql = (0, graphql_1.print)((0, gql_1.gql)` + mutation SchemaReport($report: SchemaReport!, $coreSchema: String) { + reportSchema(report: $report, coreSchema: $coreSchema) { + __typename + ... on ReportSchemaError { + message + code + } + ... on ReportSchemaResponse { + inSeconds + withCoreSchema + } + } + } +`); + var SchemaReporter = class { + constructor(options) { + var _a; + this.headers = new apollo_server_env_1.Headers(); + this.headers.set("Content-Type", "application/json"); + this.headers.set("x-api-key", options.apiKey); + this.headers.set("apollographql-client-name", "ApolloServerPluginSchemaReporting"); + this.headers.set("apollographql-client-version", require_package().version); + this.endpointUrl = options.endpointUrl || "https://schema-reporting.api.apollographql.com/api/graphql"; + this.schemaReport = options.schemaReport; + this.coreSchema = options.coreSchema; + this.isStopped = false; + this.logger = options.logger; + this.initialReportingDelayInMs = options.initialReportingDelayInMs; + this.fallbackReportingDelayInMs = options.fallbackReportingDelayInMs; + this.fetcher = (_a = options.fetcher) !== null && _a !== void 0 ? _a : apollo_server_env_1.fetch; + } + stopped() { + return this.isStopped; + } + start() { + this.pollTimer = setTimeout(() => this.sendOneReportAndScheduleNext(false), this.initialReportingDelayInMs); + } + stop() { + this.isStopped = true; + if (this.pollTimer) { + clearTimeout(this.pollTimer); + this.pollTimer = void 0; + } + } + async sendOneReportAndScheduleNext(sendNextWithCoreSchema) { + this.pollTimer = void 0; + if (this.stopped()) + return; + try { + const result = await this.reportSchema(sendNextWithCoreSchema); + if (!result) { + return; + } + if (!this.stopped()) { + this.pollTimer = setTimeout(() => this.sendOneReportAndScheduleNext(result.withCoreSchema), result.inSeconds * 1e3); + } + return; + } catch (error) { + this.logger.error(`Error reporting server info to Apollo during schema reporting: ${error}`); + if (!this.stopped()) { + this.pollTimer = setTimeout(() => this.sendOneReportAndScheduleNext(false), this.fallbackReportingDelayInMs); + } + } + } + async reportSchema(withCoreSchema) { + const { data, errors } = await this.apolloQuery({ + report: this.schemaReport, + coreSchema: withCoreSchema ? this.coreSchema : null + }); + if (errors) { + throw new Error(errors.map((x) => x.message).join("\n")); + } + function msgForUnexpectedResponse(data2) { + return [ + "Unexpected response shape from Apollo when", + "reporting schema. If this continues, please reach", + "out to support@apollographql.com.", + "Received response:", + JSON.stringify(data2) + ].join(" "); + } + if (!data || !data.reportSchema) { + throw new Error(msgForUnexpectedResponse(data)); + } + if (data.reportSchema.__typename === "ReportSchemaResponse") { + return data.reportSchema; + } else if (data.reportSchema.__typename === "ReportSchemaError") { + this.logger.error([ + "Received input validation error from Apollo:", + data.reportSchema.message, + "Stopping reporting. Please fix the input errors." + ].join(" ")); + this.stop(); + return null; + } + throw new Error(msgForUnexpectedResponse(data)); + } + async apolloQuery(variables) { + const request = { + query: exports2.schemaReportGql, + variables + }; + const httpRequest = new apollo_server_env_1.Request(this.endpointUrl, { + method: "POST", + headers: this.headers, + body: JSON.stringify(request) + }); + const httpResponse = await this.fetcher(httpRequest); + if (!httpResponse.ok) { + throw new Error([ + `An unexpected HTTP status code (${httpResponse.status}) was`, + "encountered during schema reporting." + ].join(" ")); + } + try { + return await httpResponse.json(); + } catch (error) { + throw new Error([ + "Couldn't report schema to Apollo.", + "Parsing response as JSON failed.", + "If this continues please reach out to support@apollographql.com", + error + ].join(" ")); + } + } + }; + exports2.SchemaReporter = SchemaReporter; + } +}); + +// node_modules/apollo-server-core/dist/plugin/schemaIsFederated.js +var require_schemaIsFederated = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/schemaIsFederated.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.schemaIsFederated = void 0; + var graphql_1 = require_graphql2(); + function schemaIsFederated(schema2) { + const serviceType = schema2.getType("_Service"); + if (!(0, graphql_1.isObjectType)(serviceType)) { + return false; + } + const sdlField = serviceType.getFields().sdl; + if (!sdlField) { + return false; + } + const sdlFieldType = sdlField.type; + if (!(0, graphql_1.isScalarType)(sdlFieldType)) { + return false; + } + return sdlFieldType.name == "String"; + } + exports2.schemaIsFederated = schemaIsFederated; + } +}); + +// node_modules/apollo-server-core/dist/plugin/schemaReporting/index.js +var require_schemaReporting = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/schemaReporting/index.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.computeCoreSchemaHash = exports2.ApolloServerPluginSchemaReporting = void 0; + var os_1 = __importDefault(require("os")); + var uuid_1 = require_dist5(); + var graphql_1 = require_graphql2(); + var schemaReporter_1 = require_schemaReporter(); + var createSHA_1 = __importDefault(require_createSHA()); + var schemaIsFederated_1 = require_schemaIsFederated(); + function ApolloServerPluginSchemaReporting({ initialDelayMaxMs, overrideReportedSchema, endpointUrl, fetcher } = Object.create(null)) { + const bootId = (0, uuid_1.v4)(); + return { + __internal_plugin_id__() { + return "SchemaReporting"; + }, + async serverWillStart({ apollo, schema: schema2, logger }) { + const { key, graphRef } = apollo; + if (!key) { + throw Error("To use ApolloServerPluginSchemaReporting, you must provide an Apollo API key, via the APOLLO_KEY environment variable or via `new ApolloServer({apollo: {key})`"); + } + if (!graphRef) { + throw Error("To use ApolloServerPluginSchemaReporting, you must provide your graph ref (eg, 'my-graph-id@my-graph-variant'). Try setting the APOLLO_GRAPH_REF environment variable or passing `new ApolloServer({apollo: {graphRef}})`."); + } + if (overrideReportedSchema) { + try { + const validationErrors = (0, graphql_1.validateSchema)((0, graphql_1.buildSchema)(overrideReportedSchema, { noLocation: true })); + if (validationErrors.length) { + throw new Error(validationErrors.map((error) => error.message).join("\n")); + } + } catch (err) { + throw new Error(`The schema provided to overrideReportedSchema failed to parse or validate: ${err.message}`); + } + } + if ((0, schemaIsFederated_1.schemaIsFederated)(schema2)) { + throw Error([ + "Schema reporting is not yet compatible with federated services.", + "If you're interested in using schema reporting with federated", + "services, please contact Apollo support. To set up managed federation, see", + "https://go.apollo.dev/s/managed-federation" + ].join(" ")); + } + if (endpointUrl !== void 0) { + logger.info(`Apollo schema reporting: schema reporting URL override: ${endpointUrl}`); + } + const baseSchemaReport = { + bootId, + graphRef, + platform: process.env.APOLLO_SERVER_PLATFORM || "local", + runtimeVersion: `node ${process.version}`, + userVersion: process.env.APOLLO_SERVER_USER_VERSION, + serverId: process.env.APOLLO_SERVER_ID || process.env.HOSTNAME || os_1.default.hostname(), + libraryVersion: `apollo-server-core@${require_package().version}` + }; + let currentSchemaReporter; + return { + schemaDidLoadOrUpdate({ apiSchema, coreSupergraphSdl }) { + var _a; + if (overrideReportedSchema !== void 0) { + if (currentSchemaReporter) { + return; + } else { + logger.info("Apollo schema reporting: schema to report has been overridden"); + } + } + const coreSchema = (_a = overrideReportedSchema !== null && overrideReportedSchema !== void 0 ? overrideReportedSchema : coreSupergraphSdl) !== null && _a !== void 0 ? _a : (0, graphql_1.printSchema)(apiSchema); + const coreSchemaHash = computeCoreSchemaHash(coreSchema); + const schemaReport = __spreadProps(__spreadValues({}, baseSchemaReport), { + coreSchemaHash + }); + currentSchemaReporter === null || currentSchemaReporter === void 0 ? void 0 : currentSchemaReporter.stop(); + currentSchemaReporter = new schemaReporter_1.SchemaReporter({ + schemaReport, + coreSchema, + apiKey: key, + endpointUrl, + logger, + initialReportingDelayInMs: Math.floor(Math.random() * (initialDelayMaxMs !== null && initialDelayMaxMs !== void 0 ? initialDelayMaxMs : 1e4)), + fallbackReportingDelayInMs: 2e4, + fetcher + }); + currentSchemaReporter.start(); + logger.info(`Apollo schema reporting: reporting a new schema to Studio! See your graph at https://studio.apollographql.com/graph/${encodeURI(graphRef)}/ with server info ${JSON.stringify(schemaReport)}`); + }, + async serverWillStop() { + currentSchemaReporter === null || currentSchemaReporter === void 0 ? void 0 : currentSchemaReporter.stop(); + } + }; + } + }; + } + exports2.ApolloServerPluginSchemaReporting = ApolloServerPluginSchemaReporting; + function computeCoreSchemaHash(schema2) { + return (0, createSHA_1.default)("sha256").update(schema2).digest("hex"); + } + exports2.computeCoreSchemaHash = computeCoreSchemaHash; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/durationHistogram.js +var require_durationHistogram = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/durationHistogram.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DurationHistogram = void 0; + var DurationHistogram = class { + constructor(options) { + const initSize = (options === null || options === void 0 ? void 0 : options.initSize) || 74; + const buckets = options === null || options === void 0 ? void 0 : options.buckets; + const arrayInitSize = Math.max((buckets === null || buckets === void 0 ? void 0 : buckets.length) || 0, initSize); + this.buckets = Array(arrayInitSize).fill(0); + if (buckets) { + buckets.forEach((val, index) => this.buckets[index] = val); + } + } + toArray() { + let bufferedZeroes = 0; + const outputArray = []; + for (const value of this.buckets) { + if (value === 0) { + bufferedZeroes++; + } else { + if (bufferedZeroes === 1) { + outputArray.push(0); + } else if (bufferedZeroes !== 0) { + outputArray.push(-bufferedZeroes); + } + outputArray.push(Math.floor(value)); + bufferedZeroes = 0; + } + } + return outputArray; + } + static durationToBucket(durationNs) { + const log2 = Math.log(durationNs / 1e3); + const unboundedBucket = Math.ceil(log2 / DurationHistogram.EXPONENT_LOG); + return unboundedBucket <= 0 || Number.isNaN(unboundedBucket) ? 0 : unboundedBucket >= DurationHistogram.BUCKET_COUNT ? DurationHistogram.BUCKET_COUNT - 1 : unboundedBucket; + } + incrementDuration(durationNs, value = 1) { + this.incrementBucket(DurationHistogram.durationToBucket(durationNs), value); + return this; + } + incrementBucket(bucket, value = 1) { + if (bucket >= DurationHistogram.BUCKET_COUNT) { + throw Error("Bucket is out of bounds of the buckets array"); + } + if (bucket >= this.buckets.length) { + const oldLength = this.buckets.length; + this.buckets.length = bucket + 1; + this.buckets.fill(0, oldLength); + } + this.buckets[bucket] += value; + } + combine(otherHistogram) { + for (let i = 0; i < otherHistogram.buckets.length; i++) { + this.incrementBucket(i, otherHistogram.buckets[i]); + } + } + }; + exports2.DurationHistogram = DurationHistogram; + DurationHistogram.BUCKET_COUNT = 384; + DurationHistogram.EXPONENT_LOG = Math.log(1.1); + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/iterateOverTrace.js +var require_iterateOverTrace = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/iterateOverTrace.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.iterateOverTrace = void 0; + function iterateOverTrace(trace, f, includePath) { + const rootPath = includePath ? new RootCollectingPathsResponseNamePath() : notCollectingPathsResponseNamePath; + if (trace.root) { + if (iterateOverTraceNode(trace.root, rootPath, f)) + return; + } + if (trace.queryPlan) { + if (iterateOverQueryPlan(trace.queryPlan, rootPath, f)) + return; + } + } + exports2.iterateOverTrace = iterateOverTrace; + function iterateOverQueryPlan(node, rootPath, f) { + var _a, _b, _c, _d, _e; + if (!node) + return false; + if (((_b = (_a = node.fetch) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.root) && node.fetch.serviceName) { + return iterateOverTraceNode(node.fetch.trace.root, rootPath.child(`service:${node.fetch.serviceName}`), f); + } + if ((_c = node.flatten) === null || _c === void 0 ? void 0 : _c.node) { + return iterateOverQueryPlan(node.flatten.node, rootPath, f); + } + if ((_d = node.parallel) === null || _d === void 0 ? void 0 : _d.nodes) { + return node.parallel.nodes.some((node2) => iterateOverQueryPlan(node2, rootPath, f)); + } + if ((_e = node.sequence) === null || _e === void 0 ? void 0 : _e.nodes) { + return node.sequence.nodes.some((node2) => iterateOverQueryPlan(node2, rootPath, f)); + } + return false; + } + function iterateOverTraceNode(node, path, f) { + var _a, _b; + if (f(node, path)) { + return true; + } + return (_b = (_a = node.child) === null || _a === void 0 ? void 0 : _a.some((child) => { + const childPath = child.responseName ? path.child(child.responseName) : path; + return iterateOverTraceNode(child, childPath, f); + })) !== null && _b !== void 0 ? _b : false; + } + var notCollectingPathsResponseNamePath = { + toArray() { + throw Error("not collecting paths!"); + }, + child() { + return this; + } + }; + var RootCollectingPathsResponseNamePath = class { + toArray() { + return []; + } + child(responseName) { + return new ChildCollectingPathsResponseNamePath(responseName, this); + } + }; + var ChildCollectingPathsResponseNamePath = class { + constructor(responseName, prev) { + this.responseName = responseName; + this.prev = prev; + } + toArray() { + const out = []; + let curr = this; + while (curr instanceof ChildCollectingPathsResponseNamePath) { + out.push(curr.responseName); + curr = curr.prev; + } + return out.reverse(); + } + child(responseName) { + return new ChildCollectingPathsResponseNamePath(responseName, this); + } + }; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/stats.js +var require_stats = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/stats.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.OurContextualizedStats = exports2.OurReport = exports2.SizeEstimator = void 0; + var durationHistogram_1 = require_durationHistogram(); + var apollo_reporting_protobuf_1 = require_generated(); + var iterateOverTrace_1 = require_iterateOverTrace(); + var SizeEstimator = class { + constructor() { + this.bytes = 0; + } + }; + exports2.SizeEstimator = SizeEstimator; + var OurReport = class { + constructor(header) { + this.header = header; + this.tracesPerQuery = Object.create(null); + this.endTime = null; + this.sizeEstimator = new SizeEstimator(); + } + ensureCountsAreIntegers() { + for (const tracesAndStats of Object.values(this.tracesPerQuery)) { + tracesAndStats.ensureCountsAreIntegers(); + } + } + addTrace({ statsReportKey, trace, asTrace, includeTracesContributingToStats, referencedFieldsByType }) { + const tracesAndStats = this.getTracesAndStats({ + statsReportKey, + referencedFieldsByType + }); + if (asTrace) { + const encodedTrace = apollo_reporting_protobuf_1.Trace.encode(trace).finish(); + tracesAndStats.trace.push(encodedTrace); + this.sizeEstimator.bytes += 2 + encodedTrace.length; + } else { + tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator); + if (includeTracesContributingToStats) { + const encodedTrace = apollo_reporting_protobuf_1.Trace.encode(trace).finish(); + tracesAndStats.internalTracesContributingToStats.push(encodedTrace); + this.sizeEstimator.bytes += 2 + encodedTrace.length; + } + } + } + getTracesAndStats({ statsReportKey, referencedFieldsByType }) { + const existing = this.tracesPerQuery[statsReportKey]; + if (existing) { + return existing; + } + this.sizeEstimator.bytes += estimatedBytesForString(statsReportKey); + for (const [typeName, referencedFieldsForType] of Object.entries(referencedFieldsByType)) { + this.sizeEstimator.bytes += 2 + 2; + if (referencedFieldsForType.isInterface) { + this.sizeEstimator.bytes += 2; + } + this.sizeEstimator.bytes += estimatedBytesForString(typeName); + for (const fieldName of referencedFieldsForType.fieldNames) { + this.sizeEstimator.bytes += estimatedBytesForString(fieldName); + } + } + return this.tracesPerQuery[statsReportKey] = new OurTracesAndStats(referencedFieldsByType); + } + }; + exports2.OurReport = OurReport; + var OurTracesAndStats = class { + constructor(referencedFieldsByType) { + this.referencedFieldsByType = referencedFieldsByType; + this.trace = []; + this.statsWithContext = new StatsByContext(); + this.internalTracesContributingToStats = []; + } + ensureCountsAreIntegers() { + this.statsWithContext.ensureCountsAreIntegers(); + } + }; + var StatsByContext = class { + constructor() { + this.map = Object.create(null); + } + toArray() { + return Object.values(this.map); + } + ensureCountsAreIntegers() { + for (const contextualizedStats of Object.values(this.map)) { + contextualizedStats.ensureCountsAreIntegers(); + } + } + addTrace(trace, sizeEstimator) { + this.getContextualizedStats(trace, sizeEstimator).addTrace(trace, sizeEstimator); + } + getContextualizedStats(trace, sizeEstimator) { + const statsContext = { + clientName: trace.clientName, + clientVersion: trace.clientVersion + }; + const statsContextKey = JSON.stringify(statsContext); + const existing = this.map[statsContextKey]; + if (existing) { + return existing; + } + sizeEstimator.bytes += 20 + estimatedBytesForString(trace.clientName) + estimatedBytesForString(trace.clientVersion); + const contextualizedStats = new OurContextualizedStats(statsContext); + this.map[statsContextKey] = contextualizedStats; + return contextualizedStats; + } + }; + var OurContextualizedStats = class { + constructor(context) { + this.context = context; + this.queryLatencyStats = new OurQueryLatencyStats(); + this.perTypeStat = Object.create(null); + } + ensureCountsAreIntegers() { + for (const typeStat of Object.values(this.perTypeStat)) { + typeStat.ensureCountsAreIntegers(); + } + } + addTrace(trace, sizeEstimator) { + var _a; + const { fieldExecutionWeight } = trace; + if (!fieldExecutionWeight) { + this.queryLatencyStats.requestsWithoutFieldInstrumentation++; + } + this.queryLatencyStats.requestCount++; + if (trace.fullQueryCacheHit) { + this.queryLatencyStats.cacheLatencyCount.incrementDuration(trace.durationNs); + this.queryLatencyStats.cacheHits++; + } else { + this.queryLatencyStats.latencyCount.incrementDuration(trace.durationNs); + } + if (!trace.fullQueryCacheHit && ((_a = trace.cachePolicy) === null || _a === void 0 ? void 0 : _a.maxAgeNs) != null) { + switch (trace.cachePolicy.scope) { + case apollo_reporting_protobuf_1.Trace.CachePolicy.Scope.PRIVATE: + this.queryLatencyStats.privateCacheTtlCount.incrementDuration(trace.cachePolicy.maxAgeNs); + break; + case apollo_reporting_protobuf_1.Trace.CachePolicy.Scope.PUBLIC: + this.queryLatencyStats.publicCacheTtlCount.incrementDuration(trace.cachePolicy.maxAgeNs); + break; + } + } + if (trace.persistedQueryHit) { + this.queryLatencyStats.persistedQueryHits++; + } + if (trace.persistedQueryRegister) { + this.queryLatencyStats.persistedQueryMisses++; + } + if (trace.forbiddenOperation) { + this.queryLatencyStats.forbiddenOperationCount++; + } + if (trace.registeredOperation) { + this.queryLatencyStats.registeredOperationCount++; + } + let hasError = false; + const traceNodeStats = (node, path) => { + var _a2, _b, _c, _d, _e; + if ((_a2 = node.error) === null || _a2 === void 0 ? void 0 : _a2.length) { + hasError = true; + let currPathErrorStats = this.queryLatencyStats.rootErrorStats; + path.toArray().forEach((subPath) => { + currPathErrorStats = currPathErrorStats.getChild(subPath, sizeEstimator); + }); + currPathErrorStats.requestsWithErrorsCount += 1; + currPathErrorStats.errorsCount += node.error.length; + } + if (fieldExecutionWeight) { + const fieldName = node.originalFieldName || node.responseName; + if (node.parentType && fieldName && node.type && node.endTime != null && node.startTime != null && node.endTime >= node.startTime) { + const typeStat = this.getTypeStat(node.parentType, sizeEstimator); + const fieldStat = typeStat.getFieldStat(fieldName, node.type, sizeEstimator); + fieldStat.errorsCount += (_c = (_b = node.error) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0; + fieldStat.observedExecutionCount++; + fieldStat.estimatedExecutionCount += fieldExecutionWeight; + fieldStat.requestsWithErrorsCount += ((_e = (_d = node.error) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0) > 0 ? 1 : 0; + fieldStat.latencyCount.incrementDuration(node.endTime - node.startTime, fieldExecutionWeight); + } + } + return false; + }; + (0, iterateOverTrace_1.iterateOverTrace)(trace, traceNodeStats, true); + if (hasError) { + this.queryLatencyStats.requestsWithErrorsCount++; + } + } + getTypeStat(parentType, sizeEstimator) { + const existing = this.perTypeStat[parentType]; + if (existing) { + return existing; + } + sizeEstimator.bytes += estimatedBytesForString(parentType); + const typeStat = new OurTypeStat(); + this.perTypeStat[parentType] = typeStat; + return typeStat; + } + }; + exports2.OurContextualizedStats = OurContextualizedStats; + var OurQueryLatencyStats = class { + constructor() { + this.latencyCount = new durationHistogram_1.DurationHistogram(); + this.requestCount = 0; + this.requestsWithoutFieldInstrumentation = 0; + this.cacheHits = 0; + this.persistedQueryHits = 0; + this.persistedQueryMisses = 0; + this.cacheLatencyCount = new durationHistogram_1.DurationHistogram(); + this.rootErrorStats = new OurPathErrorStats(); + this.requestsWithErrorsCount = 0; + this.publicCacheTtlCount = new durationHistogram_1.DurationHistogram(); + this.privateCacheTtlCount = new durationHistogram_1.DurationHistogram(); + this.registeredOperationCount = 0; + this.forbiddenOperationCount = 0; + } + }; + var OurPathErrorStats = class { + constructor() { + this.children = Object.create(null); + this.errorsCount = 0; + this.requestsWithErrorsCount = 0; + } + getChild(subPath, sizeEstimator) { + const existing = this.children[subPath]; + if (existing) { + return existing; + } + const child = new OurPathErrorStats(); + this.children[subPath] = child; + sizeEstimator.bytes += estimatedBytesForString(subPath) + 4; + return child; + } + }; + var OurTypeStat = class { + constructor() { + this.perFieldStat = Object.create(null); + } + getFieldStat(fieldName, returnType, sizeEstimator) { + const existing = this.perFieldStat[fieldName]; + if (existing) { + return existing; + } + sizeEstimator.bytes += estimatedBytesForString(fieldName) + estimatedBytesForString(returnType) + 10; + const fieldStat = new OurFieldStat(returnType); + this.perFieldStat[fieldName] = fieldStat; + return fieldStat; + } + ensureCountsAreIntegers() { + for (const fieldStat of Object.values(this.perFieldStat)) { + fieldStat.ensureCountsAreIntegers(); + } + } + }; + var OurFieldStat = class { + constructor(returnType) { + this.returnType = returnType; + this.errorsCount = 0; + this.observedExecutionCount = 0; + this.estimatedExecutionCount = 0; + this.requestsWithErrorsCount = 0; + this.latencyCount = new durationHistogram_1.DurationHistogram(); + } + ensureCountsAreIntegers() { + this.estimatedExecutionCount = Math.floor(this.estimatedExecutionCount); + } + }; + function estimatedBytesForString(s) { + return 2 + Buffer.byteLength(s); + } + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/defaultSendOperationsAsTrace.js +var require_defaultSendOperationsAsTrace = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/defaultSendOperationsAsTrace.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.defaultSendOperationsAsTrace = void 0; + var lru_cache_1 = __importDefault(require_lru_cache()); + var iterateOverTrace_1 = require_iterateOverTrace(); + var durationHistogram_1 = require_durationHistogram(); + function defaultSendOperationsAsTrace() { + const cache = new lru_cache_1.default({ + max: Math.pow(2, 20), + length: (_val, key) => { + return key && Buffer.byteLength(key) || 0; + } + }); + return (trace, statsReportKey) => { + var _a; + const endTimeSeconds = (_a = trace.endTime) === null || _a === void 0 ? void 0 : _a.seconds; + if (endTimeSeconds == null) { + throw Error("programming error: endTime not set on trace"); + } + const hasErrors = traceHasErrors(trace); + const cacheKey = JSON.stringify([ + statsReportKey, + durationHistogram_1.DurationHistogram.durationToBucket(trace.durationNs), + Math.floor(endTimeSeconds / 60), + hasErrors ? Math.floor(endTimeSeconds / 5) : "" + ]); + if (cache.get(cacheKey)) { + return false; + } + cache.set(cacheKey, true); + return true; + }; + } + exports2.defaultSendOperationsAsTrace = defaultSendOperationsAsTrace; + function traceHasErrors(trace) { + let hasErrors = false; + function traceNodeStats(node) { + var _a, _b; + if (((_b = (_a = node.error) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) { + hasErrors = true; + } + return hasErrors; + } + (0, iterateOverTrace_1.iterateOverTrace)(trace, traceNodeStats, false); + return hasErrors; + } + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/referencedFields.js +var require_referencedFields = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/referencedFields.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.calculateReferencedFieldsByType = void 0; + var graphql_1 = require_graphql2(); + var apollo_reporting_protobuf_1 = require_generated(); + function calculateReferencedFieldsByType({ document: document2, schema: schema2, resolvedOperationName }) { + const documentSeparatedByOperation = (0, graphql_1.separateOperations)(document2); + const filteredDocument = documentSeparatedByOperation[resolvedOperationName !== null && resolvedOperationName !== void 0 ? resolvedOperationName : ""]; + if (!filteredDocument) { + throw Error(`shouldn't happen: operation '${resolvedOperationName !== null && resolvedOperationName !== void 0 ? resolvedOperationName : ""}' not found`); + } + const typeInfo = new graphql_1.TypeInfo(schema2); + const interfaces = new Set(); + const referencedFieldSetByType = Object.create(null); + (0, graphql_1.visit)(filteredDocument, (0, graphql_1.visitWithTypeInfo)(typeInfo, { + Field(field) { + const fieldName = field.name.value; + const parentType = typeInfo.getParentType(); + if (!parentType) { + throw Error(`shouldn't happen: missing parent type for field ${fieldName}`); + } + const parentTypeName = parentType.name; + if (!referencedFieldSetByType[parentTypeName]) { + referencedFieldSetByType[parentTypeName] = new Set(); + if ((0, graphql_1.isInterfaceType)(parentType)) { + interfaces.add(parentTypeName); + } + } + referencedFieldSetByType[parentTypeName].add(fieldName); + } + })); + const referencedFieldsByType = Object.create(null); + for (const [typeName, fieldNames] of Object.entries(referencedFieldSetByType)) { + referencedFieldsByType[typeName] = new apollo_reporting_protobuf_1.ReferencedFieldsForType({ + fieldNames: [...fieldNames], + isInterface: interfaces.has(typeName) + }); + } + return referencedFieldsByType; + } + exports2.calculateReferencedFieldsByType = calculateReferencedFieldsByType; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/plugin.js +var require_plugin = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/plugin.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ApolloServerPluginUsageReportingDisabled = exports2.makeHTTPRequestHeaders = exports2.ApolloServerPluginUsageReporting = void 0; + var os_1 = __importDefault(require("os")); + var zlib_1 = require("zlib"); + var async_retry_1 = __importDefault(require_lib4()); + var apollo_reporting_protobuf_1 = require_generated(); + var apollo_server_env_1 = require_dist(); + var apollo_server_types_1 = require_dist4(); + var operationDerivedDataCache_1 = require_operationDerivedDataCache(); + var defaultUsageReportingSignature_1 = require_defaultUsageReportingSignature(); + var traceTreeBuilder_1 = require_traceTreeBuilder(); + var traceDetails_1 = require_traceDetails(); + var graphql_1 = require_graphql2(); + var schemaReporting_1 = require_schemaReporting(); + var stats_1 = require_stats(); + var defaultSendOperationsAsTrace_1 = require_defaultSendOperationsAsTrace(); + var referencedFields_1 = require_referencedFields(); + var reportHeaderDefaults = { + hostname: os_1.default.hostname(), + agentVersion: `apollo-server-core@${require_package().version}`, + runtimeVersion: `node ${process.version}`, + uname: `${os_1.default.platform()}, ${os_1.default.type()}, ${os_1.default.release()}, ${os_1.default.arch()})` + }; + var ReportData = class { + constructor(executableSchemaId, graphRef) { + this.header = new apollo_reporting_protobuf_1.ReportHeader(__spreadProps(__spreadValues({}, reportHeaderDefaults), { + executableSchemaId, + graphRef + })); + this.reset(); + } + reset() { + this.report = new stats_1.OurReport(this.header); + } + }; + function ApolloServerPluginUsageReporting(options = Object.create(null)) { + const fieldLevelInstrumentationOption = options.fieldLevelInstrumentation; + const fieldLevelInstrumentation = typeof fieldLevelInstrumentationOption === "number" ? async () => Math.random() < fieldLevelInstrumentationOption ? 1 / fieldLevelInstrumentationOption : 0 : fieldLevelInstrumentationOption ? fieldLevelInstrumentationOption : async () => true; + let requestDidStartHandler; + return { + __internal_plugin_id__() { + return "UsageReporting"; + }, + async requestDidStart(requestContext) { + if (!requestDidStartHandler) { + throw Error("The usage reporting plugin has been asked to handle a request before the server has started. See https://github.com/apollographql/apollo-server/issues/4588 for more details."); + } + return requestDidStartHandler(requestContext); + }, + async serverWillStart({ logger: serverLogger, apollo, serverlessFramework }) { + var _a, _b, _c, _d; + const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : serverLogger; + const { key, graphRef } = apollo; + if (!(key && graphRef)) { + throw new Error("You've enabled usage reporting via ApolloServerPluginUsageReporting, but you also need to provide your Apollo API key and graph ref, via the APOLLO_KEY/APOLLO_GRAPH_REF environment variables or via `new ApolloServer({apollo: {key, graphRef})`."); + } + logger.info(`Apollo usage reporting starting! See your graph at https://studio.apollographql.com/graph/${encodeURI(graphRef)}/`); + const sendReportsImmediately = (_b = options.sendReportsImmediately) !== null && _b !== void 0 ? _b : serverlessFramework; + let operationDerivedDataCache = null; + const reportDataByExecutableSchemaId = Object.create(null); + const overriddenExecutableSchemaId = options.overrideReportedSchema ? (0, schemaReporting_1.computeCoreSchemaHash)(options.overrideReportedSchema) : void 0; + let lastSeenExecutableSchemaToId; + let reportTimer; + if (!sendReportsImmediately) { + reportTimer = setInterval(() => sendAllReportsAndReportErrors(), options.reportIntervalMs || 10 * 1e3); + } + let graphMightSupportTraces = true; + const sendOperationAsTrace = (_c = options.experimental_sendOperationAsTrace) !== null && _c !== void 0 ? _c : (0, defaultSendOperationsAsTrace_1.defaultSendOperationsAsTrace)(); + const includeTracesContributingToStats = (_d = options.internal_includeTracesContributingToStats) !== null && _d !== void 0 ? _d : false; + let stopped = false; + function executableSchemaIdForSchema(schema2) { + if ((lastSeenExecutableSchemaToId === null || lastSeenExecutableSchemaToId === void 0 ? void 0 : lastSeenExecutableSchemaToId.executableSchema) === schema2) { + return lastSeenExecutableSchemaToId.executableSchemaId; + } + const id = (0, schemaReporting_1.computeCoreSchemaHash)((0, graphql_1.printSchema)(schema2)); + lastSeenExecutableSchemaToId = { + executableSchema: schema2, + executableSchemaId: id + }; + return id; + } + const getReportData = (executableSchemaId) => { + const existing = reportDataByExecutableSchemaId[executableSchemaId]; + if (existing) { + return existing; + } + const reportData = new ReportData(executableSchemaId, graphRef); + reportDataByExecutableSchemaId[executableSchemaId] = reportData; + return reportData; + }; + async function sendAllReportsAndReportErrors() { + await Promise.all(Object.keys(reportDataByExecutableSchemaId).map((executableSchemaId) => sendReportAndReportErrors(executableSchemaId))); + } + async function sendReportAndReportErrors(executableSchemaId) { + return sendReport(executableSchemaId).catch((err) => { + if (options.reportErrorFunction) { + options.reportErrorFunction(err); + } else { + logger.error(err.message); + } + }); + } + const sendReport = async (executableSchemaId) => { + var _a2, _b2; + const reportData = getReportData(executableSchemaId); + const { report } = reportData; + reportData.reset(); + if (Object.keys(report.tracesPerQuery).length === 0) { + return; + } + report.endTime = (0, traceTreeBuilder_1.dateToProtoTimestamp)(new Date()); + report.ensureCountsAreIntegers(); + const protobufError = apollo_reporting_protobuf_1.Report.verify(report); + if (protobufError) { + throw new Error(`Error encoding report: ${protobufError}`); + } + const message = apollo_reporting_protobuf_1.Report.encode(report).finish(); + if (options.debugPrintReports) { + const decodedReport = apollo_reporting_protobuf_1.Report.decode(message); + logger.warn(`Apollo usage report: ${JSON.stringify(decodedReport.toJSON())}`); + } + const compressed = await new Promise((resolve, reject) => { + const messageBuffer = Buffer.from(message.buffer, message.byteOffset, message.byteLength); + (0, zlib_1.gzip)(messageBuffer, (err, gzipResult) => { + if (err) { + reject(err); + } else { + resolve(gzipResult); + } + }); + }); + const fetcher = (_a2 = options.fetcher) !== null && _a2 !== void 0 ? _a2 : apollo_server_env_1.fetch; + const response = await (0, async_retry_1.default)(async () => { + const curResponse = await fetcher((options.endpointUrl || "https://usage-reporting.api.apollographql.com") + "/api/ingress/traces", { + method: "POST", + headers: { + "user-agent": "ApolloServerPluginUsageReporting", + "x-api-key": key, + "content-encoding": "gzip", + accept: "application/json" + }, + body: compressed, + agent: options.requestAgent + }); + if (curResponse.status >= 500 && curResponse.status < 600) { + throw new Error(`HTTP status ${curResponse.status}, ${await curResponse.text() || "(no body)"}`); + } else { + return curResponse; + } + }, { + retries: (options.maxAttempts || 5) - 1, + minTimeout: options.minimumRetryDelayMs || 100, + factor: 2 + }).catch((err) => { + throw new Error(`Error sending report to Apollo servers: ${err.message}`); + }); + if (response.status < 200 || response.status >= 300) { + throw new Error(`Error sending report to Apollo servers: HTTP status ${response.status}, ${await response.text() || "(no body)"}`); + } + if (graphMightSupportTraces && response.status === 200 && ((_b2 = response.headers.get("content-type")) === null || _b2 === void 0 ? void 0 : _b2.match(/^\s*application\/json\s*(?:;|$)/i))) { + const body = await response.text(); + let parsedBody; + try { + parsedBody = JSON.parse(body); + } catch (e) { + throw new Error(`Error parsing response from Apollo servers: ${e}`); + } + if (parsedBody.tracesIgnored === true) { + logger.debug("This graph's organization does not have access to traces; sending all subsequent operations as traces."); + graphMightSupportTraces = false; + } + } + if (options.debugPrintReports) { + logger.warn(`Apollo usage report: status ${response.status}`); + } + }; + requestDidStartHandler = ({ logger: requestLogger, metrics, schema: schema2, request: { http, variables } }) => { + var _a2; + const logger2 = (_a2 = requestLogger !== null && requestLogger !== void 0 ? requestLogger : options.logger) !== null && _a2 !== void 0 ? _a2 : serverLogger; + const treeBuilder = new traceTreeBuilder_1.TraceTreeBuilder({ + rewriteError: options.rewriteError, + logger: logger2 + }); + treeBuilder.startTiming(); + metrics.startHrTime = treeBuilder.startHrTime; + let graphqlValidationFailure = false; + let graphqlUnknownOperationName = false; + let includeOperationInUsageReporting = null; + if (http) { + treeBuilder.trace.http = new apollo_reporting_protobuf_1.Trace.HTTP({ + method: apollo_reporting_protobuf_1.Trace.HTTP.Method[http.method] || apollo_reporting_protobuf_1.Trace.HTTP.Method.UNKNOWN, + host: null, + path: null + }); + if (options.sendHeaders) { + makeHTTPRequestHeaders(treeBuilder.trace.http, http.headers, options.sendHeaders); + } + } + async function maybeCallIncludeRequestHook(requestContext) { + if (includeOperationInUsageReporting !== null) + return; + if (typeof options.includeRequest !== "function") { + includeOperationInUsageReporting = true; + return; + } + includeOperationInUsageReporting = await options.includeRequest(requestContext); + if (typeof includeOperationInUsageReporting !== "boolean") { + logger2.warn("The 'includeRequest' async predicate function must return a boolean value."); + includeOperationInUsageReporting = true; + } + } + let didResolveSource = false; + return { + async didResolveSource(requestContext) { + didResolveSource = true; + if (metrics.persistedQueryHit) { + treeBuilder.trace.persistedQueryHit = true; + } + if (metrics.persistedQueryRegister) { + treeBuilder.trace.persistedQueryRegister = true; + } + if (variables) { + treeBuilder.trace.details = (0, traceDetails_1.makeTraceDetails)(variables, options.sendVariableValues, requestContext.source); + } + const clientInfo = (options.generateClientInfo || defaultGenerateClientInfo)(requestContext); + if (clientInfo) { + const { clientName, clientVersion } = clientInfo; + treeBuilder.trace.clientVersion = clientVersion || ""; + treeBuilder.trace.clientName = clientName || ""; + } + }, + async validationDidStart() { + return async (validationErrors) => { + graphqlValidationFailure = validationErrors ? validationErrors.length !== 0 : false; + }; + }, + async didResolveOperation(requestContext) { + graphqlUnknownOperationName = requestContext.operation === void 0; + await maybeCallIncludeRequestHook(requestContext); + if (includeOperationInUsageReporting && !graphqlUnknownOperationName) { + if (metrics.captureTraces === void 0) { + const rawWeight = await fieldLevelInstrumentation(requestContext); + treeBuilder.trace.fieldExecutionWeight = typeof rawWeight === "number" ? rawWeight : rawWeight ? 1 : 0; + metrics.captureTraces = !!treeBuilder.trace.fieldExecutionWeight; + } else if (metrics.captureTraces) { + treeBuilder.trace.fieldExecutionWeight = 1; + } + } + }, + async executionDidStart() { + if (!metrics.captureTraces) + return; + return { + willResolveField({ info }) { + return treeBuilder.willResolveField(info); + } + }; + }, + async willSendResponse(requestContext) { + if (!didResolveSource) + return; + if (requestContext.errors) { + treeBuilder.didEncounterErrors(requestContext.errors); + } + await maybeCallIncludeRequestHook(requestContext); + treeBuilder.stopTiming(); + if (includeOperationInUsageReporting === false) + return; + treeBuilder.trace.fullQueryCacheHit = !!metrics.responseCacheHit; + treeBuilder.trace.forbiddenOperation = !!metrics.forbiddenOperation; + treeBuilder.trace.registeredOperation = !!metrics.registeredOperation; + const policyIfCacheable = requestContext.overallCachePolicy.policyIfCacheable(); + if (policyIfCacheable) { + treeBuilder.trace.cachePolicy = new apollo_reporting_protobuf_1.Trace.CachePolicy({ + scope: policyIfCacheable.scope === apollo_server_types_1.CacheScope.Private ? apollo_reporting_protobuf_1.Trace.CachePolicy.Scope.PRIVATE : policyIfCacheable.scope === apollo_server_types_1.CacheScope.Public ? apollo_reporting_protobuf_1.Trace.CachePolicy.Scope.PUBLIC : apollo_reporting_protobuf_1.Trace.CachePolicy.Scope.UNKNOWN, + maxAgeNs: policyIfCacheable.maxAge * 1e9 + }); + } + if (metrics.queryPlanTrace) { + treeBuilder.trace.queryPlan = metrics.queryPlanTrace; + } + addTrace().catch(logger2.error); + async function addTrace() { + if (stopped) { + return; + } + await new Promise((res) => setImmediate(res)); + const executableSchemaId = overriddenExecutableSchemaId !== null && overriddenExecutableSchemaId !== void 0 ? overriddenExecutableSchemaId : executableSchemaIdForSchema(schema2); + const reportData = getReportData(executableSchemaId); + const { report } = reportData; + const { trace } = treeBuilder; + let statsReportKey = void 0; + let referencedFieldsByType; + if (!requestContext.document) { + statsReportKey = `## GraphQLParseFailure +`; + } else if (graphqlValidationFailure) { + statsReportKey = `## GraphQLValidationFailure +`; + } else if (graphqlUnknownOperationName) { + statsReportKey = `## GraphQLUnknownOperationName +`; + } + if (statsReportKey) { + if (options.sendUnexecutableOperationDocuments) { + trace.unexecutedOperationBody = requestContext.source; + trace.unexecutedOperationName = requestContext.request.operationName || ""; + } + referencedFieldsByType = Object.create(null); + } else { + const operationDerivedData = getOperationDerivedData(); + statsReportKey = `# ${requestContext.operationName || "-"} +${operationDerivedData.signature}`; + referencedFieldsByType = operationDerivedData.referencedFieldsByType; + } + const protobufError = apollo_reporting_protobuf_1.Trace.verify(trace); + if (protobufError) { + throw new Error(`Error encoding trace: ${protobufError}`); + } + report.addTrace({ + statsReportKey, + trace, + asTrace: graphMightSupportTraces && !!metrics.captureTraces && sendOperationAsTrace(trace, statsReportKey), + includeTracesContributingToStats, + referencedFieldsByType + }); + if (sendReportsImmediately || report.sizeEstimator.bytes >= (options.maxUncompressedReportSize || 4 * 1024 * 1024)) { + await sendReportAndReportErrors(executableSchemaId); + } + } + function getOperationDerivedData() { + var _a3; + if (!requestContext.document) { + throw new Error("No document?"); + } + const cacheKey = (0, operationDerivedDataCache_1.operationDerivedDataCacheKey)(requestContext.queryHash, requestContext.operationName || ""); + if (!operationDerivedDataCache || operationDerivedDataCache.forSchema !== schema2) { + operationDerivedDataCache = { + forSchema: schema2, + cache: (0, operationDerivedDataCache_1.createOperationDerivedDataCache)({ logger: logger2 }) + }; + } + const cachedOperationDerivedData = operationDerivedDataCache.cache.get(cacheKey); + if (cachedOperationDerivedData) { + return cachedOperationDerivedData; + } + const generatedSignature = (options.calculateSignature || defaultUsageReportingSignature_1.defaultUsageReportingSignature)(requestContext.document, requestContext.operationName || ""); + const generatedOperationDerivedData = { + signature: generatedSignature, + referencedFieldsByType: (0, referencedFields_1.calculateReferencedFieldsByType)({ + document: requestContext.document, + schema: schema2, + resolvedOperationName: (_a3 = requestContext.operationName) !== null && _a3 !== void 0 ? _a3 : null + }) + }; + operationDerivedDataCache.cache.set(cacheKey, generatedOperationDerivedData); + return generatedOperationDerivedData; + } + } + }; + }; + return { + async serverWillStop() { + if (reportTimer) { + clearInterval(reportTimer); + reportTimer = void 0; + } + stopped = true; + await sendAllReportsAndReportErrors(); + } + }; + } + }; + } + exports2.ApolloServerPluginUsageReporting = ApolloServerPluginUsageReporting; + function makeHTTPRequestHeaders(http, headers, sendHeaders) { + if (!sendHeaders || "none" in sendHeaders && sendHeaders.none || "all" in sendHeaders && !sendHeaders.all) { + return; + } + for (const [key, value] of headers) { + const lowerCaseKey = key.toLowerCase(); + if ("exceptNames" in sendHeaders && sendHeaders.exceptNames.some((exceptHeader) => { + return exceptHeader.toLowerCase() === lowerCaseKey; + }) || "onlyNames" in sendHeaders && !sendHeaders.onlyNames.some((header) => { + return header.toLowerCase() === lowerCaseKey; + })) { + continue; + } + switch (key) { + case "authorization": + case "cookie": + case "set-cookie": + break; + default: + http.requestHeaders[key] = new apollo_reporting_protobuf_1.Trace.HTTP.Values({ + value: [value] + }); + } + } + } + exports2.makeHTTPRequestHeaders = makeHTTPRequestHeaders; + function defaultGenerateClientInfo({ request }) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j; + const clientNameHeaderKey = "apollographql-client-name"; + const clientVersionHeaderKey = "apollographql-client-version"; + if (((_b = (_a = request.http) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b.get(clientNameHeaderKey)) || ((_d = (_c = request.http) === null || _c === void 0 ? void 0 : _c.headers) === null || _d === void 0 ? void 0 : _d.get(clientVersionHeaderKey))) { + return { + clientName: (_f = (_e = request.http) === null || _e === void 0 ? void 0 : _e.headers) === null || _f === void 0 ? void 0 : _f.get(clientNameHeaderKey), + clientVersion: (_h = (_g = request.http) === null || _g === void 0 ? void 0 : _g.headers) === null || _h === void 0 ? void 0 : _h.get(clientVersionHeaderKey) + }; + } else if ((_j = request.extensions) === null || _j === void 0 ? void 0 : _j.clientInfo) { + return request.extensions.clientInfo; + } else { + return {}; + } + } + function ApolloServerPluginUsageReportingDisabled() { + return { + __internal_plugin_id__() { + return "UsageReporting"; + } + }; + } + exports2.ApolloServerPluginUsageReportingDisabled = ApolloServerPluginUsageReportingDisabled; + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/options.js +var require_options = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/options.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + } +}); + +// node_modules/apollo-server-core/dist/plugin/usageReporting/index.js +var require_usageReporting = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/usageReporting/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ApolloServerPluginUsageReportingDisabled = exports2.ApolloServerPluginUsageReporting = void 0; + var plugin_1 = require_plugin(); + Object.defineProperty(exports2, "ApolloServerPluginUsageReporting", { enumerable: true, get: function() { + return plugin_1.ApolloServerPluginUsageReporting; + } }); + Object.defineProperty(exports2, "ApolloServerPluginUsageReportingDisabled", { enumerable: true, get: function() { + return plugin_1.ApolloServerPluginUsageReportingDisabled; + } }); + var options_1 = require_options(); + } +}); + +// node_modules/apollo-server-core/dist/plugin/inlineTrace/index.js +var require_inlineTrace = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/inlineTrace/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ApolloServerPluginInlineTraceDisabled = exports2.ApolloServerPluginInlineTrace = void 0; + var apollo_reporting_protobuf_1 = require_generated(); + var traceTreeBuilder_1 = require_traceTreeBuilder(); + var schemaIsFederated_1 = require_schemaIsFederated(); + function ApolloServerPluginInlineTrace(options = Object.create(null)) { + let enabled = options.__onlyIfSchemaIsFederated ? null : true; + return { + __internal_plugin_id__() { + return "InlineTrace"; + }, + async serverWillStart({ schema: schema2, logger }) { + if (enabled === null) { + enabled = (0, schemaIsFederated_1.schemaIsFederated)(schema2); + if (enabled) { + logger.info("Enabling inline tracing for this federated service. To disable, use ApolloServerPluginInlineTraceDisabled."); + } + } + }, + async requestDidStart({ request: { http }, metrics }) { + if (!enabled) { + return; + } + const treeBuilder = new traceTreeBuilder_1.TraceTreeBuilder({ + rewriteError: options.rewriteError + }); + if ((http === null || http === void 0 ? void 0 : http.headers.get("apollo-federation-include-trace")) !== "ftv1") { + return; + } + if (metrics.captureTraces === false) { + return; + } + metrics.captureTraces = true; + treeBuilder.startTiming(); + return { + async executionDidStart() { + return { + willResolveField({ info }) { + return treeBuilder.willResolveField(info); + } + }; + }, + async didEncounterErrors({ errors }) { + treeBuilder.didEncounterErrors(errors); + }, + async willSendResponse({ response }) { + treeBuilder.stopTiming(); + if (metrics.queryPlanTrace) { + treeBuilder.trace.queryPlan = metrics.queryPlanTrace; + } + const encodedUint8Array = apollo_reporting_protobuf_1.Trace.encode(treeBuilder.trace).finish(); + const encodedBuffer = Buffer.from(encodedUint8Array, encodedUint8Array.byteOffset, encodedUint8Array.byteLength); + const extensions = response.extensions || (response.extensions = Object.create(null)); + if (typeof extensions.ftv1 !== "undefined") { + throw new Error("The `ftv1` extension was already present."); + } + extensions.ftv1 = encodedBuffer.toString("base64"); + } + }; + } + }; + } + exports2.ApolloServerPluginInlineTrace = ApolloServerPluginInlineTrace; + function ApolloServerPluginInlineTraceDisabled() { + return { + __internal_plugin_id__() { + return "InlineTrace"; + } + }; + } + exports2.ApolloServerPluginInlineTraceDisabled = ApolloServerPluginInlineTraceDisabled; + } +}); + +// node_modules/apollo-server-core/dist/plugin/cacheControl/index.js +var require_cacheControl = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/cacheControl/index.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ApolloServerPluginCacheControlDisabled = exports2.ApolloServerPluginCacheControl = void 0; + var graphql_1 = require_graphql2(); + var cachePolicy_1 = require_cachePolicy(); + var lru_cache_1 = __importDefault(require_lru_cache()); + function ApolloServerPluginCacheControl(options = Object.create(null)) { + const typeAnnotationCache = new lru_cache_1.default(); + const fieldAnnotationCache = new lru_cache_1.default(); + function memoizedCacheAnnotationFromType(t) { + const existing = typeAnnotationCache.get(t); + if (existing) { + return existing; + } + const annotation = cacheAnnotationFromType(t); + typeAnnotationCache.set(t, annotation); + return annotation; + } + function memoizedCacheAnnotationFromField(field) { + const existing = fieldAnnotationCache.get(field); + if (existing) { + return existing; + } + const annotation = cacheAnnotationFromField(field); + fieldAnnotationCache.set(field, annotation); + return annotation; + } + return { + __internal_plugin_id__() { + return "CacheControl"; + }, + async serverWillStart({ schema: schema2 }) { + typeAnnotationCache.max = Object.values(schema2.getTypeMap()).filter(graphql_1.isCompositeType).length; + fieldAnnotationCache.max = Object.values(schema2.getTypeMap()).filter(graphql_1.isObjectType).flatMap((t) => Object.values(t.getFields())).length + Object.values(schema2.getTypeMap()).filter(graphql_1.isInterfaceType).flatMap((t) => Object.values(t.getFields())).length; + return void 0; + }, + async requestDidStart(requestContext) { + var _a, _b; + const defaultMaxAge = (_a = options.defaultMaxAge) !== null && _a !== void 0 ? _a : 0; + const calculateHttpHeaders = (_b = options.calculateHttpHeaders) !== null && _b !== void 0 ? _b : true; + const { __testing__cacheHints } = options; + return { + async executionDidStart() { + if (isRestricted(requestContext.overallCachePolicy)) { + const fakeFieldPolicy = (0, cachePolicy_1.newCachePolicy)(); + return { + willResolveField({ info }) { + info.cacheControl = { + setCacheHint: (dynamicHint) => { + fakeFieldPolicy.replace(dynamicHint); + }, + cacheHint: fakeFieldPolicy, + cacheHintFromType: memoizedCacheAnnotationFromType + }; + } + }; + } + return { + willResolveField({ info }) { + const fieldPolicy = (0, cachePolicy_1.newCachePolicy)(); + let inheritMaxAge = false; + const targetType = (0, graphql_1.getNamedType)(info.returnType); + if ((0, graphql_1.isCompositeType)(targetType)) { + const typeAnnotation = memoizedCacheAnnotationFromType(targetType); + fieldPolicy.replace(typeAnnotation); + inheritMaxAge = !!typeAnnotation.inheritMaxAge; + } + const fieldAnnotation = memoizedCacheAnnotationFromField(info.parentType.getFields()[info.fieldName]); + if (fieldAnnotation.inheritMaxAge && fieldPolicy.maxAge === void 0) { + inheritMaxAge = true; + if (fieldAnnotation.scope) { + fieldPolicy.replace({ scope: fieldAnnotation.scope }); + } + } else { + fieldPolicy.replace(fieldAnnotation); + } + info.cacheControl = { + setCacheHint: (dynamicHint) => { + fieldPolicy.replace(dynamicHint); + }, + cacheHint: fieldPolicy, + cacheHintFromType: memoizedCacheAnnotationFromType + }; + return () => { + if (fieldPolicy.maxAge === void 0 && ((0, graphql_1.isCompositeType)(targetType) && !inheritMaxAge || !info.path.prev)) { + fieldPolicy.restrict({ maxAge: defaultMaxAge }); + } + if (__testing__cacheHints && isRestricted(fieldPolicy)) { + const path = (0, graphql_1.responsePathAsArray)(info.path).join("."); + if (__testing__cacheHints.has(path)) { + throw Error("shouldn't happen: addHint should only be called once per path"); + } + __testing__cacheHints.set(path, { + maxAge: fieldPolicy.maxAge, + scope: fieldPolicy.scope + }); + } + requestContext.overallCachePolicy.restrict(fieldPolicy); + }; + } + }; + }, + async willSendResponse(requestContext2) { + const { response, overallCachePolicy } = requestContext2; + const policyIfCacheable = overallCachePolicy.policyIfCacheable(); + if (calculateHttpHeaders && policyIfCacheable && !response.errors && response.http) { + response.http.headers.set("Cache-Control", `max-age=${policyIfCacheable.maxAge}, ${policyIfCacheable.scope.toLowerCase()}`); + } + } + }; + } + }; + } + exports2.ApolloServerPluginCacheControl = ApolloServerPluginCacheControl; + function cacheAnnotationFromDirectives(directives) { + var _a, _b, _c; + if (!directives) + return void 0; + const cacheControlDirective = directives.find((directive) => directive.name.value === "cacheControl"); + if (!cacheControlDirective) + return void 0; + if (!cacheControlDirective.arguments) + return void 0; + const maxAgeArgument = cacheControlDirective.arguments.find((argument) => argument.name.value === "maxAge"); + const scopeArgument = cacheControlDirective.arguments.find((argument) => argument.name.value === "scope"); + const inheritMaxAgeArgument = cacheControlDirective.arguments.find((argument) => argument.name.value === "inheritMaxAge"); + const scope = ((_a = scopeArgument === null || scopeArgument === void 0 ? void 0 : scopeArgument.value) === null || _a === void 0 ? void 0 : _a.kind) === "EnumValue" ? scopeArgument.value.value : void 0; + if (((_b = inheritMaxAgeArgument === null || inheritMaxAgeArgument === void 0 ? void 0 : inheritMaxAgeArgument.value) === null || _b === void 0 ? void 0 : _b.kind) === "BooleanValue" && inheritMaxAgeArgument.value.value) { + return { inheritMaxAge: true, scope }; + } + return { + maxAge: ((_c = maxAgeArgument === null || maxAgeArgument === void 0 ? void 0 : maxAgeArgument.value) === null || _c === void 0 ? void 0 : _c.kind) === "IntValue" ? parseInt(maxAgeArgument.value.value) : void 0, + scope + }; + } + function cacheAnnotationFromType(t) { + if (t.astNode) { + const hint = cacheAnnotationFromDirectives(t.astNode.directives); + if (hint) { + return hint; + } + } + if (t.extensionASTNodes) { + for (const node of t.extensionASTNodes) { + const hint = cacheAnnotationFromDirectives(node.directives); + if (hint) { + return hint; + } + } + } + return {}; + } + function cacheAnnotationFromField(field) { + if (field.astNode) { + const hint = cacheAnnotationFromDirectives(field.astNode.directives); + if (hint) { + return hint; + } + } + return {}; + } + function isRestricted(hint) { + return hint.maxAge !== void 0 || hint.scope !== void 0; + } + function ApolloServerPluginCacheControlDisabled() { + return { + __internal_plugin_id__() { + return "CacheControl"; + } + }; + } + exports2.ApolloServerPluginCacheControlDisabled = ApolloServerPluginCacheControlDisabled; + } +}); + +// node_modules/apollo-server-core/dist/plugin/drainHttpServer/stoppable.js +var require_stoppable = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/drainHttpServer/stoppable.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Stopper = void 0; + var https_1 = __importDefault(require("https")); + var Stopper = class { + constructor(server2) { + this.server = server2; + this.requestCountPerSocket = new Map(); + this.stopped = false; + server2.on(server2 instanceof https_1.default.Server ? "secureConnection" : "connection", (socket) => { + this.requestCountPerSocket.set(socket, 0); + socket.once("close", () => this.requestCountPerSocket.delete(socket)); + }); + server2.on("request", (req, res) => { + var _a; + this.requestCountPerSocket.set(req.socket, ((_a = this.requestCountPerSocket.get(req.socket)) !== null && _a !== void 0 ? _a : 0) + 1); + res.once("finish", () => { + var _a2; + const pending = ((_a2 = this.requestCountPerSocket.get(req.socket)) !== null && _a2 !== void 0 ? _a2 : 0) - 1; + this.requestCountPerSocket.set(req.socket, pending); + if (this.stopped && pending === 0) { + req.socket.end(); + } + }); + }); + } + async stop(stopGracePeriodMillis = Infinity) { + let gracefully = true; + await new Promise((resolve) => setImmediate(resolve)); + this.stopped = true; + let timeout = null; + if (stopGracePeriodMillis < Infinity) { + timeout = setTimeout(() => { + gracefully = false; + this.requestCountPerSocket.forEach((_, socket) => socket.end()); + setImmediate(() => { + this.requestCountPerSocket.forEach((_, socket) => socket.destroy()); + }); + }, stopGracePeriodMillis); + } + const closePromise = new Promise((resolve) => this.server.close(() => { + if (timeout) { + clearTimeout(timeout); + timeout = null; + } + resolve(); + })); + this.requestCountPerSocket.forEach((requests, socket) => { + if (requests === 0) + socket.end(); + }); + await closePromise; + return gracefully; + } + }; + exports2.Stopper = Stopper; + } +}); + +// node_modules/apollo-server-core/dist/plugin/drainHttpServer/index.js +var require_drainHttpServer = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/drainHttpServer/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ApolloServerPluginDrainHttpServer = void 0; + var stoppable_1 = require_stoppable(); + function ApolloServerPluginDrainHttpServer(options) { + const stopper = new stoppable_1.Stopper(options.httpServer); + return { + async serverWillStart() { + return { + async drainServer() { + var _a; + await stopper.stop((_a = options.stopGracePeriodMillis) !== null && _a !== void 0 ? _a : 1e4); + } + }; + } + }; + } + exports2.ApolloServerPluginDrainHttpServer = ApolloServerPluginDrainHttpServer; + } +}); + +// node_modules/apollo-server-core/dist/plugin/landingPage/default/index.js +var require_default = __commonJS({ + "node_modules/apollo-server-core/dist/plugin/landingPage/default/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ApolloServerPluginLandingPageProductionDefault = exports2.ApolloServerPluginLandingPageLocalDefault = void 0; + function ApolloServerPluginLandingPageLocalDefault(options = {}) { + const _a = options, { version, __internal_apolloStudioEnv__, footer, document: document2, variables, headers, includeCookies } = _a, rest = __objRest(_a, ["version", "__internal_apolloStudioEnv__", "footer", "document", "variables", "headers", "includeCookies"]); + return ApolloServerPluginLandingPageDefault(version, encodeConfig(__spreadValues({ + isProd: false, + apolloStudioEnv: __internal_apolloStudioEnv__, + footer, + document: document2, + variables, + headers, + includeCookies + }, rest))); + } + exports2.ApolloServerPluginLandingPageLocalDefault = ApolloServerPluginLandingPageLocalDefault; + function ApolloServerPluginLandingPageProductionDefault(options = {}) { + const _a = options, { version, __internal_apolloStudioEnv__, footer, document: document2, variables, headers, includeCookies, graphRef } = _a, rest = __objRest(_a, ["version", "__internal_apolloStudioEnv__", "footer", "document", "variables", "headers", "includeCookies", "graphRef"]); + return ApolloServerPluginLandingPageDefault(version, encodeConfig(__spreadValues({ + isProd: true, + apolloStudioEnv: __internal_apolloStudioEnv__, + footer, + document: document2, + variables, + headers, + includeCookies, + graphRef + }, rest))); + } + exports2.ApolloServerPluginLandingPageProductionDefault = ApolloServerPluginLandingPageProductionDefault; + function encodeConfig(config) { + return JSON.stringify(encodeURIComponent(JSON.stringify(config))); + } + function ApolloServerPluginLandingPageDefault(maybeVersion, encodedConfig) { + const version = maybeVersion !== null && maybeVersion !== void 0 ? maybeVersion : "_latest"; + return { + __internal_installed_implicitly__: false, + async serverWillStart() { + return { + async renderLandingPage() { + const html = ` + + + + + + + + + + + + + Apollo Server + + + +
+ +
+

Welcome to Apollo Server

+

It appears that you might be offline. POST to this endpoint to query your graph:

+ +curl --request POST \\ + --header 'content-type: application/json' \\ + --url '