.config/coc/extensions/node_modules/coc-go/node_modules/tslib/tslib.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 global, define, System, Reflect, Promise */\r
  16 var __extends;\r
  17 var __assign;\r
  18 var __rest;\r
  19 var __decorate;\r
  20 var __param;\r
  21 var __metadata;\r
  22 var __awaiter;\r
  23 var __generator;\r
  24 var __exportStar;\r
  25 var __values;\r
  26 var __read;\r
  27 var __spread;\r
  28 var __spreadArrays;\r
  29 var __await;\r
  30 var __asyncGenerator;\r
  31 var __asyncDelegator;\r
  32 var __asyncValues;\r
  33 var __makeTemplateObject;\r
  34 var __importStar;\r
  35 var __importDefault;\r
  36 var __classPrivateFieldGet;\r
  37 var __classPrivateFieldSet;\r
  38 var __createBinding;\r
  39 (function (factory) {\r
  40     var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};\r
  41     if (typeof define === "function" && define.amd) {\r
  42         define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); });\r
  43     }\r
  44     else if (typeof module === "object" && typeof module.exports === "object") {\r
  45         factory(createExporter(root, createExporter(module.exports)));\r
  46     }\r
  47     else {\r
  48         factory(createExporter(root));\r
  49     }\r
  50     function createExporter(exports, previous) {\r
  51         if (exports !== root) {\r
  52             if (typeof Object.create === "function") {\r
  53                 Object.defineProperty(exports, "__esModule", { value: true });\r
  54             }\r
  55             else {\r
  56                 exports.__esModule = true;\r
  57             }\r
  58         }\r
  59         return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };\r
  60     }\r
  61 })\r
  62 (function (exporter) {\r
  63     var extendStatics = Object.setPrototypeOf ||\r
  64         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r
  65         function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r
  66 \r
  67     __extends = function (d, b) {\r
  68         extendStatics(d, b);\r
  69         function __() { this.constructor = d; }\r
  70         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r
  71     };\r
  72 \r
  73     __assign = Object.assign || function (t) {\r
  74         for (var s, i = 1, n = arguments.length; i < n; i++) {\r
  75             s = arguments[i];\r
  76             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r
  77         }\r
  78         return t;\r
  79     };\r
  80 \r
  81     __rest = function (s, e) {\r
  82         var t = {};\r
  83         for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r
  84             t[p] = s[p];\r
  85         if (s != null && typeof Object.getOwnPropertySymbols === "function")\r
  86             for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r
  87                 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r
  88                     t[p[i]] = s[p[i]];\r
  89             }\r
  90         return t;\r
  91     };\r
  92 \r
  93     __decorate = function (decorators, target, key, desc) {\r
  94         var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r
  95         if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);\r
  96         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
  97         return c > 3 && r && Object.defineProperty(target, key, r), r;\r
  98     };\r
  99 \r
 100     __param = function (paramIndex, decorator) {\r
 101         return function (target, key) { decorator(target, key, paramIndex); }\r
 102     };\r
 103 \r
 104     __metadata = function (metadataKey, metadataValue) {\r
 105         if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);\r
 106     };\r
 107 \r
 108     __awaiter = function (thisArg, _arguments, P, generator) {\r
 109         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r
 110         return new (P || (P = Promise))(function (resolve, reject) {\r
 111             function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r
 112             function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }\r
 113             function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r
 114             step((generator = generator.apply(thisArg, _arguments || [])).next());\r
 115         });\r
 116     };\r
 117 \r
 118     __generator = function (thisArg, body) {\r
 119         var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r
 120         return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;\r
 121         function verb(n) { return function (v) { return step([n, v]); }; }\r
 122         function step(op) {\r
 123             if (f) throw new TypeError("Generator is already executing.");\r
 124             while (_) try {\r
 125                 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
 126                 if (y = 0, t) op = [op[0] & 2, t.value];\r
 127                 switch (op[0]) {\r
 128                     case 0: case 1: t = op; break;\r
 129                     case 4: _.label++; return { value: op[1], done: false };\r
 130                     case 5: _.label++; y = op[1]; op = [0]; continue;\r
 131                     case 7: op = _.ops.pop(); _.trys.pop(); continue;\r
 132                     default:\r
 133                         if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r
 134                         if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r
 135                         if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r
 136                         if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r
 137                         if (t[2]) _.ops.pop();\r
 138                         _.trys.pop(); continue;\r
 139                 }\r
 140                 op = body.call(thisArg, _);\r
 141             } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r
 142             if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r
 143         }\r
 144     };\r
 145 \r
 146     __exportStar = function(m, o) {\r
 147         for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r
 148     };\r
 149 \r
 150     __createBinding = Object.create ? (function(o, m, k, k2) {\r
 151         if (k2 === undefined) k2 = k;\r
 152         Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r
 153     }) : (function(o, m, k, k2) {\r
 154         if (k2 === undefined) k2 = k;\r
 155         o[k2] = m[k];\r
 156     });\r
 157 \r
 158     __values = function (o) {\r
 159         var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;\r
 160         if (m) return m.call(o);\r
 161         if (o && typeof o.length === "number") return {\r
 162             next: function () {\r
 163                 if (o && i >= o.length) o = void 0;\r
 164                 return { value: o && o[i++], done: !o };\r
 165             }\r
 166         };\r
 167         throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");\r
 168     };\r
 169 \r
 170     __read = function (o, n) {\r
 171         var m = typeof Symbol === "function" && o[Symbol.iterator];\r
 172         if (!m) return o;\r
 173         var i = m.call(o), r, ar = [], e;\r
 174         try {\r
 175             while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r
 176         }\r
 177         catch (error) { e = { error: error }; }\r
 178         finally {\r
 179             try {\r
 180                 if (r && !r.done && (m = i["return"])) m.call(i);\r
 181             }\r
 182             finally { if (e) throw e.error; }\r
 183         }\r
 184         return ar;\r
 185     };\r
 186 \r
 187     __spread = function () {\r
 188         for (var ar = [], i = 0; i < arguments.length; i++)\r
 189             ar = ar.concat(__read(arguments[i]));\r
 190         return ar;\r
 191     };\r
 192 \r
 193     __spreadArrays = function () {\r
 194         for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r
 195         for (var r = Array(s), k = 0, i = 0; i < il; i++)\r
 196             for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r
 197                 r[k] = a[j];\r
 198         return r;\r
 199     };\r
 200 \r
 201     __await = function (v) {\r
 202         return this instanceof __await ? (this.v = v, this) : new __await(v);\r
 203     };\r
 204 \r
 205     __asyncGenerator = function (thisArg, _arguments, generator) {\r
 206         if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");\r
 207         var g = generator.apply(thisArg, _arguments || []), i, q = [];\r
 208         return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;\r
 209         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
 210         function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r
 211         function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }\r
 212         function fulfill(value) { resume("next", value); }\r
 213         function reject(value) { resume("throw", value); }\r
 214         function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r
 215     };\r
 216 \r
 217     __asyncDelegator = function (o) {\r
 218         var i, p;\r
 219         return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;\r
 220         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
 221     };\r
 222 \r
 223     __asyncValues = function (o) {\r
 224         if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");\r
 225         var m = o[Symbol.asyncIterator], i;\r
 226         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
 227         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
 228         function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r
 229     };\r
 230 \r
 231     __makeTemplateObject = function (cooked, raw) {\r
 232         if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }\r
 233         return cooked;\r
 234     };\r
 235 \r
 236     var __setModuleDefault = Object.create ? (function(o, v) {\r
 237         Object.defineProperty(o, "default", { enumerable: true, value: v });\r
 238     }) : function(o, v) {\r
 239         o["default"] = v;\r
 240     };\r
 241 \r
 242     __importStar = function (mod) {\r
 243         if (mod && mod.__esModule) return mod;\r
 244         var result = {};\r
 245         if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r
 246         __setModuleDefault(result, mod);\r
 247         return result;\r
 248     };\r
 249 \r
 250     __importDefault = function (mod) {\r
 251         return (mod && mod.__esModule) ? mod : { "default": mod };\r
 252     };\r
 253 \r
 254     __classPrivateFieldGet = function (receiver, privateMap) {\r
 255         if (!privateMap.has(receiver)) {\r
 256             throw new TypeError("attempted to get private field on non-instance");\r
 257         }\r
 258         return privateMap.get(receiver);\r
 259     };\r
 260 \r
 261     __classPrivateFieldSet = function (receiver, privateMap, value) {\r
 262         if (!privateMap.has(receiver)) {\r
 263             throw new TypeError("attempted to set private field on non-instance");\r
 264         }\r
 265         privateMap.set(receiver, value);\r
 266         return value;\r
 267     };\r
 268 \r
 269     exporter("__extends", __extends);\r
 270     exporter("__assign", __assign);\r
 271     exporter("__rest", __rest);\r
 272     exporter("__decorate", __decorate);\r
 273     exporter("__param", __param);\r
 274     exporter("__metadata", __metadata);\r
 275     exporter("__awaiter", __awaiter);\r
 276     exporter("__generator", __generator);\r
 277     exporter("__exportStar", __exportStar);\r
 278     exporter("__createBinding", __createBinding);\r
 279     exporter("__values", __values);\r
 280     exporter("__read", __read);\r
 281     exporter("__spread", __spread);\r
 282     exporter("__spreadArrays", __spreadArrays);\r
 283     exporter("__await", __await);\r
 284     exporter("__asyncGenerator", __asyncGenerator);\r
 285     exporter("__asyncDelegator", __asyncDelegator);\r
 286     exporter("__asyncValues", __asyncValues);\r
 287     exporter("__makeTemplateObject", __makeTemplateObject);\r
 288     exporter("__importStar", __importStar);\r
 289     exporter("__importDefault", __importDefault);\r
 290     exporter("__classPrivateFieldGet", __classPrivateFieldGet);\r
 291     exporter("__classPrivateFieldSet", __classPrivateFieldSet);\r
 292 });\r