@progressive-development/pd-spa-helper 0.3.102 → 0.3.103

package/dist/node_modules/rxjs/dist/esm5/internal/operators/withLatestFrom.js

@@ -0,0 +1,43 @@
+import { __spreadArray, __read } from "../../../../../tslib/tslib.es6.js";
+import { operate } from "../util/lift.js";
+import { createOperatorSubscriber } from "./OperatorSubscriber.js";
+import { innerFrom } from "../observable/innerFrom.js";
+import { identity } from "../util/identity.js";
+import { noop } from "../util/noop.js";
+import { popResultSelector } from "../util/args.js";
+function withLatestFrom() {
+  var inputs = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    inputs[_i] = arguments[_i];
+  }
+  var project = popResultSelector(inputs);
+  return operate(function(source, subscriber) {
+    var len = inputs.length;
+    var otherValues = new Array(len);
+    var hasValue = inputs.map(function() {
+      return false;
+    });
+    var ready = false;
+    var _loop_1 = function(i2) {
+      innerFrom(inputs[i2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
+        otherValues[i2] = value;
+        if (!ready && !hasValue[i2]) {
+          hasValue[i2] = true;
+          (ready = hasValue.every(identity)) && (hasValue = null);
+        }
+      }, noop));
+    };
+    for (var i = 0; i < len; i++) {
+      _loop_1(i);
+    }
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      if (ready) {
+        var values = __spreadArray([value], __read(otherValues));
+        subscriber.next(project ? project.apply(void 0, __spreadArray([], __read(values))) : values);
+      }
+    }));
+  });
+}
+export {
+  withLatestFrom
+};

package/dist/node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js

@@ -0,0 +1,18 @@
+import { __spreadArray, __read } from "../../../../../tslib/tslib.es6.js";
+var timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+export {
+  timeoutProvider
+};

package/dist/node_modules/rxjs/dist/esm5/internal/symbol/iterator.js

@@ -0,0 +1,11 @@
+function getSymbolIterator() {
+  if (typeof Symbol !== "function" || !Symbol.iterator) {
+    return "@@iterator";
+  }
+  return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+export {
+  getSymbolIterator,
+  iterator
+};

package/dist/node_modules/rxjs/dist/esm5/internal/symbol/observable.js

@@ -0,0 +1,6 @@
+var observable = function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+}();
+export {
+  observable
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js

@@ -0,0 +1,14 @@
+import { createErrorClass } from "./createErrorClass.js";
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+  };
+});
+export {
+  UnsubscriptionError
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/args.js

@@ -0,0 +1,10 @@
+import { isFunction } from "./isFunction.js";
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popResultSelector(args) {
+  return isFunction(last(args)) ? args.pop() : void 0;
+}
+export {
+  popResultSelector
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/arrRemove.js

@@ -0,0 +1,9 @@
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+export {
+  arrRemove
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js

@@ -0,0 +1,13 @@
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+export {
+  createErrorClass
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/errorContext.js

@@ -0,0 +1,8 @@
+function errorContext(cb) {
+  {
+    cb();
+  }
+}
+export {
+  errorContext
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js

@@ -0,0 +1,23 @@
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  if (repeat === void 0) {
+    repeat = false;
+  }
+  var scheduleSubscription = scheduler.schedule(function() {
+    work();
+    if (repeat) {
+      parentSubscription.add(this.schedule(null, delay));
+    } else {
+      this.unsubscribe();
+    }
+  }, delay);
+  parentSubscription.add(scheduleSubscription);
+  if (!repeat) {
+    return scheduleSubscription;
+  }
+}
+export {
+  executeSchedule
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/identity.js

@@ -0,0 +1,6 @@
+function identity(x) {
+  return x;
+}
+export {
+  identity
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js

@@ -0,0 +1,6 @@
+var isArrayLike = function(x) {
+  return x && typeof x.length === "number" && typeof x !== "function";
+};
+export {
+  isArrayLike
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js

@@ -0,0 +1,7 @@
+import { isFunction } from "./isFunction.js";
+function isAsyncIterable(obj) {
+  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+export {
+  isAsyncIterable
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isFunction.js

@@ -0,0 +1,6 @@
+function isFunction(value) {
+  return typeof value === "function";
+}
+export {
+  isFunction
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js

@@ -0,0 +1,8 @@
+import { observable } from "../symbol/observable.js";
+import { isFunction } from "./isFunction.js";
+function isInteropObservable(input) {
+  return isFunction(input[observable]);
+}
+export {
+  isInteropObservable
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isIterable.js

@@ -0,0 +1,8 @@
+import { iterator } from "../symbol/iterator.js";
+import { isFunction } from "./isFunction.js";
+function isIterable(input) {
+  return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+}
+export {
+  isIterable
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isPromise.js

@@ -0,0 +1,7 @@
+import { isFunction } from "./isFunction.js";
+function isPromise(value) {
+  return isFunction(value === null || value === void 0 ? void 0 : value.then);
+}
+export {
+  isPromise
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js

@@ -0,0 +1,46 @@
+import { __asyncGenerator, __generator, __await } from "../../../../../tslib/tslib.es6.js";
+import { isFunction } from "./isFunction.js";
+function readableStreamLikeToAsyncGenerator(readableStream) {
+  return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+    var reader, _a, value, done;
+    return __generator(this, function(_b) {
+      switch (_b.label) {
+        case 0:
+          reader = readableStream.getReader();
+          _b.label = 1;
+        case 1:
+          _b.trys.push([1, , 9, 10]);
+          _b.label = 2;
+        case 2:
+          return [4, __await(reader.read())];
+        case 3:
+          _a = _b.sent(), value = _a.value, done = _a.done;
+          if (!done) return [3, 5];
+          return [4, __await(void 0)];
+        case 4:
+          return [2, _b.sent()];
+        case 5:
+          return [4, __await(value)];
+        case 6:
+          return [4, _b.sent()];
+        case 7:
+          _b.sent();
+          return [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          reader.releaseLock();
+          return [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function isReadableStreamLike(obj) {
+  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+export {
+  isReadableStreamLike,
+  readableStreamLikeToAsyncGenerator
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/lift.js

@@ -0,0 +1,22 @@
+import { isFunction } from "./isFunction.js";
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source)) {
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+export {
+  hasLift,
+  operate
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/noop.js

@@ -0,0 +1,5 @@
+function noop() {
+}
+export {
+  noop
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/pipe.js

@@ -0,0 +1,17 @@
+import { identity } from "./identity.js";
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+export {
+  pipeFromArray
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js

@@ -0,0 +1,11 @@
+import { timeoutProvider } from "../scheduler/timeoutProvider.js";
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    {
+      throw err;
+    }
+  });
+}
+export {
+  reportUnhandledError
+};

package/dist/node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js

@@ -0,0 +1,6 @@
+function createInvalidObservableTypeError(input) {
+  return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+export {
+  createInvalidObservableTypeError
+};

package/dist/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,240 @@
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+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 __());
+}
+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;
+}
+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());
+  });
+}
+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;
+  return g = { next: verb(0), "throw": verb(1), "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 };
+  }
+}
+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.");
+}
+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 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+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));
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+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 = {}, 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]);
+  }
+}
+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(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+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 {
+  __asyncGenerator,
+  __asyncValues,
+  __await,
+  __awaiter,
+  __extends,
+  __generator,
+  __read,
+  __rest,
+  __spreadArray,
+  __values
+};