@vxrn/tslib-lite 1.1.291

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+  Copyright (c) 2020 Nate Wienert
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

package/index.mjs

@@ -0,0 +1,607 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function (d, b) {
+  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]
+    }
+  return extendStatics(d, b)
+}
+
+export function __extends(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 __())
+}
+
+export var __assign = function () {
+  __assign =
+    Object.assign ||
+    function __assign(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
+    }
+  return __assign.apply(this, arguments)
+}
+
+export function __rest(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
+}
+
+export function __decorate(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
+}
+
+export function __param(paramIndex, decorator) {
+  return function (target, key) {
+    decorator(target, key, paramIndex)
+  }
+}
+
+export function __esDecorate(
+  ctor,
+  descriptorIn,
+  decorators,
+  contextIn,
+  initializers,
+  extraInitializers
+) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== 'function') throw new TypeError('Function expected')
+    return f
+  }
+  var kind = contextIn.kind,
+    key = kind === 'getter' ? 'get' : kind === 'setter' ? 'set' : 'value'
+  var target = !descriptorIn && ctor ? (contextIn['static'] ? ctor : ctor.prototype) : null
+  var descriptor =
+    descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {})
+  var _,
+    done = false
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {}
+    for (var p in contextIn) context[p] = p === 'access' ? {} : contextIn[p]
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p]
+    context.addInitializer = function (f) {
+      if (done) throw new TypeError('Cannot add initializers after decoration has completed')
+      extraInitializers.push(accept(f || null))
+    }
+    var result = (0, decorators[i])(
+      kind === 'accessor' ? { get: descriptor.get, set: descriptor.set } : descriptor[key],
+      context
+    )
+    if (kind === 'accessor') {
+      if (result === void 0) continue
+      if (result === null || typeof result !== 'object') throw new TypeError('Object expected')
+      if ((_ = accept(result.get))) descriptor.get = _
+      if ((_ = accept(result.set))) descriptor.set = _
+      if ((_ = accept(result.init))) initializers.unshift(_)
+    } else if ((_ = accept(result))) {
+      if (kind === 'field') initializers.unshift(_)
+      else descriptor[key] = _
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor)
+  done = true
+}
+
+export function __runInitializers(thisArg, initializers, value) {
+  var useValue = arguments.length > 2
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg)
+  }
+  return useValue ? value : void 0
+}
+
+export function __propKey(x) {
+  return typeof x === 'symbol' ? x : ''.concat(x)
+}
+
+export function __setFunctionName(f, name, prefix) {
+  if (typeof name === 'symbol') name = name.description ? '['.concat(name.description, ']') : ''
+  return Object.defineProperty(f, 'name', {
+    configurable: true,
+    value: prefix ? ''.concat(prefix, ' ', name) : name,
+  })
+}
+
+export function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
+    return Reflect.metadata(metadataKey, metadataValue)
+}
+
+export function __awaiter(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())
+  })
+}
+
+export function __generator(thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1]
+        return t[1]
+      },
+      trys: [],
+      ops: [],
+    },
+    f,
+    y,
+    t,
+    g = Object.create((typeof Iterator === 'function' ? Iterator : Object).prototype)
+  return (
+    (g.next = verb(0)),
+    (g['throw'] = verb(1)),
+    (g['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 ((g && ((g = 0), op[0] && (_ = 0)), _))
+      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 }
+  }
+}
+
+export var __createBinding = Object.create
+  ? function (o, m, k, k2) {
+      if (k2 === undefined) k2 = k
+      var desc = Object.getOwnPropertyDescriptor(m, k)
+      if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function () {
+            return m[k]
+          },
+        }
+      }
+      Object.defineProperty(o, k2, desc)
+    }
+  : function (o, m, k, k2) {
+      if (k2 === undefined) k2 = k
+      o[k2] = m[k]
+    }
+
+export function __exportStar(m, o) {
+  for (var p in m)
+    if (p !== 'default' && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p)
+}
+
+export function __values(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.')
+}
+
+export function __read(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: error }
+  } finally {
+    try {
+      if (r && !r.done && (m = i['return'])) m.call(i)
+    } finally {
+      if (e) throw e.error
+    }
+  }
+  return ar
+}
+
+/** @deprecated */
+export function __spread() {
+  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]))
+  return ar
+}
+
+/** @deprecated */
+export function __spreadArrays() {
+  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
+}
+
+export function __spreadArray(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))
+}
+
+export function __await(v) {
+  return this instanceof __await ? ((this.v = v), this) : new __await(v)
+}
+
+export function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.')
+  var g = generator.apply(thisArg, _arguments || []),
+    i,
+    q = []
+  return (
+    (i = Object.create((typeof AsyncIterator === 'function' ? AsyncIterator : Object).prototype)),
+    verb('next'),
+    verb('throw'),
+    verb('return', awaitReturn),
+    (i[Symbol.asyncIterator] = function () {
+      return this
+    }),
+    i
+  )
+  function awaitReturn(f) {
+    return function (v) {
+      return Promise.resolve(v).then(f, reject)
+    }
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function (v) {
+        return new Promise(function (a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v)
+        })
+      }
+      if (f) i[n] = f(i[n])
+    }
+  }
+  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])
+  }
+}
+
+export function __asyncDelegator(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: false } : f ? f(v) : v
+        }
+      : f
+  }
+}
+
+export function __asyncValues(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 (v) {
+      resolve({ value: v, done: d })
+    }, reject)
+  }
+}
+
+export function __makeTemplateObject(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
+    }
+
+export function __importStar(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
+}
+
+export function __importDefault(mod) {
+  return mod && mod.__esModule ? mod : { default: mod }
+}
+
+export function __classPrivateFieldGet(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)
+}
+
+export function __classPrivateFieldSet(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
+  )
+}
+
+export function __classPrivateFieldIn(state, receiver) {
+  if (receiver === null || (typeof receiver !== 'object' && typeof receiver !== 'function'))
+    throw new TypeError("Cannot use 'in' operator on non-object")
+  return typeof state === 'function' ? receiver === state : state.has(receiver)
+}
+
+export function __addDisposableResource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== 'object' && typeof value !== 'function')
+      throw new TypeError('Object expected.')
+    var dispose, inner
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError('Symbol.asyncDispose is not defined.')
+      dispose = value[Symbol.asyncDispose]
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError('Symbol.dispose is not defined.')
+      dispose = value[Symbol.dispose]
+      if (async) inner = dispose
+    }
+    if (typeof dispose !== 'function') throw new TypeError('Object not disposable.')
+    if (inner)
+      dispose = function () {
+        try {
+          inner.call(this)
+        } catch (e) {
+          return Promise.reject(e)
+        }
+      }
+    env.stack.push({ value: value, dispose: dispose, async: async })
+  } else if (async) {
+    env.stack.push({ async: true })
+  }
+  return value
+}
+
+var _SuppressedError =
+  typeof SuppressedError === 'function'
+    ? SuppressedError
+    : function (error, suppressed, message) {
+        var e = new Error(message)
+        return (e.name = 'SuppressedError'), (e.error = error), (e.suppressed = suppressed), e
+      }
+
+export function __disposeResources(env) {
+  function fail(e) {
+    env.error = env.hasError
+      ? new _SuppressedError(e, env.error, 'An error was suppressed during disposal.')
+      : e
+    env.hasError = true
+  }
+  var r,
+    s = 0
+  function next() {
+    while ((r = env.stack.pop())) {
+      try {
+        if (!r.async && s === 1) return (s = 0), env.stack.push(r), Promise.resolve().then(next)
+        if (r.dispose) {
+          var result = r.dispose.call(r.value)
+          if (r.async)
+            return (
+              (s |= 2),
+              Promise.resolve(result).then(next, function (e) {
+                fail(e)
+                return next()
+              })
+            )
+        } else s |= 1
+      } catch (e) {
+        fail(e)
+      }
+    }
+    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve()
+    if (env.hasError) throw env.error
+  }
+  return next()
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@vxrn/tslib-lite",
+  "sideEffects": false,
+  "version": "1.1.291",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./index.mjs"
+  }
+}