@uwrl/qc-utils 0.0.14 → 0.0.17

package/dist/index.js

@@ -1,122 +1,1407 @@
-var f = /* @__PURE__ */ ((r) => (r.ADD_POINTS = "ADD_POINTS", r.CHANGE_VALUES = "CHANGE_VALUES", r.DELETE_POINTS = "DELETE_POINTS", r.DRIFT_CORRECTION = "DRIFT_CORRECTION", r.INTERPOLATE = "INTERPOLATE", r.SHIFT_DATETIMES = "SHIFT_DATETIMES", r.FILL_GAPS = "FILL_GAPS", r))(f || {}), _ = /* @__PURE__ */ ((r) => (r.FIND_GAPS = "FIND_GAPS", r.PERSISTENCE = "PERSISTENCE", r.RATE_OF_CHANGE = "RATE_OF_CHANGE", r.VALUE_THRESHOLD = "VALUE_THRESHOLD", r))(_ || {});
-const X = {
-  "Less than": (r, t) => r < t,
-  "Less than or equal to": (r, t) => r <= t,
-  "Greater than": (r, t) => r > t,
-  "Greater than or equal to": (r, t) => r >= t,
-  Equal: (r, t) => r == t,
-  "Start datetime": (r, t) => r == t,
-  "End datetime": (r, t) => r == t
+var $ = /* @__PURE__ */ ((e) => (e.SECOND = "s", e.MINUTE = "m", e.HOUR = "h", e.DAY = "D", e.WEEK = "W", e.MONTH = "M", e.YEAR = "Y", e))($ || {}), v = /* @__PURE__ */ ((e) => (e.ADD_POINTS = "ADD_POINTS", e.CHANGE_VALUES = "CHANGE_VALUES", e.DELETE_POINTS = "DELETE_POINTS", e.DRIFT_CORRECTION = "DRIFT_CORRECTION", e.INTERPOLATE = "INTERPOLATE", e.SHIFT_DATETIMES = "SHIFT_DATETIMES", e.FILL_GAPS = "FILL_GAPS", e))(v || {}), P = /* @__PURE__ */ ((e) => (e.FIND_GAPS = "FIND_GAPS", e.PERSISTENCE = "PERSISTENCE", e.CHANGE = "CHANGE", e.RATE_OF_CHANGE = "RATE_OF_CHANGE", e.VALUE_THRESHOLD = "VALUE_THRESHOLD", e))(P || {}), Me = /* @__PURE__ */ ((e) => (e.LT = "Less than", e.LTE = "Less than or equal to", e.GT = "Greater than", e.GTE = "Greater than or equal to", e.E = "Equal", e.START = "Start datetime", e.END = "End datetime", e))(Me || {});
+const Ye = {
+  "Less than": (e, t) => e < t,
+  "Less than or equal to": (e, t) => e <= t,
+  "Greater than": (e, t) => e > t,
+  "Greater than or equal to": (e, t) => e >= t,
+  Equal: (e, t) => e == t,
+  "Start datetime": (e, t) => e == t,
+  "End datetime": (e, t) => e == t
 };
-var E = /* @__PURE__ */ ((r) => (r.ADD = "ADD", r.SUB = "SUB", r.MULT = "MULT", r.DIV = "DIV", r.ASSIGN = "ASSIGN", r))(E || {});
-const x = {
-  "Less than": (r, t) => r < t,
-  "Less than or equal to": (r, t) => r <= t,
-  "Greater than": (r, t) => r > t,
-  "Greater than or equal to": (r, t) => r >= t,
-  Equal: (r, t) => r == t
-}, I = `(function(){"use strict";self.onmessage=o=>{const{bufferX:s,bufferY:n,outputBufferX:u,outputBufferY:f,start:l,end:y,deleteSegment:a,startTarget:c}=o.data,A=new Float64Array(s),d=new Float32Array(n),g=new Float64Array(u),p=new Float32Array(f);let e=0,r=c;for(let t=l;t<=y;t++)e<a.length&&t===a[e]?e++:(g[r]=A[t],p[r]=d[t],r++);self.postMessage("Done")}})();
-`, b = typeof self < "u" && self.Blob && new Blob([I], { type: "text/javascript;charset=utf-8" });
-function U(r) {
+var R = /* @__PURE__ */ ((e) => (e.ADD = "ADD", e.SUB = "SUB", e.MULT = "MULT", e.DIV = "DIV", e.ASSIGN = "ASSIGN", e))(R || {}), je = /* @__PURE__ */ ((e) => (e.LT = "Less than", e.LTE = "Less than or equal to", e.GT = "Greater than", e.GTE = "Greater than or equal to", e.E = "Equal", e))(je || {});
+const ie = {
+  "Less than": (e, t) => e < t,
+  "Less than or equal to": (e, t) => e <= t,
+  "Greater than": (e, t) => e > t,
+  "Greater than or equal to": (e, t) => e >= t,
+  Equal: (e, t) => e == t
+};
+class He {
+  id;
+  thingId;
+  link;
+  frequency;
+  path;
+  datastreamIds;
+  publicResource;
+  constructor() {
+    this.id = "", this.thingId = "", this.link = "", this.frequency = null, this.path = "HydroShare", this.datastreamIds = [], this.publicResource = !1;
+  }
+}
+class wt extends He {
+  resourceTitle;
+  resourceAbstract;
+  resourceKeywords;
+  constructor() {
+    super(), this.resourceTitle = void 0, this.resourceAbstract = void 0, this.resourceKeywords = void 0;
+  }
+}
+class Ge {
+  latitude;
+  longitude;
+  elevation_m;
+  elevationDatum;
+  state;
+  county;
+  country;
+  constructor() {
+    this.elevationDatum = "WGS84", this.state = "", this.county = "", this.country = "";
+  }
+}
+class Tt {
+  id;
+  workspaceId;
+  name;
+  location = new Ge();
+  tags;
+  hydroShareArchive;
+  siteType;
+  samplingFeatureCode;
+  isPrivate;
+  description;
+  samplingFeatureType;
+  dataDisclaimer;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.name = "", this.tags = [], this.siteType = "", this.samplingFeatureCode = "", this.isPrivate = !1, this.description = "", this.samplingFeatureType = "Site", this.dataDisclaimer = "";
+  }
+}
+class At {
+  id;
+  workspaceId;
+  name;
+  description;
+  thingId;
+  observationType;
+  resultType;
+  status;
+  sampledMedium;
+  noDataValue;
+  aggregationStatistic;
+  unitId;
+  observedPropertyId;
+  sensorId;
+  processingLevelId;
+  isPrivate;
+  isVisible;
+  phenomenonBeginTime;
+  phenomenonEndTime;
+  intendedTimeSpacing;
+  intendedTimeSpacingUnit;
+  timeAggregationInterval;
+  timeAggregationIntervalUnit;
+  dataSourceId;
+  valueCount;
+  constructor(t) {
+    this.id = "", this.workspaceId = "", this.name = "", this.description = "", this.thingId = t || "", this.observationType = "OM_Measurement", this.resultType = "Time Series Coverage", this.sampledMedium = "", this.noDataValue = -9999, this.aggregationStatistic = "", this.unitId = "", this.observedPropertyId = "", this.sensorId = "", this.processingLevelId = "", this.timeAggregationInterval = null, this.timeAggregationIntervalUnit = "seconds", this.isPrivate = !0, this.isVisible = !0, this.valueCount = 0;
+  }
+}
+class Lt {
+  id;
+  workspaceId;
+  name;
+  symbol;
+  definition;
+  type;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.name = "", this.symbol = "", this.definition = "", this.type = "";
+  }
+}
+class It {
+  id;
+  workspaceId;
+  name;
+  description;
+  manufacturer;
+  model;
+  methodType;
+  methodCode;
+  methodLink;
+  encodingType;
+  modelLink;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.name = "", this.description = "", this.manufacturer = "", this.model = "", this.methodType = "Instrument Deployment", this.methodCode = "", this.methodLink = "", this.encodingType = "application/json", this.modelLink = "";
+  }
+}
+class Dt {
+  id;
+  workspaceId;
+  name;
+  definition;
+  description;
+  type;
+  code;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.name = "", this.definition = "", this.description = "", this.type = "Hydrology", this.code = "";
+  }
+}
+class Ot {
+  id;
+  workspaceId;
+  code;
+  definition;
+  explanation;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.code = "", this.definition = "", this.explanation = "";
+  }
+}
+class kt {
+  id;
+  workspaceId;
+  code;
+  description;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.code = "", this.description = "";
+  }
+}
+class Ft {
+  name;
+  code;
+  type;
+  description;
+  link;
+  constructor() {
+  }
+}
+class Pt {
+  id;
+  email;
+  password;
+  firstName;
+  middleName;
+  lastName;
+  phone;
+  address;
+  organization;
+  type;
+  link;
+  accountType;
+  hydroShareConnected;
+  constructor() {
+    this.id = "", this.email = "", this.password = "", this.firstName = "", this.middleName = "", this.lastName = "", this.phone = "", this.address = "", this.type = "", this.link = "", this.accountType = "standard", this.hydroShareConnected = !1;
+  }
+}
+class Rt {
+  id;
+  name;
+  iconLink;
+  signupEnabled;
+  connectEnabled;
+  constructor() {
+    this.id = "", this.name = "", this.iconLink = "", this.signupEnabled = !0, this.connectEnabled = !0;
+  }
+}
+var We = /* @__PURE__ */ ((e) => (e.Global = "*", e.View = "view", e.Create = "create", e.Edit = "edit", e.Delete = "delete", e))(We || {}), Xe = /* @__PURE__ */ ((e) => (e.Global = "*", e.Workspace = "Workspace", e.Collaborator = "Collaborator", e.Thing = "Thing", e.Datastream = "Datastream", e.Sensor = "Sensor", e.Unit = "Unit", e.ObservedProperty = "ObservedProperty", e.ProcessingLevel = "ProcessingLevel", e.Observation = "Observation", e))(Xe || {});
+class xt {
+  id = "";
+  key = "";
+  name = "";
+  description = "";
+  isActive = !0;
+  expiresAt = "";
+  createdAt = "";
+  lastUsed = "";
+  workspaceId = "";
+  role = null;
+  constructor(t) {
+    Object.assign(this, t);
+  }
+}
+class Nt {
+  id;
+  name;
+  isPrivate;
+  owner;
+  collaboratorRole;
+  pendingTransferTo;
+  constructor() {
+    this.id = "", this.name = "", this.isPrivate = !1, this.owner = null, this.collaboratorRole = null, this.pendingTransferTo = null;
+  }
+}
+class Ct {
+  user;
+  role;
+  constructor() {
+    this.user = {
+      phone: "",
+      address: "",
+      link: "",
+      type: "",
+      name: "",
+      email: "",
+      organizationName: ""
+    }, this.role = {
+      name: "",
+      description: "",
+      id: "",
+      isApikeyRole: !1,
+      isUserRole: !1,
+      workspaceId: "",
+      permissions: []
+    };
+  }
+}
+function _e() {
+  const e = "csrftoken=", r = decodeURIComponent(document.cookie).split(";");
+  for (const s of r) {
+    const a = s.trim();
+    if (a.startsWith(e))
+      return a.substring(e.length);
+  }
+  return null;
+}
+function we(e) {
+  let t = e.headers ? { ...e.headers } : {}, r;
+  return e.body !== void 0 && (r = typeof e.body == "string" || e.body instanceof FormData ? e.body : JSON.stringify(e.body)), t["X-CSRFToken"] = _e() || "", {
+    ...e,
+    headers: t,
+    body: r,
+    credentials: "omit"
+  };
+}
+function qe(e) {
+  if (Array.isArray(e?.errors) && e.errors.length && (e = e.errors[0]), typeof e != "object" || e === null)
+    return "An unknown error occurred.";
+  const t = ["message", "detail", "error"];
+  for (const r of t)
+    if (e[r]) return e[r];
+  return "An unknown error occurred.";
+}
+async function Te(e) {
+  if (e.headers.get("Content-Length") === "0" || e.statusText === "No Content")
+    return null;
+  const t = e.headers.get("content-type") || "";
+  let r = null;
+  if (t.includes("application/json"))
+    try {
+      r = await e.json();
+    } catch (a) {
+      console.error("Failed to parse error JSON:", a);
+    }
+  else if (t.includes("text/csv"))
+    try {
+      r = await e.blob();
+    } catch (a) {
+      console.error("Failed to parse error JSON:", a);
+    }
+  if (e.ok || e.status === 401) return r;
+  const s = {
+    status: e.status,
+    message: qe(r)
+  };
+  throw console.error("API response not OK:", s.message), s;
+}
+var Q = function(e, t) {
+  return Q = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, s) {
+    r.__proto__ = s;
+  } || function(r, s) {
+    for (var a in s) Object.prototype.hasOwnProperty.call(s, a) && (r[a] = s[a]);
+  }, Q(e, t);
+};
+function Y(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  Q(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+function K(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], s = 0;
+  if (r) return r.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && s >= e.length && (e = void 0), { value: e && e[s++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function Z(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var s = r.call(e), a, n = [], i;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(a = s.next()).done; ) n.push(a.value);
+  } catch (c) {
+    i = { error: c };
+  } finally {
+    try {
+      a && !a.done && (r = s.return) && r.call(s);
+    } finally {
+      if (i) throw i.error;
+    }
+  }
+  return n;
+}
+function ee(e, t, r) {
+  if (r || arguments.length === 2) for (var s = 0, a = t.length, n; s < a; s++)
+    (n || !(s in t)) && (n || (n = Array.prototype.slice.call(t, 0, s)), n[s] = t[s]);
+  return e.concat(n || Array.prototype.slice.call(t));
+}
+function w(e) {
+  return typeof e == "function";
+}
+function Ae(e) {
+  var t = function(s) {
+    Error.call(s), s.stack = new Error().stack;
+  }, r = e(t);
+  return r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r;
+}
+var W = Ae(function(e) {
+  return function(r) {
+    e(this), this.message = r ? r.length + ` errors occurred during unsubscription:
+` + r.map(function(s, a) {
+      return a + 1 + ") " + s.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = r;
+  };
+});
+function te(e, t) {
+  if (e) {
+    var r = e.indexOf(t);
+    0 <= r && e.splice(r, 1);
+  }
+}
+var j = function() {
+  function e(t) {
+    this.initialTeardown = t, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t, r, s, a, n;
+    if (!this.closed) {
+      this.closed = !0;
+      var i = this._parentage;
+      if (i)
+        if (this._parentage = null, Array.isArray(i))
+          try {
+            for (var c = K(i), h = c.next(); !h.done; h = c.next()) {
+              var u = h.value;
+              u.remove(this);
+            }
+          } catch (b) {
+            t = { error: b };
+          } finally {
+            try {
+              h && !h.done && (r = c.return) && r.call(c);
+            } finally {
+              if (t) throw t.error;
+            }
+          }
+        else
+          i.remove(this);
+      var d = this.initialTeardown;
+      if (w(d))
+        try {
+          d();
+        } catch (b) {
+          n = b instanceof W ? b.errors : [b];
+        }
+      var l = this._finalizers;
+      if (l) {
+        this._finalizers = null;
+        try {
+          for (var p = K(l), m = p.next(); !m.done; m = p.next()) {
+            var A = m.value;
+            try {
+              ce(A);
+            } catch (b) {
+              n = n ?? [], b instanceof W ? n = ee(ee([], Z(n)), Z(b.errors)) : n.push(b);
+            }
+          }
+        } catch (b) {
+          s = { error: b };
+        } finally {
+          try {
+            m && !m.done && (a = p.return) && a.call(p);
+          } finally {
+            if (s) throw s.error;
+          }
+        }
+      }
+      if (n)
+        throw new W(n);
+    }
+  }, e.prototype.add = function(t) {
+    var r;
+    if (t && t !== this)
+      if (this.closed)
+        ce(t);
+      else {
+        if (t instanceof e) {
+          if (t.closed || t._hasParent(this))
+            return;
+          t._addParent(this);
+        }
+        (this._finalizers = (r = this._finalizers) !== null && r !== void 0 ? r : []).push(t);
+      }
+  }, e.prototype._hasParent = function(t) {
+    var r = this._parentage;
+    return r === t || Array.isArray(r) && r.includes(t);
+  }, e.prototype._addParent = function(t) {
+    var r = this._parentage;
+    this._parentage = Array.isArray(r) ? (r.push(t), r) : r ? [r, t] : t;
+  }, e.prototype._removeParent = function(t) {
+    var r = this._parentage;
+    r === t ? this._parentage = null : Array.isArray(r) && te(r, t);
+  }, e.prototype.remove = function(t) {
+    var r = this._finalizers;
+    r && te(r, t), t instanceof e && t._removeParent(this);
+  }, e.EMPTY = function() {
+    var t = new e();
+    return t.closed = !0, t;
+  }(), e;
+}(), Le = j.EMPTY;
+function Ie(e) {
+  return e instanceof j || e && "closed" in e && w(e.remove) && w(e.add) && w(e.unsubscribe);
+}
+function ce(e) {
+  w(e) ? e() : e.unsubscribe();
+}
+var Ve = {
+  Promise: void 0
+}, ze = {
+  setTimeout: function(e, t) {
+    for (var r = [], s = 2; s < arguments.length; s++)
+      r[s - 2] = arguments[s];
+    return setTimeout.apply(void 0, ee([e, t], Z(r)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function Je(e) {
+  ze.setTimeout(function() {
+    throw e;
+  });
+}
+function he() {
+}
+function U(e) {
+  e();
+}
+var De = function(e) {
+  Y(t, e);
+  function t(r) {
+    var s = e.call(this) || this;
+    return s.isStopped = !1, r ? (s.destination = r, Ie(r) && r.add(s)) : s.destination = Ze, s;
+  }
+  return t.create = function(r, s, a) {
+    return new re(r, s, a);
+  }, t.prototype.next = function(r) {
+    this.isStopped || this._next(r);
+  }, t.prototype.error = function(r) {
+    this.isStopped || (this.isStopped = !0, this._error(r));
+  }, t.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, t.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, t.prototype._next = function(r) {
+    this.destination.next(r);
+  }, t.prototype._error = function(r) {
+    try {
+      this.destination.error(r);
+    } finally {
+      this.unsubscribe();
+    }
+  }, t.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, t;
+}(j), Qe = function() {
+  function e(t) {
+    this.partialObserver = t;
+  }
+  return e.prototype.next = function(t) {
+    var r = this.partialObserver;
+    if (r.next)
+      try {
+        r.next(t);
+      } catch (s) {
+        C(s);
+      }
+  }, e.prototype.error = function(t) {
+    var r = this.partialObserver;
+    if (r.error)
+      try {
+        r.error(t);
+      } catch (s) {
+        C(s);
+      }
+    else
+      C(t);
+  }, e.prototype.complete = function() {
+    var t = this.partialObserver;
+    if (t.complete)
+      try {
+        t.complete();
+      } catch (r) {
+        C(r);
+      }
+  }, e;
+}(), re = function(e) {
+  Y(t, e);
+  function t(r, s, a) {
+    var n = e.call(this) || this, i;
+    return w(r) || !r ? i = {
+      next: r ?? void 0,
+      error: s ?? void 0,
+      complete: a ?? void 0
+    } : i = r, n.destination = new Qe(i), n;
+  }
+  return t;
+}(De);
+function C(e) {
+  Je(e);
+}
+function Ke(e) {
+  throw e;
+}
+var Ze = {
+  closed: !0,
+  next: he,
+  error: Ke,
+  complete: he
+}, et = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function tt(e) {
+  return e;
+}
+function rt(e) {
+  return e.length === 0 ? tt : e.length === 1 ? e[0] : function(r) {
+    return e.reduce(function(s, a) {
+      return a(s);
+    }, r);
+  };
+}
+var ue = function() {
+  function e(t) {
+    t && (this._subscribe = t);
+  }
+  return e.prototype.lift = function(t) {
+    var r = new e();
+    return r.source = this, r.operator = t, r;
+  }, e.prototype.subscribe = function(t, r, s) {
+    var a = this, n = at(t) ? t : new re(t, r, s);
+    return U(function() {
+      var i = a, c = i.operator, h = i.source;
+      n.add(c ? c.call(n, h) : h ? a._subscribe(n) : a._trySubscribe(n));
+    }), n;
+  }, e.prototype._trySubscribe = function(t) {
+    try {
+      return this._subscribe(t);
+    } catch (r) {
+      t.error(r);
+    }
+  }, e.prototype.forEach = function(t, r) {
+    var s = this;
+    return r = le(r), new r(function(a, n) {
+      var i = new re({
+        next: function(c) {
+          try {
+            t(c);
+          } catch (h) {
+            n(h), i.unsubscribe();
+          }
+        },
+        error: n,
+        complete: a
+      });
+      s.subscribe(i);
+    });
+  }, e.prototype._subscribe = function(t) {
+    var r;
+    return (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(t);
+  }, e.prototype[et] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var t = [], r = 0; r < arguments.length; r++)
+      t[r] = arguments[r];
+    return rt(t)(this);
+  }, e.prototype.toPromise = function(t) {
+    var r = this;
+    return t = le(t), new t(function(s, a) {
+      var n;
+      r.subscribe(function(i) {
+        return n = i;
+      }, function(i) {
+        return a(i);
+      }, function() {
+        return s(n);
+      });
+    });
+  }, e.create = function(t) {
+    return new e(t);
+  }, e;
+}();
+function le(e) {
+  var t;
+  return (t = e ?? Ve.Promise) !== null && t !== void 0 ? t : Promise;
+}
+function st(e) {
+  return e && w(e.next) && w(e.error) && w(e.complete);
+}
+function at(e) {
+  return e && e instanceof De || st(e) && Ie(e);
+}
+var nt = Ae(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), Oe = function(e) {
+  Y(t, e);
+  function t() {
+    var r = e.call(this) || this;
+    return r.closed = !1, r.currentObservers = null, r.observers = [], r.isStopped = !1, r.hasError = !1, r.thrownError = null, r;
+  }
+  return t.prototype.lift = function(r) {
+    var s = new de(this, this);
+    return s.operator = r, s;
+  }, t.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new nt();
+  }, t.prototype.next = function(r) {
+    var s = this;
+    U(function() {
+      var a, n;
+      if (s._throwIfClosed(), !s.isStopped) {
+        s.currentObservers || (s.currentObservers = Array.from(s.observers));
+        try {
+          for (var i = K(s.currentObservers), c = i.next(); !c.done; c = i.next()) {
+            var h = c.value;
+            h.next(r);
+          }
+        } catch (u) {
+          a = { error: u };
+        } finally {
+          try {
+            c && !c.done && (n = i.return) && n.call(i);
+          } finally {
+            if (a) throw a.error;
+          }
+        }
+      }
+    });
+  }, t.prototype.error = function(r) {
+    var s = this;
+    U(function() {
+      if (s._throwIfClosed(), !s.isStopped) {
+        s.hasError = s.isStopped = !0, s.thrownError = r;
+        for (var a = s.observers; a.length; )
+          a.shift().error(r);
+      }
+    });
+  }, t.prototype.complete = function() {
+    var r = this;
+    U(function() {
+      if (r._throwIfClosed(), !r.isStopped) {
+        r.isStopped = !0;
+        for (var s = r.observers; s.length; )
+          s.shift().complete();
+      }
+    });
+  }, t.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(t.prototype, "observed", {
+    get: function() {
+      var r;
+      return ((r = this.observers) === null || r === void 0 ? void 0 : r.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), t.prototype._trySubscribe = function(r) {
+    return this._throwIfClosed(), e.prototype._trySubscribe.call(this, r);
+  }, t.prototype._subscribe = function(r) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(r), this._innerSubscribe(r);
+  }, t.prototype._innerSubscribe = function(r) {
+    var s = this, a = this, n = a.hasError, i = a.isStopped, c = a.observers;
+    return n || i ? Le : (this.currentObservers = null, c.push(r), new j(function() {
+      s.currentObservers = null, te(c, r);
+    }));
+  }, t.prototype._checkFinalizedStatuses = function(r) {
+    var s = this, a = s.hasError, n = s.thrownError, i = s.isStopped;
+    a ? r.error(n) : i && r.complete();
+  }, t.prototype.asObservable = function() {
+    var r = new ue();
+    return r.source = this, r;
+  }, t.create = function(r, s) {
+    return new de(r, s);
+  }, t;
+}(ue), de = function(e) {
+  Y(t, e);
+  function t(r, s) {
+    var a = e.call(this) || this;
+    return a.destination = r, a.source = s, a;
+  }
+  return t.prototype.next = function(r) {
+    var s, a;
+    (a = (s = this.destination) === null || s === void 0 ? void 0 : s.next) === null || a === void 0 || a.call(s, r);
+  }, t.prototype.error = function(r) {
+    var s, a;
+    (a = (s = this.destination) === null || s === void 0 ? void 0 : s.error) === null || a === void 0 || a.call(s, r);
+  }, t.prototype.complete = function() {
+    var r, s;
+    (s = (r = this.destination) === null || r === void 0 ? void 0 : r.complete) === null || s === void 0 || s.call(r);
+  }, t.prototype._subscribe = function(r) {
+    var s, a;
+    return (a = (s = this.source) === null || s === void 0 ? void 0 : s.subscribe(r)) !== null && a !== void 0 ? a : Le;
+  }, t;
+}(Oe);
+const ke = 3e3;
+var Fe = /* @__PURE__ */ ((e) => (e.Warning = "warning", e.Success = "success", e.Error = "error", e.Info = "info", e))(Fe || {}), Pe = /* @__PURE__ */ ((e) => (e.Success = "mdi-checkbox-marked-circle", e.Warning = "mdi-alert", e.Error = "mdi-alert-circle", e.Info = "mdi-information", e.None = "none", e))(Pe || {}), Re = /* @__PURE__ */ ((e) => (e.Warning = "Warning", e.Success = "Success", e.Error = "Error", e.Info = "Info", e))(Re || {}), ot = /* @__PURE__ */ ((e) => (e.Center = "center", e.Left = "left", e.Right = "right", e.Bottom = "bottom", e.Top = "top", e))(ot || {});
+class it {
+  constructor(t = "", r = "info", s = "none", a = "Info", n = ke, i = "center", c = !1) {
+    this.message = t, this.color = r, this.icon = s, this.title = a, this.timeout = n, this.position = i, this.visible = c;
+  }
+}
+class ct {
+  static subject = new Oe();
+  static get snack$() {
+    return this.subject.asObservable();
+  }
+  static createSnackbar(t, r) {
+    this.subject.next(
+      new it(
+        t,
+        Fe[r],
+        Pe[r],
+        Re[r],
+        ke,
+        "bottom",
+        !0
+      )
+    );
+  }
+  static success(t) {
+    this.createSnackbar(
+      t,
+      "Success"
+      /* Success */
+    );
+  }
+  static warn(t) {
+    this.createSnackbar(
+      t,
+      "Warning"
+      /* Warning */
+    );
+  }
+  static error(t) {
+    this.createSnackbar(
+      t,
+      "Error"
+      /* Error */
+    );
+  }
+  static info(t) {
+    this.createSnackbar(
+      t,
+      "Info"
+      /* Info */
+    );
+  }
+}
+function xe(e, t) {
+  const r = {};
+  for (let s in t)
+    if (Array.isArray(t[s]))
+      JSON.stringify(e[s]) !== JSON.stringify(t[s]) && (r[s] = t[s]);
+    else if (e[s] && typeof e[s] == "object" && t[s] && typeof t[s] == "object") {
+      const a = xe(e[s], t[s]);
+      Object.keys(a).length > 0 && (r[s] = a);
+    } else JSON.stringify(e[s]) !== JSON.stringify(t[s]) && (r[s] = t[s]);
+  return r;
+}
+function ht(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var X, fe;
+function ut() {
+  if (fe) return X;
+  fe = 1;
+  class e {
+    /// value;
+    /// next;
+    constructor(s) {
+      this.value = s, this.next = void 0;
+    }
+  }
+  class t {
+    // TODO: Use private class fields when targeting Node.js 12.
+    // #_head;
+    // #_tail;
+    // #_size;
+    constructor() {
+      this.clear();
+    }
+    enqueue(s) {
+      const a = new e(s);
+      this._head ? (this._tail.next = a, this._tail = a) : (this._head = a, this._tail = a), this._size++;
+    }
+    dequeue() {
+      const s = this._head;
+      if (s)
+        return this._head = this._head.next, this._size--, s.value;
+    }
+    clear() {
+      this._head = void 0, this._tail = void 0, this._size = 0;
+    }
+    get size() {
+      return this._size;
+    }
+    *[Symbol.iterator]() {
+      let s = this._head;
+      for (; s; )
+        yield s.value, s = s.next;
+    }
+  }
+  return X = t, X;
+}
+var q, pe;
+function lt() {
+  if (pe) return q;
+  pe = 1;
+  const e = ut();
+  return q = (r) => {
+    if (!((Number.isInteger(r) || r === 1 / 0) && r > 0))
+      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+    const s = new e();
+    let a = 0;
+    const n = () => {
+      a--, s.size > 0 && s.dequeue()();
+    }, i = async (u, d, ...l) => {
+      a++;
+      const p = (async () => u(...l))();
+      d(p);
+      try {
+        await p;
+      } catch {
+      }
+      n();
+    }, c = (u, d, ...l) => {
+      s.enqueue(i.bind(null, u, d, ...l)), (async () => (await Promise.resolve(), a < r && s.size > 0 && s.dequeue()()))();
+    }, h = (u, ...d) => new Promise((l) => {
+      c(u, l, ...d);
+    });
+    return Object.defineProperties(h, {
+      activeCount: {
+        get: () => a
+      },
+      pendingCount: {
+        get: () => s.size
+      },
+      clearQueue: {
+        value: () => {
+          s.clear();
+        }
+      }
+    }), h;
+  }, q;
+}
+var dt = lt();
+const ft = /* @__PURE__ */ ht(dt), L = ft(10), pt = 1e3;
+async function O(e, t) {
+  const r = we(t);
+  try {
+    const s = await fetch(e, r);
+    return await Te(s);
+  } catch (s) {
+    throw s instanceof TypeError && ct.error("Network error. Please check your connection."), s;
+  }
+}
+const o = {
+  async fetch(e, t = {}) {
+    return t.method = "GET", await L(() => O(e, t));
+  },
+  async patch(e, t, r = null, s = {}) {
+    if (s.method = "PATCH", s.body = r ? xe(r, t) : t, Object.keys(s.body).length !== 0)
+      return await L(() => O(e, s));
+  },
+  async post(e, t = void 0, r = {}) {
+    return r.method = "POST", r.body = t, await L(() => O(e, r));
+  },
+  async put(e, t = void 0, r = {}) {
+    return r.method = "PUT", r.body = t, await L(() => O(e, r));
+  },
+  async delete(e, t = void 0, r = {}) {
+    return r.method = "DELETE", r.body = t, await L(() => O(e, r));
+  },
+  async paginatedFetch(e, t) {
+    const r = t ?? pt, s = e.includes("?") ? "&" : "?", a = `${e}${s}page_size=${r}&page=1`, n = we({ method: "GET" }), i = await L(() => fetch(a, n)), c = Number(i.headers.get("x-total-pages")) || 1, u = [...await Te(i)];
+    for (let d = 2; d <= c; d++) {
+      const l = `${e}${s}page_size=${r}&page=${d}`, p = await L(() => O(l, { method: "GET" }));
+      u.push(...p);
+    }
+    return u;
+  }
+}, ye = {
+  HTTP: {
+    type: "HTTP",
+    sourceUri: "",
+    placeholderVariables: []
+  },
+  local: {
+    type: "local",
+    sourceUri: "",
+    placeholderVariables: []
+  }
+}, me = {
+  JSON: {
+    type: "JSON",
+    timestamp: {
+      key: "",
+      format: "ISO8601",
+      timezoneMode: "embeddedOffset"
+    },
+    JMESPath: ""
+  },
+  CSV: {
+    type: "CSV",
+    timestamp: {
+      key: "",
+      format: "ISO8601",
+      timezoneMode: "embeddedOffset"
+    },
+    headerRow: 1,
+    dataStartRow: 2,
+    delimiter: ",",
+    identifierType: "name"
+    /* Name */
+  }
+}, ge = {
+  HydroServer: {
+    type: "HydroServer"
+  }
+};
+class Ut {
+  name = "";
+  settings = {
+    type: "SDL",
+    extractor: JSON.parse(JSON.stringify(ye.local)),
+    transformer: JSON.parse(JSON.stringify(me.CSV)),
+    loader: JSON.parse(JSON.stringify(ge.HydroServer)),
+    payloads: []
+  };
+  id = "";
+  workspaceId = "";
+  orchestrationSystem = {
+    id: "",
+    name: "",
+    workspaceId: "",
+    type: ""
+  };
+  schedule = {
+    interval: 15,
+    intervalUnits: "minutes"
+  };
+  status = { paused: !0 };
+  datastreams = [];
+  constructor(t) {
+    Object.assign(this, t);
+  }
+  switchExtractor(t) {
+    this.settings.extractor = JSON.parse(
+      JSON.stringify(ye[t])
+    );
+  }
+  switchTransformer(t) {
+    this.settings.transformer = JSON.parse(
+      JSON.stringify(me[t])
+    );
+  }
+  switchLoader(t) {
+    this.settings.loader = JSON.parse(JSON.stringify(ge[t]));
+  }
+}
+function be(e) {
+  return {
+    name: e.name,
+    settings: e.settings,
+    workspaceId: e.workspaceId,
+    orchestrationSystemId: e.orchestrationSystem.id,
+    schedule: e.schedule,
+    status: e.status
+  };
+}
+const S = "https://lro.hydroserver.org/api", ae = `${S}/auth`, E = `${ae}/browser/account`, V = `${ae}/browser/session`, B = `${ae}/browser/provider`, y = `${S}/data/workspaces`, z = `${S}/data/roles`, g = `${S}/data/datastreams`, T = `${S}/data/sensors`, f = `${S}/data/things`, ve = `${f}/tags`, k = `${S}/data/orchestration-systems`, _ = `${S}/data/data-sources`, I = `${S}/data/observed-properties`, F = `${S}/data/processing-levels`, x = `${S}/data/result-qualifiers`, D = `${S}/data/units`, Bt = (e, t, r, s, a) => {
+  let n = `${g}/${e}/observations?format=column`;
+  return n += `&order_by=phenomenonTime&page_size=${t}`, n += `&phenomenon_time_min=${encodeURIComponent(r)}`, s && (n += `&phenomenon_time_max=${encodeURIComponent(s)}`), a && (n += `&page=${a}`), n;
+}, yt = (e, t, r) => {
+  const s = {
+    provider: e,
+    callback_url: t,
+    process: r
+  }, a = _e(), n = document.createElement("form");
+  if (n.method = "POST", n.action = `${B}/redirect`, a) {
+    const i = document.createElement("input");
+    i.type = "hidden", i.name = "csrfmiddlewaretoken", i.value = a, n.appendChild(i);
+  }
+  for (const i in s) {
+    const c = document.createElement("input");
+    c.type = "hidden", c.name = i, c.value = s[i] || "", n.appendChild(c);
+  }
+  document.body.appendChild(n), n.submit();
+}, Mt = {
+  fetchSession: async () => o.fetch(`${V}`),
+  login: async (e, t) => o.post(`${V}`, { email: e, password: t }),
+  logout: async () => o.delete(`${V}`),
+  fetchUser: async () => o.fetch(`${E}`),
+  signup: async (e) => o.post(`${E}`, e),
+  updateUser: async (e, t) => o.patch(`${E}`, e, t),
+  deleteUser: async () => o.delete(`${E}`),
+  sendVerificationEmail: async (e) => o.put(`${E}/email/verify`, {
+    email: e
+  }),
+  verifyEmailWithCode: async (e) => o.post(`${E}/email/verify`, { key: e }),
+  requestPasswordReset: async (e) => o.post(`${E}/password/request`, {
+    email: e
+  }),
+  resetPassword: async (e, t) => o.post(`${E}/password/reset`, {
+    key: e,
+    password: t
+  }),
+  fetchWorkspaces: async () => o.paginatedFetch(`${y}`),
+  fetchAssociatedWorkspaces: async () => o.paginatedFetch(`${y}?is_associated=true`),
+  fetchWorkspace: async (e) => o.fetch(`${y}/${e}`),
+  createWorkspace: async (e) => o.post(y, e),
+  updateWorkspace: async (e, t = null) => o.patch(
+    `${y}/${e.id}`,
+    e,
+    t
+  ),
+  deleteWorkspace: async (e) => o.delete(`${y}/${e}`),
+  transferWorkspace: async (e, t) => o.post(`${y}/${e}/transfer`, { newOwner: t }),
+  acceptWorkspaceTransfer: async (e) => o.put(`${y}/${e}/transfer`),
+  rejectWorkspaceTransfer: async (e) => o.delete(`${y}/${e}/transfer`),
+  getCollaboratorRoles: async (e) => o.paginatedFetch(`${z}?is_user_role=true`),
+  getAPIKeyRoles: async (e) => o.paginatedFetch(`${z}?is_apikey_role=true`),
+  getRole: async (e) => o.fetch(`${z}/${e}`),
+  getCollaborators: async (e) => o.paginatedFetch(`${y}/${e}/collaborators`),
+  addCollaborator: async (e, t, r) => o.post(`${y}/${e}/collaborators`, {
+    email: t,
+    roleId: r
+  }),
+  updateCollaboratorRole: async (e, t, r) => o.put(`${y}/${e}/collaborators`, {
+    email: t,
+    roleId: r
+  }),
+  removeCollaborator: async (e, t) => o.delete(`${y}/${e}/collaborators`, { email: t }),
+  fetchApiKeys: async (e) => o.paginatedFetch(
+    `${y}/${e}/api-keys?expand_related=true`
+  ),
+  fetchApiKey: async (e, t) => o.fetch(
+    `${y}/${e}/api-keys/${t}?expand_related=true`
+  ),
+  createApiKey: async (e) => o.post(
+    `${y}/${e.workspaceId}/api-keys?expand_related=true`,
+    {
+      name: e.name,
+      description: e.description,
+      isActive: !0,
+      roleId: e.role.id
+    }
+  ),
+  updateApiKey: async (e, t) => o.patch(
+    `${y}/${e.workspaceId}/api-keys/${e.id}?expand_related=true`,
+    {
+      name: e.name,
+      description: e.description,
+      isActive: !0,
+      roleId: e.role.id
+    },
+    t && {
+      name: t.name,
+      description: t.description,
+      isActive: !0,
+      roleId: t.role.id
+    }
+  ),
+  regenerateApiKey: async (e, t) => o.put(
+    `${y}/${e}/api-keys/${t}/regenerate?expand_related=true`
+  ),
+  deleteApiKey: async (e, t) => o.delete(`${y}/${e}/api-keys/${t}`),
+  fetchConnectedProviders: async () => o.fetch(`${B}/connections`),
+  providerRedirect: yt,
+  providerSignup: async (e) => o.post(`${B}/signup`, e),
+  deleteProvider: async (e, t) => o.delete(`${B}/connections`, {
+    provider: e,
+    account: t
+  }),
+  createUnit: async (e) => o.post(D, e),
+  fetchUnits: async () => o.paginatedFetch(`${D}`),
+  fetchWorkspaceUnits: async (e) => o.paginatedFetch(`${D}?workspace_id=${e}`),
+  updateUnit: async (e, t = null) => o.patch(`${D}/${e.id}`, e, t),
+  deleteUnit: async (e) => o.delete(`${D}/${e}`),
+  getUnit: async (e) => o.fetch(`${D}/${e}`),
+  removeThingOwner: async (e, t) => o.patch(`${f}/${e}/ownership`, {
+    email: t,
+    removeOwner: !0
+  }),
+  addSecondaryOwner: async (e, t) => o.patch(`${f}/${e}/ownership`, {
+    email: t,
+    makeOwner: !0
+  }),
+  transferPrimaryOwnership: async (e, t) => o.patch(`${f}/${e}/ownership`, {
+    email: t,
+    transferPrimary: !0
+  }),
+  createThing: async (e) => o.post(f, e),
+  fetchThings: async () => o.paginatedFetch(`${f}`),
+  fetchThingsForWorkspace: async (e) => o.paginatedFetch(`${f}?workspace_id=${e}`),
+  fetchOwnedThings: async () => o.paginatedFetch(`${f}?owned_only=true`),
+  fetchThing: async (e) => o.fetch(`${f}/${e}`),
+  updateThing: async (e) => o.patch(`${f}/${e.id}`, e),
+  updateThingPrivacy: async (e, t) => o.patch(`${f}/${e}`, { isPrivate: t }),
+  deleteThing: async (e) => o.delete(`${f}/${e}`),
+  fetchMetadataForThingOwner: async (e) => o.paginatedFetch(
+    `${f}/${e}/metadata?include_assignable_metadata=true`
+  ),
+  fetchMetadataForThing: async (e) => o.fetch(`${f}/${e}/metadata`),
+  uploadSitePhotos: async (e, t) => o.post(`${f}/${e}/photos`, t),
+  fetchSitePhotos: async (e) => o.paginatedFetch(`${f}/${e}/photos`),
+  deleteSitePhoto: async (e, t) => o.delete(`${f}/${e}/photos`, { name: t }),
+  createSiteTag: async (e, t) => o.post(`${f}/${e}/tags`, t),
+  editSiteTag: async (e, t) => o.put(`${f}/${e}/tags`, t),
+  fetchSiteTags: async (e) => o.fetch(`${f}/${e}/tags`),
+  fetchUsersSiteTags: async () => o.fetch(`${ve}`),
+  deleteSiteTag: async (e, t) => o.delete(`${f}/${e}/tags`, t),
+  fetchWorkspaceTags: async (e) => o.fetch(`${ve}/keys?workspace_id=${e}`),
+  createHydroShareArchive: async (e) => o.post(`${f}/${e.thingId}/archive`, e),
+  updateHydroShareArchive: async (e, t) => o.patch(
+    `${f}/${e.thingId}/archive`,
+    e,
+    t
+  ),
+  fetchHydroShareArchive: async (e) => o.fetch(`${f}/${e}/archive`),
+  deleteHydroShareArchive: async (e) => o.delete(`${f}/${e}/archive`),
+  archiveToHydroShare: async (e) => o.post(`${f}/${e}/archive/trigger`),
+  createDatastream: async (e) => o.post(g, e),
+  fetchDatastreams: async (e) => {
+    const t = [];
+    if (e)
+      for (const [s, a] of Object.entries(e))
+        t.push(`${encodeURIComponent(s)}=${encodeURIComponent(a)}`);
+    const r = t.length ? `?${t.join("&")}` : "";
+    return o.paginatedFetch(`${g}${r}`);
+  },
+  fetchDatastreamsForThing: async (e) => o.paginatedFetch(`${g}?thing_id=${e}`),
+  fetchExpandedDatastreamsForThing: async (e) => o.paginatedFetch(
+    `${g}?thing_id=${e}&expand_related=true`
+  ),
+  fetchDatastreamsForDataSource: async (e) => o.paginatedFetch(`${g}?data_source_id=${e}`),
+  fetchDatastream: async (e) => o.fetch(`${g}/${e}`),
+  fetchDatastreamExpanded: async (e) => o.fetch(`${g}/${e}?expand_related=true`),
+  fetchUsersDatastreams: async () => o.paginatedFetch(`${g}?exclude_unowned=true`),
+  updateDatastream: async (e, t = null) => o.patch(`${g}/${e.id}`, e, t),
+  deleteDatastream: async (e) => o.delete(`${g}/${e}`),
+  downloadDatastreamCSV: async (e) => o.fetch(`${g}/${e}/csv`),
+  createObservedProperty: async (e) => o.post(I, e),
+  fetchObservedProperty: async (e) => o.fetch(`${I}/${e}`),
+  fetchObservedProperties: async () => o.paginatedFetch(`${I}`),
+  fetchWorkspaceObservedProperties: async (e) => o.paginatedFetch(`${I}?workspace_id=${e}`),
+  updateObservedProperty: async (e, t = null) => o.patch(`${I}/${e.id}`, e, t),
+  deleteObservedProperty: async (e) => o.delete(`${I}/${e}`),
+  createProcessingLevel: async (e) => o.post(F, e),
+  fetchProcessingLevels: async () => o.paginatedFetch(`${F}`),
+  fetchProcessingLevel: async (e) => o.fetch(`${F}/${e}`),
+  fetchWorkspaceProcessingLevels: async (e) => o.paginatedFetch(`${F}?workspace_id=${e}`),
+  updateProcessingLevel: async (e, t = null) => o.patch(`${F}/${e.id}`, e, t),
+  deleteProcessingLevel: async (e) => o.delete(`${F}/${e}`),
+  createSensor: async (e) => o.post(T, e),
+  fetchSensors: async () => o.paginatedFetch(`${T}`),
+  fetchSensor: async (e) => o.fetch(`${T}/${e}`),
+  fetchWorkspaceSensors: async (e) => o.paginatedFetch(`${T}?workspace_id=${e}`),
+  updateSensor: async (e, t = null) => o.patch(`${T}/${e.id}`, e, t),
+  deleteSensor: async (e) => o.delete(`${T}/${e}`),
+  createResultQualifier: async (e) => o.post(x, e),
+  fetchResultQualifiers: async () => o.paginatedFetch(`${x}`),
+  fetchWorkspaceResultQualifiers: async (e) => o.paginatedFetch(`${x}?workspace_id=${e}`),
+  updateResultQualifier: async (e, t = null) => o.patch(
+    `${x}/${e.id}`,
+    e,
+    t
+  ),
+  deleteResultQualifier: async (e) => o.delete(`${x}/${e}`),
+  createOrchestrationSystem: async (e) => o.post(k, e),
+  fetchOrchestrationSystems: async () => o.paginatedFetch(k),
+  fetchWorkspaceOrchestrationSystems: async (e) => o.paginatedFetch(`${k}?workspace_id=${e}`),
+  fetchOrchestrationSystem: async (e) => o.fetch(`${k}/${e}`),
+  updateOrchestrationSystem: async (e, t) => o.patch(`${k}/${e}`, t),
+  deleteOrchestrationSystem: async (e) => o.delete(`${k}/${e}`),
+  createDataSource: async (e) => o.post(
+    `${_}?expand_related=true`,
+    be(e)
+  ),
+  fetchDataSources: async () => o.paginatedFetch(`${_}?expand_related=true`),
+  fetchWorkspaceDataSources: async (e) => o.paginatedFetch(
+    `${_}?workspace_id=${e}&expand_related=true`
+  ),
+  fetchDataSource: async (e) => o.fetch(`${_}/${e}?expand_related=true`),
+  updateDataSource: async (e) => o.patch(
+    `${_}/${e.id}?expand_related=true`,
+    be(e)
+  ),
+  updateDataSourcePartial: async (e) => o.patch(
+    `${_}/${e.id}?expand_related=true`,
+    e
+  ),
+  deleteDataSource: async (e) => o.delete(`${_}/${e}`),
+  linkDatastreamToDataSource: async (e, t) => o.post(
+    `${_}/${e}/datastreams/${t}`
+  ),
+  unlinkDatastreamFromDataSource: async (e, t) => o.delete(
+    `${_}/${e}/datastreams/${t}`
+  ),
+  fetchObservations: async (e) => o.fetch(e),
+  deleteObservationsForDatastream: async (e) => o.post(`${g}/${e}/observations/bulk-delete`, {
+    phenomenonTimeStart: null,
+    phenomenonTimeEnd: null
+  }),
+  fetchUserTypes: async () => o.fetch(`${E}/user-types`),
+  fetchOrganizationTypes: async () => o.fetch(`${E}/organization-types`),
+  fetchSiteTypes: async () => o.fetch(`${f}/site-types`),
+  fetchSamplingFeatureTypes: async () => o.paginatedFetch(`${f}/sampling-feature-types`),
+  fetchSensorEncodingTypes: async () => o.paginatedFetch(`${T}/encoding-types`),
+  fetchMethodTypes: async () => o.paginatedFetch(`${T}/method-types`),
+  fetchVariableTypes: async () => o.paginatedFetch(`${I}/variable-types`),
+  fetchUnitTypes: async () => o.paginatedFetch(`${D}/types`),
+  fetchDatastreamStatuses: async () => o.paginatedFetch(`${g}/statuses`),
+  fetchDatastreamAggregations: async () => o.paginatedFetch(`${g}/aggregation-statistics`),
+  fetchSampledMediums: async () => o.paginatedFetch(`${g}/sampled-mediums`)
+};
+class Yt {
+  name = "";
+  mappings = [];
+  extractorVariables = {};
+  constructor(t) {
+    Object.assign(this, t);
+  }
+}
+const Ne = 1, M = Ne * 60, ne = M * 60, oe = ne * 24, mt = oe * 7, gt = ne * 30, bt = oe * 365, se = {
+  [$.SECOND]: Ne,
+  [$.MINUTE]: M,
+  [$.HOUR]: ne,
+  [$.DAY]: oe,
+  [$.WEEK]: mt,
+  [$.MONTH]: gt,
+  [$.YEAR]: bt
+}, jt = (e) => e.toLocaleString(void 0, {
+  year: "numeric",
+  month: "short",
+  day: "2-digit",
+  hour: "2-digit",
+  hour12: !1,
+  minute: "2-digit",
+  second: "2-digit"
+}), Ht = (e) => {
+  let t, r;
+  e >= M * 1e3 ? (t = e / (M * 1e3), r = "m") : e >= 1e3 ? (t = e / 1e3, r = "s") : (t = e, r = "ms");
+  let s;
+  return r === "ms" ? s = Math.round(t).toString() : s = t.toFixed(2), `${s} ${r}`;
+}, vt = (e, t, r) => {
+  if (r === $.MONTH) {
+    const s = new Date(e);
+    return s.setMonth(s.getMonth() + t), s.getTime();
+  } else if (r === $.YEAR) {
+    const s = new Date(e);
+    return s.setFullYear(s.getFullYear() + t), s.getTime();
+  } else
+    return e + t * se[r] * 1e3;
+}, J = async (e, t) => {
+  t && console.info(t);
+  const r = performance.now(), s = await e(), a = performance.now();
+  console.info(`	Done in ${(a - r).toFixed(2)} ms`);
+  const n = +(a - r);
+  return { response: s, duration: n };
+};
+function Gt(e, t) {
+  const r = new Date(e);
+  return r.setHours(r.getHours() - t), r.toISOString();
+}
+const St = (e, t) => {
+  let r = 0, s = e.length;
+  for (; r < s; ) {
+    const a = r + s >> 1;
+    e[a] < t ? r = a + 1 : s = a;
+  }
+  return r;
+}, Se = (e, t) => {
+  let r = 0, s = e.length;
+  for (; r < s; ) {
+    const a = r + s >> 1;
+    e[a] > t ? s = a : r = a + 1;
+  }
+  return r - 1;
+}, Ce = `(function(){"use strict";self.onmessage=o=>{const{bufferX:s,bufferY:n,outputBufferX:u,outputBufferY:f,start:l,end:y,deleteSegment:a,startTarget:c}=o.data,A=new Float64Array(s),d=new Float32Array(n),g=new Float64Array(u),p=new Float32Array(f);let e=0,r=c;for(let t=l;t<=y;t++)e<a.length&&t===a[e]?e++:(g[r]=A[t],p[r]=d[t],r++);self.postMessage("Done")}})();
+`, Ee = typeof self < "u" && self.Blob && new Blob([Ce], { type: "text/javascript;charset=utf-8" });
+function Et(e) {
   let t;
   try {
-    if (t = b && (self.URL || self.webkitURL).createObjectURL(b), !t) throw "";
-    const s = new Worker(t, {
-      name: r?.name
+    if (t = Ee && (self.URL || self.webkitURL).createObjectURL(Ee), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
     });
-    return s.addEventListener("error", () => {
+    return r.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(t);
-    }), s;
+    }), r;
   } catch {
     return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(I),
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Ce),
       {
-        name: r?.name
+        name: e?.name
       }
     );
   } finally {
     t && (self.URL || self.webkitURL).revokeObjectURL(t);
   }
 }
-const F = `(function(){"use strict";self.onmessage=function(e){const{bufferX:f,bufferY:t,outputBufferX:u,outputBufferY:s}=e.data;self.postMessage("Done")}})();
-`, R = typeof self < "u" && self.Blob && new Blob([F], { type: "text/javascript;charset=utf-8" });
-function M(r) {
+const Ue = `(function(){"use strict";self.onmessage=function(e){const{bufferX:f,bufferY:t,outputBufferX:u,outputBufferY:s}=e.data;self.postMessage("Done")}})();
+`, $e = typeof self < "u" && self.Blob && new Blob([Ue], { type: "text/javascript;charset=utf-8" });
+function $t(e) {
   let t;
   try {
-    if (t = R && (self.URL || self.webkitURL).createObjectURL(R), !t) throw "";
-    const s = new Worker(t, {
-      name: r?.name
+    if (t = $e && (self.URL || self.webkitURL).createObjectURL($e), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
     });
-    return s.addEventListener("error", () => {
+    return r.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(t);
-    }), s;
+    }), r;
   } catch {
     return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(F),
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Ue),
       {
-        name: r?.name
+        name: e?.name
       }
     );
   } finally {
     t && (self.URL || self.webkitURL).revokeObjectURL(t);
   }
 }
-const C = (r, t) => {
-  let s = 0, e = r.length;
-  for (; s < e; ) {
-    const n = s + e >> 1;
-    r[n] < t ? s = n + 1 : e = n;
-  }
-  return s;
-}, B = (r, t) => {
-  let s = 0, e = r.length;
-  for (; s < e; ) {
-    const n = s + e >> 1;
-    r[n] > t ? e = n : s = n + 1;
-  }
-  return s - 1;
-}, w = async (r, t) => {
-  const s = performance.now(), e = await r(), n = performance.now();
-  console.log(`	Done in ${(n - s).toFixed(2)} ms`);
-  const a = +(n - s);
-  return { response: e, duration: a };
-}, N = 1, Y = N * 60, S = Y * 60, D = S * 24, G = D * 7, O = S * 30, k = D * 365, A = {
-  s: N,
-  m: Y,
-  h: S,
-  D,
-  W: G,
-  M: O,
-  Y: k
-}, H = (r, t, s) => {
-  if (s === "M") {
-    const e = new Date(r);
-    return e.setMonth(e.getMonth() + t), e.getTime();
-  } else if (s === "Y") {
-    const e = new Date(r);
-    return e.setFullYear(e.getFullYear() + t), e.getTime();
-  } else
-    return r + t * A[s] * 1e3;
-}, L = 20 * 1e3, v = ["date", "value", "qualifier"];
-class V {
+const N = 20 * 1e3, _t = ["date", "value", "qualifier"];
+class Wt {
   /** The generated dataset to be used for plotting */
   dataset = {
-    dimensions: v,
+    dimensions: _t,
     source: {
       x: new Float64Array(
         new SharedArrayBuffer(
-          L * Float64Array.BYTES_PER_ELEMENT,
+          N * Float64Array.BYTES_PER_ELEMENT,
           {
-            maxByteLength: L * Float64Array.BYTES_PER_ELEMENT
+            maxByteLength: N * Float64Array.BYTES_PER_ELEMENT
             // Max size the array can reach
           }
         )
       ),
       y: new Float32Array(
         new SharedArrayBuffer(
-          L * Float32Array.BYTES_PER_ELEMENT,
+          N * Float32Array.BYTES_PER_ELEMENT,
           {
-            maxByteLength: L * Float32Array.BYTES_PER_ELEMENT
+            maxByteLength: N * Float32Array.BYTES_PER_ELEMENT
             // Max size the array can reach
           }
         )
@@ -134,10 +1419,10 @@ class V {
     if (!t)
       return;
     this.isLoading = !0;
-    const s = await w(() => {
+    const r = await J(() => {
       this._growBuffer(t.datetimes.length), this._resizeTo(t.datetimes.length), this.dataX.set(t.datetimes), this.dataY.set(t.dataValues);
     });
-    this.loadingTime = s.duration, this.history.length = 0, this.isLoading = !1;
+    this.loadingTime = r.duration, this.history.length = 0, this.isLoading = !1;
   }
   get dataX() {
     return this.dataset.source.x;
@@ -162,23 +1447,23 @@ class V {
    * @param newLength The total number of elements that the view will contain
    */
   _growBuffer(t) {
-    const s = t * Float64Array.BYTES_PER_ELEMENT;
-    let e = this.dataX.buffer.byteLength;
-    for (; s > e; )
-      e += L * Float64Array.BYTES_PER_ELEMENT;
-    if (e * Float64Array.BYTES_PER_ELEMENT > this.dataX.buffer.maxByteLength) {
-      const n = new SharedArrayBuffer(
+    const r = t * Float64Array.BYTES_PER_ELEMENT;
+    let s = this.dataX.buffer.byteLength;
+    for (; r > s; )
+      s += N * Float64Array.BYTES_PER_ELEMENT;
+    if (s * Float64Array.BYTES_PER_ELEMENT > this.dataX.buffer.maxByteLength) {
+      const a = new SharedArrayBuffer(
         this.dataX.buffer.byteLength,
         {
-          maxByteLength: e * Float64Array.BYTES_PER_ELEMENT
+          maxByteLength: s * Float64Array.BYTES_PER_ELEMENT
         }
-      ), a = new SharedArrayBuffer(
+      ), n = new SharedArrayBuffer(
         this.dataY.buffer.byteLength,
         {
-          maxByteLength: e * Float32Array.BYTES_PER_ELEMENT
+          maxByteLength: s * Float32Array.BYTES_PER_ELEMENT
         }
-      ), o = new Float64Array(n), i = new Float32Array(a);
-      o.set(this.dataX), i.set(this.dataY), this.dataset.source.x = o, this.dataset.source.y = i;
+      ), i = new Float64Array(a), c = new Float32Array(n);
+      i.set(this.dataX), c.set(this.dataY), this.dataset.source.x = i, this.dataset.source.y = c;
     }
     this.dataX.buffer.byteLength < t * Float64Array.BYTES_PER_ELEMENT && (this.dataX.buffer.grow(t * Float64Array.BYTES_PER_ELEMENT), this.dataY.buffer.grow(t * Float32Array.BYTES_PER_ELEMENT));
   }
@@ -193,16 +1478,16 @@ class V {
    * @returns
    */
   async reloadHistory(t) {
-    const s = this.history.slice(0, t + 1);
-    await this.reload(), await this.dispatch(s.map((e) => [e.method, ...e.args || []]));
+    const r = this.history.slice(0, t + 1);
+    await this.reload(), await this.dispatch(r.map((s) => [s.method, ...s.args || []]));
   }
   /**
    * Remove a history item
    * @param index
    */
   async removeHistoryItem(t) {
-    const s = [...this.history];
-    s.splice(t, 1), await this.reload(), await this.dispatch(s.map((e) => [e.method, ...e.args || []]));
+    const r = [...this.history];
+    r.splice(t, 1), await this.reload(), await this.dispatch(r.map((s) => [s.method, ...s.args || []]));
   }
   get beginTime() {
     return this.dataset.source.x.length ? new Date(this.dataset.source.x[0]) : null;
@@ -211,88 +1496,89 @@ class V {
     return this.dataset.source.x.length ? new Date(this.dataset.source.x[this.dataset.source.x.length - 1]) : null;
   }
   /** Dispatch an operation and log its signature in hisotry */
-  async dispatch(t, ...s) {
-    const e = {
-      [f.ADD_POINTS]: this._addDataPoints,
-      [f.CHANGE_VALUES]: this._changeValues,
-      [f.DELETE_POINTS]: this._deleteDataPoints,
-      [f.DRIFT_CORRECTION]: this._driftCorrection,
-      [f.INTERPOLATE]: this._interpolate,
-      [f.SHIFT_DATETIMES]: this._shift,
-      [f.FILL_GAPS]: this._fillGaps
-    }, n = {
-      [f.ADD_POINTS]: "mdi-plus",
-      [f.CHANGE_VALUES]: "mdi-pencil",
-      [f.DELETE_POINTS]: "mdi-trash-can",
-      [f.DRIFT_CORRECTION]: "mdi-chart-sankey",
-      [f.INTERPOLATE]: "mdi-transit-connection-horizontal",
-      [f.SHIFT_DATETIMES]: "mdi-calendar",
-      [f.FILL_GAPS]: "mdi-keyboard-space"
+  async dispatch(t, ...r) {
+    const s = {
+      [v.ADD_POINTS]: this._addDataPoints,
+      [v.CHANGE_VALUES]: this._changeValues,
+      [v.DELETE_POINTS]: this._deleteDataPoints,
+      [v.DRIFT_CORRECTION]: this._driftCorrection,
+      [v.INTERPOLATE]: this._interpolate,
+      [v.SHIFT_DATETIMES]: this._shift,
+      [v.FILL_GAPS]: this._fillGaps
+    }, a = {
+      [v.ADD_POINTS]: "mdi-plus",
+      [v.CHANGE_VALUES]: "mdi-pencil",
+      [v.DELETE_POINTS]: "mdi-trash-can",
+      [v.DRIFT_CORRECTION]: "mdi-chart-sankey",
+      [v.INTERPOLATE]: "mdi-transit-connection-horizontal",
+      [v.SHIFT_DATETIMES]: "mdi-calendar",
+      [v.FILL_GAPS]: "mdi-keyboard-space"
     };
-    let a = [];
+    let n = [];
     try {
       if (Array.isArray(t)) {
-        for (let o = 0; o < t.length; o++) {
-          const i = t[o][0], h = t[o].slice(1, t[o].length), l = {
-            method: i,
+        for (let i = 0; i < t.length; i++) {
+          const c = t[i][0], h = t[i].slice(1, t[i].length), u = {
+            method: c,
             args: h,
-            icon: n[i],
+            icon: a[c],
             isLoading: !1
           };
-          this.history.push(l);
+          this.history.push(u);
         }
-        for (let o = this.history.length - t.length; o < this.history.length; o++) {
-          const i = this.history[o];
-          i.isLoading = !0;
-          const h = await w(async () => await e[i.method].apply(
+        for (let i = this.history.length - t.length; i < this.history.length; i++) {
+          const c = this.history[i];
+          c.isLoading = !0;
+          const h = await J(async () => await s[c.method].apply(
             this,
-            i.args
+            c.args
           ));
-          i.duration = h.duration, i.isLoading = !1, a.push(h.response);
+          c.duration = h.duration, c.isLoading = !1, n.push(h.response);
         }
       } else {
-        const o = {
+        const i = {
           method: t,
-          args: s,
-          icon: n[t],
+          args: r,
+          icon: a[t],
           isLoading: !0
         };
-        this.history.push(o);
-        const i = await w(async () => await e[t].apply(this, s));
-        a = i.response, o.duration = i.duration, o.isLoading = !1;
+        this.history.push(i);
+        const c = await J(async () => await s[t].apply(this, r));
+        n = c.response, i.duration = c.duration, i.isLoading = !1;
       }
-    } catch (o) {
+    } catch (i) {
       console.log(
         `Failed to execute operation: ${t} with arguments: `,
-        s
-      ), console.log(o);
+        r
+      ), console.log(i);
     }
-    return a;
+    return n;
   }
   /** Filter operations do not transform the data and are not logged in history */
-  async dispatchFilter(t, ...s) {
-    const e = {
-      [_.FIND_GAPS]: this._findGaps,
-      [_.VALUE_THRESHOLD]: this._valueThreshold,
-      [_.PERSISTENCE]: this._persistence,
-      [_.RATE_OF_CHANGE]: this._rateOfChange
+  async dispatchFilter(t, ...r) {
+    const s = {
+      [P.FIND_GAPS]: this._findGaps,
+      [P.VALUE_THRESHOLD]: this._valueThreshold,
+      [P.PERSISTENCE]: this._persistence,
+      [P.CHANGE]: this._change,
+      [P.RATE_OF_CHANGE]: this._rateOfChange
     };
-    let n = [];
+    let a = [];
     try {
       if (Array.isArray(t))
-        for (let a = 0; a < t.length; a++) {
-          const o = t[a][0], i = t[a].slice(1, t[a].length), h = await e[o].apply(this, i);
-          n.push(h);
+        for (let n = 0; n < t.length; n++) {
+          const i = t[n][0], c = t[n].slice(1, t[n].length), h = await s[i].apply(this, c);
+          a.push(h);
         }
       else
-        n = await e[t].apply(this, s);
-    } catch (a) {
+        a = await s[t].apply(this, r);
+    } catch (n) {
       console.log(
         `Failed to execute filter operation: ${t} with arguments: `,
-        s
-      ), console.log(a);
+        r
+      ), console.log(n);
     }
-    return n;
+    return a;
   }
   /**
    * @param index An array containing the list of index of values to perform the operations on.
@@ -300,45 +1586,45 @@ class V {
    * @param value The value to use in the operation
    * @returns The modified DataFrame
    */
-  _changeValues(t, s, e) {
-    const n = (a) => {
-      switch (s) {
-        case E.ADD:
-          return a + e;
-        case E.ASSIGN:
-          return e;
-        case E.DIV:
-          return a / e;
-        case E.MULT:
-          return a * e;
-        case E.SUB:
-          return a - e;
+  _changeValues(t, r, s) {
+    const a = (n) => {
+      switch (r) {
+        case R.ADD:
+          return n + s;
+        case R.ASSIGN:
+          return s;
+        case R.DIV:
+          return n / s;
+        case R.MULT:
+          return n * s;
+        case R.SUB:
+          return n - s;
         default:
-          return a;
+          return n;
       }
     };
-    t.forEach((a) => {
-      this.dataset.source.y[a] = n(this.dataset.source.y[a]);
+    t.forEach((n) => {
+      this.dataset.source.y[n] = a(this.dataset.source.y[n]);
     });
   }
   _interpolate(t) {
-    this._getConsecutiveGroups(t).forEach((e) => {
-      const n = e[0], a = e[e.length - 1];
-      let o = Math.max(0, n - 1), i = Math.min(this.dataset.source.y.length - 1, a + 1);
-      const h = this.dataset.source.x, l = this.dataset.source.y;
-      for (let u = 0; u < e.length; u++)
-        this.dataset.source.y[e[u]] = this._interpolateLinear(
-          h[e[u]],
-          h[o],
-          l[o],
+    this._getConsecutiveGroups(t).forEach((s) => {
+      const a = s[0], n = s[s.length - 1];
+      let i = Math.max(0, a - 1), c = Math.min(this.dataset.source.y.length - 1, n + 1);
+      const h = this.dataset.source.x, u = this.dataset.source.y;
+      for (let d = 0; d < s.length; d++)
+        this.dataset.source.y[s[d]] = this._interpolateLinear(
+          h[s[d]],
           h[i],
-          l[i]
+          u[i],
+          h[c],
+          u[c]
         );
     });
   }
   /** Interpolate existing values in the data source */
-  _interpolateLinear(t, s, e, n, a) {
-    return e + (t - s) * (a - e) / (n - s);
+  _interpolateLinear(t, r, s, a, n) {
+    return s + (t - r) * (n - s) / (a - r);
   }
   /**
    * Shifts the selected indexes by specified amount of units. Elements are reinserted according to their datetime.
@@ -347,34 +1633,34 @@ class V {
    * @param unit {@link TimeUnit}
    * @returns
    */
-  async _shift(t, s, e) {
-    const n = t.map((a) => [
-      H(this.dataX[a], s, e),
-      this.dataY[a]
+  async _shift(t, r, s) {
+    const a = t.map((n) => [
+      vt(this.dataX[n], r, s),
+      this.dataY[n]
     ]);
-    await this._deleteDataPoints(t), await this._addDataPoints(n);
+    await this._deleteDataPoints(t), await this._addDataPoints(a);
   }
-  async _fillGapsV2(t, s, e, n) {
-    const a = navigator.hardwareConcurrency || 1, o = [], i = [], h = this.dataX.length, l = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
+  async _fillGapsV2(t, r, s, a) {
+    const n = navigator.hardwareConcurrency || 1, i = [], c = [], h = this.dataX.length, u = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
       maxByteLength: this.dataX.buffer.maxByteLength
-    }), u = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
+    }), d = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
       maxByteLength: this.dataY.buffer.maxByteLength
     });
-    for (let c = 0; c < a; c++)
-      i.push(
-        new Promise((d) => {
-          const y = new M();
-          o.push(y), y.postMessage({
+    for (let l = 0; l < n; l++)
+      c.push(
+        new Promise((p) => {
+          const m = new $t();
+          i.push(m), m.postMessage({
             bufferX: this.dataX.buffer,
             bufferY: this.dataY.buffer,
-            outputBufferX: l,
-            outputBufferY: u
-          }), y.onmessage = (g) => {
-            d(g.data);
+            outputBufferX: u,
+            outputBufferY: d
+          }), m.onmessage = (A) => {
+            p(A.data);
           };
         })
       );
-    await Promise.all(i), o.forEach((c) => c.terminate()), this.dataset.source.x = new Float64Array(l), this.dataset.source.y = new Float32Array(u), this._resizeTo(h);
+    await Promise.all(c), i.forEach((l) => l.terminate()), this.dataset.source.x = new Float64Array(u), this.dataset.source.y = new Float32Array(d), this._resizeTo(h);
   }
   /**
    * Find gaps and fill them with placeholder value
@@ -384,22 +1670,22 @@ class V {
    * @returns
    */
   // TODO: this needs to be improved using web workers
-  _fillGaps(t, s, e, n) {
-    const a = this._findGaps(t[0], t[1], n);
-    for (let o = a.length - 1; o >= 0; o--) {
-      const i = a[o], h = this.dataX[i[0]], l = this.dataX[i[1]], u = [], c = s[0] * A[s[1]] * 1e3;
-      let d = h + c;
-      for (; d < l; ) {
-        const y = e ? this._interpolateLinear(
-          d,
-          this.dataX[i[0]],
-          this.dataY[i[0]],
-          this.dataX[i[1]],
-          this.dataY[i[1]]
+  _fillGaps(t, r, s, a) {
+    const n = this._findGaps(t[0], t[1], a);
+    for (let i = n.length - 1; i >= 0; i--) {
+      const c = n[i], h = this.dataX[c[0]], u = this.dataX[c[1]], d = [], l = r[0] * se[r[1]] * 1e3;
+      let p = h + l;
+      for (; p < u; ) {
+        const m = s ? this._interpolateLinear(
+          p,
+          this.dataX[c[0]],
+          this.dataY[c[0]],
+          this.dataX[c[1]],
+          this.dataY[c[1]]
         ) : -9999;
-        u.push([d, y]), d += c;
+        d.push([p, m]), p += l;
       }
-      this._addDataPoints(u);
+      this._addDataPoints(d);
     }
   }
   /**
@@ -412,40 +1698,40 @@ class V {
    */
   // TODO: implement similar multithread solutions for other operations
   async _deleteDataPoints(t) {
-    const s = navigator.hardwareConcurrency || 1, e = Math.ceil(this.dataX.length / s), n = [], a = [];
-    for (let c = 0; c < s; c++) {
-      const d = c * e, y = Math.min((c + 1) * e - 1, this.dataX.length - 1), g = C(t, d), p = B(t, y), m = t.slice(g, p + 1);
-      a.push({ start: d, end: y, deleteSegment: m });
+    const r = navigator.hardwareConcurrency || 1, s = Math.ceil(this.dataX.length / r), a = [], n = [];
+    for (let l = 0; l < r; l++) {
+      const p = l * s, m = Math.min((l + 1) * s - 1, this.dataX.length - 1), A = St(t, p), b = Se(t, m), H = t.slice(A, b + 1);
+      n.push({ start: p, end: m, deleteSegment: H });
     }
-    const o = new Array(s).fill(0);
-    for (let c = 1; c < s; c++)
-      o[c] = o[c - 1] + a[c - 1].deleteSegment.length;
-    const i = [], h = this.dataX.length - t.length, l = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
+    const i = new Array(r).fill(0);
+    for (let l = 1; l < r; l++)
+      i[l] = i[l - 1] + n[l - 1].deleteSegment.length;
+    const c = [], h = this.dataX.length - t.length, u = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
       maxByteLength: this.dataX.buffer.maxByteLength
-    }), u = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
+    }), d = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
       maxByteLength: this.dataY.buffer.maxByteLength
     });
-    for (let c = 0; c < s; c++) {
-      const { start: d, end: y, deleteSegment: g } = a[c], p = d - o[c];
-      i.push(
-        new Promise((m) => {
-          const T = new U();
-          n.push(T), T.postMessage({
+    for (let l = 0; l < r; l++) {
+      const { start: p, end: m, deleteSegment: A } = n[l], b = p - i[l];
+      c.push(
+        new Promise((H) => {
+          const G = new Et();
+          a.push(G), G.postMessage({
             bufferX: this.dataX.buffer,
             bufferY: this.dataY.buffer,
-            outputBufferX: l,
-            outputBufferY: u,
-            start: d,
-            end: y,
-            deleteSegment: g,
-            startTarget: p
-          }), T.onmessage = (P) => {
-            m(P.data);
+            outputBufferX: u,
+            outputBufferY: d,
+            start: p,
+            end: m,
+            deleteSegment: A,
+            startTarget: b
+          }), G.onmessage = (Be) => {
+            H(Be.data);
           };
         })
       );
     }
-    await Promise.all(i), n.forEach((c) => c.terminate()), this.dataset.source.x = new Float64Array(l), this.dataset.source.y = new Float32Array(u), this._resizeTo(h);
+    await Promise.all(c), a.forEach((l) => l.terminate()), this.dataset.source.x = new Float64Array(u), this.dataset.source.y = new Float32Array(d), this._resizeTo(h);
   }
   /**
    *
@@ -453,10 +1739,10 @@ class V {
    * @param end The end index
    * @param value The drift amount
    */
-  _driftCorrection(t, s, e) {
-    const n = this.dataset.source.x, a = this.dataset.source.y, o = n[t], h = n[s] - o;
-    for (let l = t; l < s; l++)
-      this.dataset.source.y[l] = a[l] + e * ((n[l] - o) / h);
+  _driftCorrection(t, r, s) {
+    const a = this.dataset.source.x, n = this.dataset.source.y, i = a[t], h = a[r] - i;
+    for (let u = t; u < r; u++)
+      this.dataset.source.y[u] = n[u] + s * ((a[u] - i) / h);
   }
   /** Traverses the index array and returns groups of consecutive values.
    * i.e.: `[0, 1, 3, 4, 6] => [[0, 1], [3, 4], [6]]`
@@ -464,27 +1750,27 @@ class V {
    * @param index: the index array (sorted)
    */
   _getConsecutiveGroups(t) {
-    const s = [[]];
-    return t.reduce((e, n) => {
-      const a = e[e.length - 1];
-      return !a.length || n == a[a.length - 1] + 1 ? a.push(n) : e.push([n]), e;
-    }, s), s;
+    const r = [[]];
+    return t.reduce((s, a) => {
+      const n = s[s.length - 1];
+      return !n.length || a == n[n.length - 1] + 1 ? n.push(a) : s.push([a]), s;
+    }, r), r;
   }
   /**
    * Adds data points. Their insert index is determined using `findFirstGreaterOrEqual` in the x-axis.
    * @param dataPoints
    */
   async _addDataPoints(t) {
-    const s = this.dataX.length + t.length;
-    this._growBuffer(s), t.sort((a, o) => a[0] - o[0]);
-    const e = t.map((a) => B(this.dataX, a[0]) + 1);
-    this._resizeTo(s), e.push(this.dataX.length);
-    let n = t.length;
-    for (let a = e.length - 1; a > 0; a--) {
-      const o = e[a - 1], i = e[a] - 1;
-      for (let h = i; h >= o; h--)
-        this.dataX[h + n] = this.dataX[h], this.dataY[h + n] = this.dataY[h];
-      n--, this.dataX[o + n] = t[a - 1][0], this.dataY[o + n] = t[a - 1][1];
+    const r = this.dataX.length + t.length;
+    this._growBuffer(r), t.sort((n, i) => n[0] - i[0]);
+    const s = t.map((n) => Se(this.dataX, n[0]) + 1);
+    this._resizeTo(r), s.push(this.dataX.length);
+    let a = t.length;
+    for (let n = s.length - 1; n > 0; n--) {
+      const i = s[n - 1], c = s[n] - 1;
+      for (let h = c; h >= i; h--)
+        this.dataX[h + a] = this.dataX[h], this.dataY[h + a] = this.dataY[h];
+      a--, this.dataX[i + a] = t[n - 1][0], this.dataY[i + a] = t[n - 1][1];
     }
   }
   // =======================
@@ -496,13 +1782,13 @@ class V {
    * @returns
    */
   _valueThreshold(t) {
-    const s = [];
-    return this.dataset.source.y.forEach((e, n) => {
-      Object.keys(t).some((a) => X[a]?.(
-        e,
-        t[a]
-      )) && s.push(n);
-    }), s;
+    const r = [];
+    return this.dataset.source.y.forEach((s, a) => {
+      Object.keys(t).some((n) => Ye[n]?.(
+        s,
+        t[n]
+      )) && r.push(a);
+    }), r;
   }
   /**
    *
@@ -510,16 +1796,33 @@ class V {
    * @param value
    * @returns
    */
-  _rateOfChange(t, s) {
-    const e = [], n = this.dataset.source.y;
-    for (let a = 1; a < n.length; a++) {
-      const o = n[a - 1], h = (n[a] - o) / Math.abs(o);
-      x[t]?.(
+  _rateOfChange(t, r) {
+    const s = [], a = this.dataset.source.y;
+    for (let n = 1; n < a.length; n++) {
+      const i = a[n - 1], h = (a[n] - i) / Math.abs(i);
+      ie[t]?.(
         h,
-        s
-      ) && e.push(a);
+        r
+      ) && s.push(n);
     }
-    return e;
+    return s;
+  }
+  /**
+  *
+  * @param comparator
+  * @param value
+  * @returns
+  */
+  _change(t, r) {
+    const s = [], a = this.dataset.source.y;
+    for (let n = 1; n < a.length; n++) {
+      const i = a[n - 1], h = a[n] - i;
+      ie[t]?.(
+        h,
+        r
+      ) && s.push(n);
+    }
+    return s;
   }
   /**
    * Find gaps in the data
@@ -528,16 +1831,16 @@ class V {
    * @param range If specified, the gaps will be found only within the range
    * @returns
    */
-  _findGaps(t, s, e) {
-    const n = [], a = this.dataset.source.x;
-    let o = 0, i = a.length;
-    e?.[0] && e?.[1] && (o = e[0], i = e[1]);
-    let h = a[o];
-    for (let l = o + 1; l <= i; l++) {
-      const u = a[l];
-      u - h > t * A[s] * 1e3 && n.push([l - 1, l]), h = u;
+  _findGaps(t, r, s) {
+    const a = [], n = this.dataset.source.x;
+    let i = 0, c = n.length;
+    s?.[0] && s?.[1] && (i = s[0], c = s[1]);
+    let h = n[i];
+    for (let u = i + 1; u <= c; u++) {
+      const d = n[u];
+      d - h > t * se[r] * 1e3 && a.push([u - 1, u]), h = d;
     }
-    return n;
+    return a;
   }
   /**
    * Find points where the values are the same at least x times in a row
@@ -545,15 +1848,74 @@ class V {
    * @param range If specified, the points will be found only within the range
    * @returns
    */
-  _persistence(t, s) {
-    let e = [], n = this.dataset.source.y, a = 0, o = n.length;
-    s?.[0] && s?.[1] && (a = s[0], o = s[1]);
-    let i = n[a], h = [];
-    for (let l = a + 1; l < o; l++)
-      n[l] != i || l === o ? (h.length >= t && (e = [...e, ...h]), h = []) : h.push(l);
-    return e;
+  _persistence(t, r) {
+    let s = [], a = this.dataset.source.y, n = 0, i = a.length;
+    r?.[0] && r?.[1] && (n = r[0], i = r[1]);
+    let c = a[n], h = [];
+    for (let u = n + 1; u < i; u++)
+      a[u] != c || u === i ? (h.length >= t && (s = [...s, ...h]), h = []) : h.push(u);
+    return s;
   }
 }
 export {
-  V as ObservationRecord
+  E as ACCOUNT_BASE,
+  ae as AUTH_BASE,
+  xt as ApiKey,
+  S as BASE_URL,
+  Ct as Collaborator,
+  ke as DEFAULT_SNACK_DURATION,
+  Ut as DataSource,
+  At as Datastream,
+  v as EnumEditOperations,
+  P as EnumFilterOperations,
+  Me as FilterOperation,
+  Ye as FilterOperationFn,
+  He as HydroShareArchive,
+  N as INCREASE_AMOUNT,
+  Ge as Location,
+  ie as LogicalComparator,
+  je as LogicalOperation,
+  Rt as OAuthProvider,
+  Wt as ObservationRecord,
+  Dt as ObservedProperty,
+  R as Operator,
+  Ft as Organization,
+  B as PROVIDER_BASE,
+  Yt as Payload,
+  We as PermissionAction,
+  Xe as PermissionResource,
+  ot as Position,
+  wt as PostHydroShareArchive,
+  Ot as ProcessingLevel,
+  kt as ResultQualifier,
+  V as SESSION_BASE,
+  It as Sensor,
+  it as Snack,
+  Fe as SnackColor,
+  Pe as SnackIcon,
+  Re as SnackTitle,
+  ct as Snackbar,
+  ve as TAG_BASE,
+  f as THINGS_BASE,
+  Tt as Thing,
+  $ as TimeUnit,
+  Lt as Unit,
+  Pt as User,
+  Nt as Workspace,
+  Mt as api,
+  o as apiMethods,
+  xe as createPatchObject,
+  qe as extractErrorMessage,
+  St as findFirstGreaterOrEqual,
+  Se as findLastLessOrEqual,
+  jt as formatDate,
+  Ht as formatDuration,
+  _e as getCSRFToken,
+  Bt as getObservationsEndpoint,
+  J as measureEllapsedTime,
+  we as requestInterceptor,
+  Te as responseInterceptor,
+  vt as shiftDatetime,
+  Gt as subtractHours,
+  se as timeUnitMultipliers
 };