.config/coc/extensions/node_modules/coc-go/node_modules/tslib/tslib.es6.js

   1 /*! *****************************************************************************\r
   2 Copyright (c) Microsoft Corporation.\r
   3 \r
   4 Permission to use, copy, modify, and/or distribute this software for any\r
   5 purpose with or without fee is hereby granted.\r
   6 \r
   7 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r
   8 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r
   9 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r
  10 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r
  11 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r
  12 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r
  13 PERFORMANCE OF THIS SOFTWARE.\r
  14 ***************************************************************************** */\r
  15 /* global Reflect, Promise */\r
  16 \r
  17 var extendStatics = function(d, b) {\r
  18     extendStatics = Object.setPrototypeOf ||\r
  19         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r
  20         function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r
  21     return extendStatics(d, b);\r
  22 };\r
  23 \r
  24 export function __extends(d, b) {\r
  25     extendStatics(d, b);\r
  26     function __() { this.constructor = d; }\r
  27     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r
  28 }\r
  29 \r
  30 export var __assign = function() {\r
  31     __assign = Object.assign || function __assign(t) {\r
  32         for (var s, i = 1, n = arguments.length; i < n; i++) {\r
  33             s = arguments[i];\r
  34             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r
  35         }\r
  36         return t;\r
  37     }\r
  38     return __assign.apply(this, arguments);\r
  39 }\r
  40 \r
  41 export function __rest(s, e) {\r
  42     var t = {};\r
  43     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r
  44         t[p] = s[p];\r
  45     if (s != null && typeof Object.getOwnPropertySymbols === "function")\r
  46         for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r
  47             if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r
  48                 t[p[i]] = s[p[i]];\r
  49         }\r
  50     return t;\r
  51 }\r
  52 \r
  53 export function __decorate(decorators, target, key, desc) {\r
  54     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r
  55     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);\r
  56     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;\r
  57     return c > 3 && r && Object.defineProperty(target, key, r), r;\r
  58 }\r
  59 \r
  60 export function __param(paramIndex, decorator) {\r
  61     return function (target, key) { decorator(target, key, paramIndex); }\r
  62 }\r
  63 \r
  64 export function __metadata(metadataKey, metadataValue) {\r
  65     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);\r
  66 }\r
  67 \r
  68 export function __awaiter(thisArg, _arguments, P, generator) {\r
  69     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r
  70     return new (P || (P = Promise))(function (resolve, reject) {\r
  71         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r
  72         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }\r
  73         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r
  74         step((generator = generator.apply(thisArg, _arguments || [])).next());\r
  75     });\r
  76 }\r
  77 \r
  78 export function __generator(thisArg, body) {\r
  79     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r
  80     return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;\r
  81     function verb(n) { return function (v) { return step([n, v]); }; }\r
  82     function step(op) {\r
  83         if (f) throw new TypeError("Generator is already executing.");\r
  84         while (_) try {\r
  85             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;\r
  86             if (y = 0, t) op = [op[0] & 2, t.value];\r
  87             switch (op[0]) {\r
  88                 case 0: case 1: t = op; break;\r
  89                 case 4: _.label++; return { value: op[1], done: false };\r
  90                 case 5: _.label++; y = op[1]; op = [0]; continue;\r
  91                 case 7: op = _.ops.pop(); _.trys.pop(); continue;\r
  92                 default:\r
  93                     if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r
  94                     if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r
  95                     if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r
  96                     if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r
  97                     if (t[2]) _.ops.pop();\r
  98                     _.trys.pop(); continue;\r
  99             }\r
 100             op = body.call(thisArg, _);\r
 101         } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r
 102         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r
 103     }\r
 104 }\r
 105 \r
 106 export var __createBinding = Object.create ? (function(o, m, k, k2) {\r
 107     if (k2 === undefined) k2 = k;\r
 108     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r
 109 }) : (function(o, m, k, k2) {\r
 110     if (k2 === undefined) k2 = k;\r
 111     o[k2] = m[k];\r
 112 });\r
 113 \r
 114 export function __exportStar(m, o) {\r
 115     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r
 116 }\r
 117 \r
 118 export function __values(o) {\r
 119     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;\r
 120     if (m) return m.call(o);\r
 121     if (o && typeof o.length === "number") return {\r
 122         next: function () {\r
 123             if (o && i >= o.length) o = void 0;\r
 124             return { value: o && o[i++], done: !o };\r
 125         }\r
 126     };\r
 127     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");\r
 128 }\r
 129 \r
 130 export function __read(o, n) {\r
 131     var m = typeof Symbol === "function" && o[Symbol.iterator];\r
 132     if (!m) return o;\r
 133     var i = m.call(o), r, ar = [], e;\r
 134     try {\r
 135         while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r
 136     }\r
 137     catch (error) { e = { error: error }; }\r
 138     finally {\r
 139         try {\r
 140             if (r && !r.done && (m = i["return"])) m.call(i);\r
 141         }\r
 142         finally { if (e) throw e.error; }\r
 143     }\r
 144     return ar;\r
 145 }\r
 146 \r
 147 export function __spread() {\r
 148     for (var ar = [], i = 0; i < arguments.length; i++)\r
 149         ar = ar.concat(__read(arguments[i]));\r
 150     return ar;\r
 151 }\r
 152 \r
 153 export function __spreadArrays() {\r
 154     for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r
 155     for (var r = Array(s), k = 0, i = 0; i < il; i++)\r
 156         for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r
 157             r[k] = a[j];\r
 158     return r;\r
 159 };\r
 160 \r
 161 export function __await(v) {\r
 162     return this instanceof __await ? (this.v = v, this) : new __await(v);\r
 163 }\r
 164 \r
 165 export function __asyncGenerator(thisArg, _arguments, generator) {\r
 166     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");\r
 167     var g = generator.apply(thisArg, _arguments || []), i, q = [];\r
 168     return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;\r
 169     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); }); }; }\r
 170     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r
 171     function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r
 172     function fulfill(value) { resume("next", value); }\r
 173     function reject(value) { resume("throw", value); }\r
 174     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r
 175 }\r
 176 \r
 177 export function __asyncDelegator(o) {\r
 178     var i, p;\r
 179     return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;\r
 180     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; }\r
 181 }\r
 182 \r
 183 export function __asyncValues(o) {\r
 184     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");\r
 185     var m = o[Symbol.asyncIterator], i;\r
 186     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);\r
 187     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); }); }; }\r
 188     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r
 189 }\r
 190 \r
 191 export function __makeTemplateObject(cooked, raw) {\r
 192     if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }\r
 193     return cooked;\r
 194 };\r
 195 \r
 196 var __setModuleDefault = Object.create ? (function(o, v) {\r
 197     Object.defineProperty(o, "default", { enumerable: true, value: v });\r
 198 }) : function(o, v) {\r
 199     o["default"] = v;\r
 200 };\r
 201 \r
 202 export function __importStar(mod) {\r
 203     if (mod && mod.__esModule) return mod;\r
 204     var result = {};\r
 205     if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r
 206     __setModuleDefault(result, mod);\r
 207     return result;\r
 208 }\r
 209 \r
 210 export function __importDefault(mod) {\r
 211     return (mod && mod.__esModule) ? mod : { default: mod };\r
 212 }\r
 213 \r
 214 export function __classPrivateFieldGet(receiver, privateMap) {\r
 215     if (!privateMap.has(receiver)) {\r
 216         throw new TypeError("attempted to get private field on non-instance");\r
 217     }\r
 218     return privateMap.get(receiver);\r
 219 }\r
 220 \r
 221 export function __classPrivateFieldSet(receiver, privateMap, value) {\r
 222     if (!privateMap.has(receiver)) {\r
 223         throw new TypeError("attempted to set private field on non-instance");\r
 224     }\r
 225     privateMap.set(receiver, value);\r
 226     return value;\r
 227 }\r