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