.config/coc/extensions/node_modules/coc-prettier/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 (b.hasOwnProperty(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 function __createBinding(o, m, k, k2) {\r
 107     if (k2 === undefined) k2 = k;\r
 108     o[k2] = m[k];\r
 109 }\r
 110 \r
 111 export function __exportStar(m, exports) {\r
 112     for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r
 113 }\r
 114 \r
 115 export function __values(o) {\r
 116     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;\r
 117     if (m) return m.call(o);\r
 118     if (o && typeof o.length === "number") return {\r
 119         next: function () {\r
 120             if (o && i >= o.length) o = void 0;\r
 121             return { value: o && o[i++], done: !o };\r
 122         }\r
 123     };\r
 124     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");\r
 125 }\r
 126 \r
 127 export function __read(o, n) {\r
 128     var m = typeof Symbol === "function" && o[Symbol.iterator];\r
 129     if (!m) return o;\r
 130     var i = m.call(o), r, ar = [], e;\r
 131     try {\r
 132         while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r
 133     }\r
 134     catch (error) { e = { error: error }; }\r
 135     finally {\r
 136         try {\r
 137             if (r && !r.done && (m = i["return"])) m.call(i);\r
 138         }\r
 139         finally { if (e) throw e.error; }\r
 140     }\r
 141     return ar;\r
 142 }\r
 143 \r
 144 export function __spread() {\r
 145     for (var ar = [], i = 0; i < arguments.length; i++)\r
 146         ar = ar.concat(__read(arguments[i]));\r
 147     return ar;\r
 148 }\r
 149 \r
 150 export function __spreadArrays() {\r
 151     for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r
 152     for (var r = Array(s), k = 0, i = 0; i < il; i++)\r
 153         for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r
 154             r[k] = a[j];\r
 155     return r;\r
 156 };\r
 157 \r
 158 export function __await(v) {\r
 159     return this instanceof __await ? (this.v = v, this) : new __await(v);\r
 160 }\r
 161 \r
 162 export function __asyncGenerator(thisArg, _arguments, generator) {\r
 163     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");\r
 164     var g = generator.apply(thisArg, _arguments || []), i, q = [];\r
 165     return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;\r
 166     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
 167     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r
 168     function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r
 169     function fulfill(value) { resume("next", value); }\r
 170     function reject(value) { resume("throw", value); }\r
 171     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r
 172 }\r
 173 \r
 174 export function __asyncDelegator(o) {\r
 175     var i, p;\r
 176     return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;\r
 177     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
 178 }\r
 179 \r
 180 export function __asyncValues(o) {\r
 181     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");\r
 182     var m = o[Symbol.asyncIterator], i;\r
 183     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
 184     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
 185     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r
 186 }\r
 187 \r
 188 export function __makeTemplateObject(cooked, raw) {\r
 189     if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }\r
 190     return cooked;\r
 191 };\r
 192 \r
 193 export function __importStar(mod) {\r
 194     if (mod && mod.__esModule) return mod;\r
 195     var result = {};\r
 196     if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r
 197     result.default = mod;\r
 198     return result;\r
 199 }\r
 200 \r
 201 export function __importDefault(mod) {\r
 202     return (mod && mod.__esModule) ? mod : { default: mod };\r
 203 }\r
 204 \r
 205 export function __classPrivateFieldGet(receiver, privateMap) {\r
 206     if (!privateMap.has(receiver)) {\r
 207         throw new TypeError("attempted to get private field on non-instance");\r
 208     }\r
 209     return privateMap.get(receiver);\r
 210 }\r
 211 \r
 212 export function __classPrivateFieldSet(receiver, privateMap, value) {\r
 213     if (!privateMap.has(receiver)) {\r
 214         throw new TypeError("attempted to set private field on non-instance");\r
 215     }\r
 216     privateMap.set(receiver, value);\r
 217     return value;\r
 218 }\r