@uwrl/qc-utils 0.0.15 → 0.0.18

package/dist/index.js

@@ -1,122 +1,2073 @@
-var f = /* @__PURE__ */ ((s) => (s.ADD_POINTS = "ADD_POINTS", s.CHANGE_VALUES = "CHANGE_VALUES", s.DELETE_POINTS = "DELETE_POINTS", s.DRIFT_CORRECTION = "DRIFT_CORRECTION", s.INTERPOLATE = "INTERPOLATE", s.SHIFT_DATETIMES = "SHIFT_DATETIMES", s.FILL_GAPS = "FILL_GAPS", s))(f || {}), T = /* @__PURE__ */ ((s) => (s.FIND_GAPS = "FIND_GAPS", s.PERSISTENCE = "PERSISTENCE", s.RATE_OF_CHANGE = "RATE_OF_CHANGE", s.VALUE_THRESHOLD = "VALUE_THRESHOLD", s))(T || {}), X = /* @__PURE__ */ ((s) => (s.LT = "Less than", s.LTE = "Less than or equal to", s.GT = "Greater than", s.GTE = "Greater than or equal to", s.E = "Equal", s.START = "Start datetime", s.END = "End datetime", s))(X || {});
-const x = {
-  "Less than": (s, t) => s < t,
-  "Less than or equal to": (s, t) => s <= t,
-  "Greater than": (s, t) => s > t,
-  "Greater than or equal to": (s, t) => s >= t,
-  Equal: (s, t) => s == t,
-  "Start datetime": (s, t) => s == t,
-  "End datetime": (s, t) => s == t
+var D = /* @__PURE__ */ ((e) => (e.SECOND = "s", e.MINUTE = "m", e.HOUR = "h", e.DAY = "D", e.WEEK = "W", e.MONTH = "M", e.YEAR = "Y", e))(D || {}), E = /* @__PURE__ */ ((e) => (e.ADD_POINTS = "ADD_POINTS", e.CHANGE_VALUES = "CHANGE_VALUES", e.ASSIGN_VALUES_BULK = "ASSIGN_VALUES_BULK", e.DELETE_POINTS = "DELETE_POINTS", e.DRIFT_CORRECTION = "DRIFT_CORRECTION", e.INTERPOLATE = "INTERPOLATE", e.SHIFT_DATETIMES = "SHIFT_DATETIMES", e.ASSIGN_DATETIMES_BULK = "ASSIGN_DATETIMES_BULK", e.FILL_GAPS = "FILL_GAPS", e))(E || {}), v = /* @__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.DATETIME_RANGE = "DATETIME_RANGE", e.SELECTION = "SELECTION", e))(v || {}), q = /* @__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))(q || {}), Pt = /* @__PURE__ */ ((e) => (e.ADD = "ADD", e.SUB = "SUB", e.MULT = "MULT", e.DIV = "DIV", e.ASSIGN = "ASSIGN", e))(Pt || {}), Bt = /* @__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))(Bt || {});
+class Nt {
+  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 Hr extends Nt {
+  resourceTitle;
+  resourceAbstract;
+  resourceKeywords;
+  constructor() {
+    super(), this.resourceTitle = void 0, this.resourceAbstract = void 0, this.resourceKeywords = void 0;
+  }
+}
+class jt {
+  latitude;
+  longitude;
+  elevation_m;
+  elevationDatum;
+  state;
+  county;
+  country;
+  constructor() {
+    this.elevationDatum = "WGS84", this.state = "", this.county = "", this.country = "";
+  }
+}
+class zr {
+  id;
+  workspaceId;
+  name;
+  location = new jt();
+  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 Xr {
+  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 Vr {
+  id;
+  workspaceId;
+  name;
+  symbol;
+  definition;
+  type;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.name = "", this.symbol = "", this.definition = "", this.type = "";
+  }
+}
+class qr {
+  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 Jr {
+  id;
+  workspaceId;
+  name;
+  definition;
+  description;
+  type;
+  code;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.name = "", this.definition = "", this.description = "", this.type = "Hydrology", this.code = "";
+  }
+}
+class Kr {
+  id;
+  workspaceId;
+  code;
+  definition;
+  explanation;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.code = "", this.definition = "", this.explanation = "";
+  }
+}
+class Qr {
+  id;
+  workspaceId;
+  code;
+  description;
+  constructor() {
+    this.id = "", this.workspaceId = "", this.code = "", this.description = "";
+  }
+}
+class Zr {
+  name;
+  code;
+  type;
+  description;
+  link;
+  constructor() {
+  }
+}
+class en {
+  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 tn {
+  id;
+  name;
+  iconLink;
+  signupEnabled;
+  connectEnabled;
+  constructor() {
+    this.id = "", this.name = "", this.iconLink = "", this.signupEnabled = !0, this.connectEnabled = !0;
+  }
+}
+var Wt = /* @__PURE__ */ ((e) => (e.Global = "*", e.View = "view", e.Create = "create", e.Edit = "edit", e.Delete = "delete", e))(Wt || {}), Gt = /* @__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))(Gt || {});
+class rn {
+  id = "";
+  key = "";
+  name = "";
+  description = "";
+  isActive = !0;
+  expiresAt = "";
+  createdAt = "";
+  lastUsed = "";
+  workspaceId = "";
+  role = null;
+  constructor(t) {
+    Object.assign(this, t);
+  }
+}
+class nn {
+  id;
+  name;
+  isPrivate;
+  owner;
+  collaboratorRole;
+  pendingTransferTo;
+  constructor() {
+    this.id = "", this.name = "", this.isPrivate = !1, this.owner = null, this.collaboratorRole = null, this.pendingTransferTo = null;
+  }
+}
+class sn {
+  user;
+  role;
+  constructor() {
+    this.user = {
+      phone: "",
+      address: "",
+      link: "",
+      type: "",
+      name: "",
+      email: "",
+      organizationName: ""
+    }, this.role = {
+      name: "",
+      description: "",
+      id: "",
+      isApikeyRole: !1,
+      isUserRole: !1,
+      workspaceId: "",
+      permissions: []
+    };
+  }
+}
+function lt() {
+  const e = "csrftoken=", r = decodeURIComponent(document.cookie).split(";");
+  for (const n of r) {
+    const s = n.trim();
+    if (s.startsWith(e))
+      return s.substring(e.length);
+  }
+  return null;
+}
+function ut(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"] = lt() || "", {
+    ...e,
+    headers: t,
+    body: r,
+    credentials: "omit"
+  };
+}
+function Yt(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 ht(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 (s) {
+      console.error("Failed to parse error JSON:", s);
+    }
+  else if (t.includes("text/csv"))
+    try {
+      r = await e.blob();
+    } catch (s) {
+      console.error("Failed to parse error JSON:", s);
+    }
+  if (e.ok || e.status === 401) return r;
+  const n = {
+    status: e.status,
+    message: Yt(r)
+  };
+  throw console.error("API response not OK:", n.message), n;
+}
+var ke = function(e, t) {
+  return ke = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var s in n) Object.prototype.hasOwnProperty.call(n, s) && (r[s] = n[s]);
+  }, ke(e, t);
+};
+function le(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  ke(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+function ve(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], n = 0;
+  if (r) return r.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function _e(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var n = r.call(e), s, a = [], o;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(s = n.next()).done; ) a.push(s.value);
+  } catch (i) {
+    o = { error: i };
+  } finally {
+    try {
+      s && !s.done && (r = n.return) && r.call(n);
+    } finally {
+      if (o) throw o.error;
+    }
+  }
+  return a;
+}
+function Ae(e, t, r) {
+  if (r || arguments.length === 2) for (var n = 0, s = t.length, a; n < s; n++)
+    (a || !(n in t)) && (a || (a = Array.prototype.slice.call(t, 0, n)), a[n] = t[n]);
+  return e.concat(a || Array.prototype.slice.call(t));
+}
+function P(e) {
+  return typeof e == "function";
+}
+function ft(e) {
+  var t = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, r = e(t);
+  return r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r;
+}
+var de = ft(function(e) {
+  return function(r) {
+    e(this), this.message = r ? r.length + ` errors occurred during unsubscription:
+` + r.map(function(n, s) {
+      return s + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = r;
+  };
+});
+function Le(e, t) {
+  if (e) {
+    var r = e.indexOf(t);
+    0 <= r && e.splice(r, 1);
+  }
+}
+var ue = (function() {
+  function e(t) {
+    this.initialTeardown = t, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t, r, n, s, a;
+    if (!this.closed) {
+      this.closed = !0;
+      var o = this._parentage;
+      if (o)
+        if (this._parentage = null, Array.isArray(o))
+          try {
+            for (var i = ve(o), l = i.next(); !l.done; l = i.next()) {
+              var f = l.value;
+              f.remove(this);
+            }
+          } catch (h) {
+            t = { error: h };
+          } finally {
+            try {
+              l && !l.done && (r = i.return) && r.call(i);
+            } finally {
+              if (t) throw t.error;
+            }
+          }
+        else
+          o.remove(this);
+      var u = this.initialTeardown;
+      if (P(u))
+        try {
+          u();
+        } catch (h) {
+          a = h instanceof de ? h.errors : [h];
+        }
+      var p = this._finalizers;
+      if (p) {
+        this._finalizers = null;
+        try {
+          for (var g = ve(p), y = g.next(); !y.done; y = g.next()) {
+            var d = y.value;
+            try {
+              Pe(d);
+            } catch (h) {
+              a = a ?? [], h instanceof de ? a = Ae(Ae([], _e(a)), _e(h.errors)) : a.push(h);
+            }
+          }
+        } catch (h) {
+          n = { error: h };
+        } finally {
+          try {
+            y && !y.done && (s = g.return) && s.call(g);
+          } finally {
+            if (n) throw n.error;
+          }
+        }
+      }
+      if (a)
+        throw new de(a);
+    }
+  }, e.prototype.add = function(t) {
+    var r;
+    if (t && t !== this)
+      if (this.closed)
+        Pe(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) && Le(r, t);
+  }, e.prototype.remove = function(t) {
+    var r = this._finalizers;
+    r && Le(r, t), t instanceof e && t._removeParent(this);
+  }, e.EMPTY = (function() {
+    var t = new e();
+    return t.closed = !0, t;
+  })(), e;
+})(), dt = ue.EMPTY;
+function pt(e) {
+  return e instanceof ue || e && "closed" in e && P(e.remove) && P(e.add) && P(e.unsubscribe);
+}
+function Pe(e) {
+  P(e) ? e() : e.unsubscribe();
+}
+var Ht = {
+  Promise: void 0
+}, zt = {
+  setTimeout: function(e, t) {
+    for (var r = [], n = 2; n < arguments.length; n++)
+      r[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, Ae([e, t], _e(r)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function Xt(e) {
+  zt.setTimeout(function() {
+    throw e;
+  });
+}
+function Be() {
+}
+function oe(e) {
+  e();
+}
+var yt = (function(e) {
+  le(t, e);
+  function t(r) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, r ? (n.destination = r, pt(r) && r.add(n)) : n.destination = Jt, n;
+  }
+  return t.create = function(r, n, s) {
+    return new Te(r, n, s);
+  }, 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;
+})(ue), Vt = (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 (n) {
+        ee(n);
+      }
+  }, e.prototype.error = function(t) {
+    var r = this.partialObserver;
+    if (r.error)
+      try {
+        r.error(t);
+      } catch (n) {
+        ee(n);
+      }
+    else
+      ee(t);
+  }, e.prototype.complete = function() {
+    var t = this.partialObserver;
+    if (t.complete)
+      try {
+        t.complete();
+      } catch (r) {
+        ee(r);
+      }
+  }, e;
+})(), Te = (function(e) {
+  le(t, e);
+  function t(r, n, s) {
+    var a = e.call(this) || this, o;
+    return P(r) || !r ? o = {
+      next: r ?? void 0,
+      error: n ?? void 0,
+      complete: s ?? void 0
+    } : o = r, a.destination = new Vt(o), a;
+  }
+  return t;
+})(yt);
+function ee(e) {
+  Xt(e);
+}
+function qt(e) {
+  throw e;
+}
+var Jt = {
+  closed: !0,
+  next: Be,
+  error: qt,
+  complete: Be
+}, Kt = (function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})();
+function Qt(e) {
+  return e;
+}
+function Zt(e) {
+  return e.length === 0 ? Qt : e.length === 1 ? e[0] : function(r) {
+    return e.reduce(function(n, s) {
+      return s(n);
+    }, r);
+  };
+}
+var Ne = (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, n) {
+    var s = this, a = tr(t) ? t : new Te(t, r, n);
+    return oe(function() {
+      var o = s, i = o.operator, l = o.source;
+      a.add(i ? i.call(a, l) : l ? s._subscribe(a) : s._trySubscribe(a));
+    }), a;
+  }, e.prototype._trySubscribe = function(t) {
+    try {
+      return this._subscribe(t);
+    } catch (r) {
+      t.error(r);
+    }
+  }, e.prototype.forEach = function(t, r) {
+    var n = this;
+    return r = je(r), new r(function(s, a) {
+      var o = new Te({
+        next: function(i) {
+          try {
+            t(i);
+          } catch (l) {
+            a(l), o.unsubscribe();
+          }
+        },
+        error: a,
+        complete: s
+      });
+      n.subscribe(o);
+    });
+  }, e.prototype._subscribe = function(t) {
+    var r;
+    return (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(t);
+  }, e.prototype[Kt] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var t = [], r = 0; r < arguments.length; r++)
+      t[r] = arguments[r];
+    return Zt(t)(this);
+  }, e.prototype.toPromise = function(t) {
+    var r = this;
+    return t = je(t), new t(function(n, s) {
+      var a;
+      r.subscribe(function(o) {
+        return a = o;
+      }, function(o) {
+        return s(o);
+      }, function() {
+        return n(a);
+      });
+    });
+  }, e.create = function(t) {
+    return new e(t);
+  }, e;
+})();
+function je(e) {
+  var t;
+  return (t = e ?? Ht.Promise) !== null && t !== void 0 ? t : Promise;
+}
+function er(e) {
+  return e && P(e.next) && P(e.error) && P(e.complete);
+}
+function tr(e) {
+  return e && e instanceof yt || er(e) && pt(e);
+}
+var rr = ft(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), gt = (function(e) {
+  le(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 n = new We(this, this);
+    return n.operator = r, n;
+  }, t.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new rr();
+  }, t.prototype.next = function(r) {
+    var n = this;
+    oe(function() {
+      var s, a;
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.currentObservers || (n.currentObservers = Array.from(n.observers));
+        try {
+          for (var o = ve(n.currentObservers), i = o.next(); !i.done; i = o.next()) {
+            var l = i.value;
+            l.next(r);
+          }
+        } catch (f) {
+          s = { error: f };
+        } finally {
+          try {
+            i && !i.done && (a = o.return) && a.call(o);
+          } finally {
+            if (s) throw s.error;
+          }
+        }
+      }
+    });
+  }, t.prototype.error = function(r) {
+    var n = this;
+    oe(function() {
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.hasError = n.isStopped = !0, n.thrownError = r;
+        for (var s = n.observers; s.length; )
+          s.shift().error(r);
+      }
+    });
+  }, t.prototype.complete = function() {
+    var r = this;
+    oe(function() {
+      if (r._throwIfClosed(), !r.isStopped) {
+        r.isStopped = !0;
+        for (var n = r.observers; n.length; )
+          n.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 n = this, s = this, a = s.hasError, o = s.isStopped, i = s.observers;
+    return a || o ? dt : (this.currentObservers = null, i.push(r), new ue(function() {
+      n.currentObservers = null, Le(i, r);
+    }));
+  }, t.prototype._checkFinalizedStatuses = function(r) {
+    var n = this, s = n.hasError, a = n.thrownError, o = n.isStopped;
+    s ? r.error(a) : o && r.complete();
+  }, t.prototype.asObservable = function() {
+    var r = new Ne();
+    return r.source = this, r;
+  }, t.create = function(r, n) {
+    return new We(r, n);
+  }, t;
+})(Ne), We = (function(e) {
+  le(t, e);
+  function t(r, n) {
+    var s = e.call(this) || this;
+    return s.destination = r, s.source = n, s;
+  }
+  return t.prototype.next = function(r) {
+    var n, s;
+    (s = (n = this.destination) === null || n === void 0 ? void 0 : n.next) === null || s === void 0 || s.call(n, r);
+  }, t.prototype.error = function(r) {
+    var n, s;
+    (s = (n = this.destination) === null || n === void 0 ? void 0 : n.error) === null || s === void 0 || s.call(n, r);
+  }, t.prototype.complete = function() {
+    var r, n;
+    (n = (r = this.destination) === null || r === void 0 ? void 0 : r.complete) === null || n === void 0 || n.call(r);
+  }, t.prototype._subscribe = function(r) {
+    var n, s;
+    return (s = (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(r)) !== null && s !== void 0 ? s : dt;
+  }, t;
+})(gt);
+const mt = 3e3;
+var wt = /* @__PURE__ */ ((e) => (e.Warning = "warning", e.Success = "success", e.Error = "error", e.Info = "info", e))(wt || {}), bt = /* @__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))(bt || {}), St = /* @__PURE__ */ ((e) => (e.Warning = "Warning", e.Success = "Success", e.Error = "Error", e.Info = "Info", e))(St || {}), nr = /* @__PURE__ */ ((e) => (e.Center = "center", e.Left = "left", e.Right = "right", e.Bottom = "bottom", e.Top = "top", e))(nr || {});
+class sr {
+  constructor(t = "", r = "info", n = "none", s = "Info", a = mt, o = "center", i = !1) {
+    this.message = t, this.color = r, this.icon = n, this.title = s, this.timeout = a, this.position = o, this.visible = i;
+  }
+}
+class or {
+  static subject = new gt();
+  static get snack$() {
+    return this.subject.asObservable();
+  }
+  static createSnackbar(t, r) {
+    this.subject.next(
+      new sr(
+        t,
+        wt[r],
+        bt[r],
+        St[r],
+        mt,
+        "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 Et(e, t) {
+  const r = {};
+  for (let n in t)
+    if (Array.isArray(t[n]))
+      JSON.stringify(e[n]) !== JSON.stringify(t[n]) && (r[n] = t[n]);
+    else if (e[n] && typeof e[n] == "object" && t[n] && typeof t[n] == "object") {
+      const s = Et(e[n], t[n]);
+      Object.keys(s).length > 0 && (r[n] = s);
+    } else JSON.stringify(e[n]) !== JSON.stringify(t[n]) && (r[n] = t[n]);
+  return r;
+}
+function ar(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var pe, Ge;
+function ir() {
+  if (Ge) return pe;
+  Ge = 1;
+  class e {
+    /// value;
+    /// next;
+    constructor(n) {
+      this.value = n, this.next = void 0;
+    }
+  }
+  class t {
+    // TODO: Use private class fields when targeting Node.js 12.
+    // #_head;
+    // #_tail;
+    // #_size;
+    constructor() {
+      this.clear();
+    }
+    enqueue(n) {
+      const s = new e(n);
+      this._head ? (this._tail.next = s, this._tail = s) : (this._head = s, this._tail = s), this._size++;
+    }
+    dequeue() {
+      const n = this._head;
+      if (n)
+        return this._head = this._head.next, this._size--, n.value;
+    }
+    clear() {
+      this._head = void 0, this._tail = void 0, this._size = 0;
+    }
+    get size() {
+      return this._size;
+    }
+    *[Symbol.iterator]() {
+      let n = this._head;
+      for (; n; )
+        yield n.value, n = n.next;
+    }
+  }
+  return pe = t, pe;
+}
+var ye, Ye;
+function cr() {
+  if (Ye) return ye;
+  Ye = 1;
+  const e = ir();
+  return ye = (r) => {
+    if (!((Number.isInteger(r) || r === 1 / 0) && r > 0))
+      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+    const n = new e();
+    let s = 0;
+    const a = () => {
+      s--, n.size > 0 && n.dequeue()();
+    }, o = async (f, u, ...p) => {
+      s++;
+      const g = (async () => f(...p))();
+      u(g);
+      try {
+        await g;
+      } catch {
+      }
+      a();
+    }, i = (f, u, ...p) => {
+      n.enqueue(o.bind(null, f, u, ...p)), (async () => (await Promise.resolve(), s < r && n.size > 0 && n.dequeue()()))();
+    }, l = (f, ...u) => new Promise((p) => {
+      i(f, p, ...u);
+    });
+    return Object.defineProperties(l, {
+      activeCount: {
+        get: () => s
+      },
+      pendingCount: {
+        get: () => n.size
+      },
+      clearQueue: {
+        value: () => {
+          n.clear();
+        }
+      }
+    }), l;
+  }, ye;
+}
+var lr = cr();
+const ur = /* @__PURE__ */ ar(lr), G = ur(10), hr = 1e3;
+async function z(e, t) {
+  const r = ut(t);
+  try {
+    const n = await fetch(e, r);
+    return await ht(n);
+  } catch (n) {
+    throw n instanceof TypeError && or.error("Network error. Please check your connection."), n;
+  }
+}
+const c = {
+  async fetch(e, t = {}) {
+    return t.method = "GET", await G(() => z(e, t));
+  },
+  async patch(e, t, r = null, n = {}) {
+    if (n.method = "PATCH", n.body = r ? Et(r, t) : t, Object.keys(n.body).length !== 0)
+      return await G(() => z(e, n));
+  },
+  async post(e, t = void 0, r = {}) {
+    return r.method = "POST", r.body = t, await G(() => z(e, r));
+  },
+  async put(e, t = void 0, r = {}) {
+    return r.method = "PUT", r.body = t, await G(() => z(e, r));
+  },
+  async delete(e, t = void 0, r = {}) {
+    return r.method = "DELETE", r.body = t, await G(() => z(e, r));
+  },
+  async paginatedFetch(e, t) {
+    const r = t ?? hr, n = e.includes("?") ? "&" : "?", s = `${e}${n}page_size=${r}&page=1`, a = ut({ method: "GET" }), o = await G(() => fetch(s, a)), i = Number(o.headers.get("x-total-pages")) || 1, f = [...await ht(o)];
+    for (let u = 2; u <= i; u++) {
+      const p = `${e}${n}page_size=${r}&page=${u}`, g = await G(() => z(p, { method: "GET" }));
+      f.push(...g);
+    }
+    return f;
+  }
+}, He = {
+  HTTP: {
+    type: "HTTP",
+    sourceUri: "",
+    placeholderVariables: []
+  },
+  local: {
+    type: "local",
+    sourceUri: "",
+    placeholderVariables: []
+  }
+}, ze = {
+  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 */
+  }
+}, Xe = {
+  HydroServer: {
+    type: "HydroServer"
+  }
+};
+class on {
+  name = "";
+  settings = {
+    type: "SDL",
+    extractor: JSON.parse(JSON.stringify(He.local)),
+    transformer: JSON.parse(JSON.stringify(ze.CSV)),
+    loader: JSON.parse(JSON.stringify(Xe.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(He[t])
+    );
+  }
+  switchTransformer(t) {
+    this.settings.transformer = JSON.parse(
+      JSON.stringify(ze[t])
+    );
+  }
+  switchLoader(t) {
+    this.settings.loader = JSON.parse(JSON.stringify(Xe[t]));
+  }
+}
+function Ve(e) {
+  return {
+    name: e.name,
+    settings: e.settings,
+    workspaceId: e.workspaceId,
+    orchestrationSystemId: e.orchestrationSystem.id,
+    schedule: e.schedule,
+    status: e.status
+  };
+}
+const O = "https://lro.hydroserver.org/api", Me = `${O}/auth`, x = `${Me}/browser/account`, ge = `${Me}/browser/session`, ae = `${Me}/browser/provider`, $ = `${O}/data/workspaces`, me = `${O}/data/roles`, R = `${O}/data/datastreams`, N = `${O}/data/sensors`, _ = `${O}/data/things`, qe = `${_}/tags`, X = `${O}/data/orchestration-systems`, F = `${O}/data/data-sources`, Y = `${O}/data/observed-properties`, V = `${O}/data/processing-levels`, J = `${O}/data/result-qualifiers`, H = `${O}/data/units`, an = (e, t, r, n, s) => {
+  let a = `${R}/${e}/observations?format=column`;
+  return a += `&order_by=phenomenonTime&page_size=${t}`, a += `&phenomenon_time_min=${encodeURIComponent(r)}`, n && (a += `&phenomenon_time_max=${encodeURIComponent(n)}`), s && (a += `&page=${s}`), a;
+}, fr = (e, t, r) => {
+  const n = {
+    provider: e,
+    callback_url: t,
+    process: r
+  }, s = lt(), a = document.createElement("form");
+  if (a.method = "POST", a.action = `${ae}/redirect`, s) {
+    const o = document.createElement("input");
+    o.type = "hidden", o.name = "csrfmiddlewaretoken", o.value = s, a.appendChild(o);
+  }
+  for (const o in n) {
+    const i = document.createElement("input");
+    i.type = "hidden", i.name = o, i.value = n[o] || "", a.appendChild(i);
+  }
+  document.body.appendChild(a), a.submit();
+}, cn = {
+  fetchSession: async () => c.fetch(`${ge}`),
+  login: async (e, t) => c.post(`${ge}`, { email: e, password: t }),
+  logout: async () => c.delete(`${ge}`),
+  fetchUser: async () => c.fetch(`${x}`),
+  signup: async (e) => c.post(`${x}`, e),
+  updateUser: async (e, t) => c.patch(`${x}`, e, t),
+  deleteUser: async () => c.delete(`${x}`),
+  sendVerificationEmail: async (e) => c.put(`${x}/email/verify`, {
+    email: e
+  }),
+  verifyEmailWithCode: async (e) => c.post(`${x}/email/verify`, { key: e }),
+  requestPasswordReset: async (e) => c.post(`${x}/password/request`, {
+    email: e
+  }),
+  resetPassword: async (e, t) => c.post(`${x}/password/reset`, {
+    key: e,
+    password: t
+  }),
+  fetchWorkspaces: async () => c.paginatedFetch(`${$}`),
+  fetchAssociatedWorkspaces: async () => c.paginatedFetch(`${$}?is_associated=true`),
+  fetchWorkspace: async (e) => c.fetch(`${$}/${e}`),
+  createWorkspace: async (e) => c.post($, e),
+  updateWorkspace: async (e, t = null) => c.patch(
+    `${$}/${e.id}`,
+    e,
+    t
+  ),
+  deleteWorkspace: async (e) => c.delete(`${$}/${e}`),
+  transferWorkspace: async (e, t) => c.post(`${$}/${e}/transfer`, { newOwner: t }),
+  acceptWorkspaceTransfer: async (e) => c.put(`${$}/${e}/transfer`),
+  rejectWorkspaceTransfer: async (e) => c.delete(`${$}/${e}/transfer`),
+  getCollaboratorRoles: async (e) => c.paginatedFetch(`${me}?is_user_role=true`),
+  getAPIKeyRoles: async (e) => c.paginatedFetch(`${me}?is_apikey_role=true`),
+  getRole: async (e) => c.fetch(`${me}/${e}`),
+  getCollaborators: async (e) => c.paginatedFetch(`${$}/${e}/collaborators`),
+  addCollaborator: async (e, t, r) => c.post(`${$}/${e}/collaborators`, {
+    email: t,
+    roleId: r
+  }),
+  updateCollaboratorRole: async (e, t, r) => c.put(`${$}/${e}/collaborators`, {
+    email: t,
+    roleId: r
+  }),
+  removeCollaborator: async (e, t) => c.delete(`${$}/${e}/collaborators`, { email: t }),
+  fetchApiKeys: async (e) => c.paginatedFetch(
+    `${$}/${e}/api-keys?expand_related=true`
+  ),
+  fetchApiKey: async (e, t) => c.fetch(
+    `${$}/${e}/api-keys/${t}?expand_related=true`
+  ),
+  createApiKey: async (e) => c.post(
+    `${$}/${e.workspaceId}/api-keys?expand_related=true`,
+    {
+      name: e.name,
+      description: e.description,
+      isActive: !0,
+      roleId: e.role.id
+    }
+  ),
+  updateApiKey: async (e, t) => c.patch(
+    `${$}/${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) => c.put(
+    `${$}/${e}/api-keys/${t}/regenerate?expand_related=true`
+  ),
+  deleteApiKey: async (e, t) => c.delete(`${$}/${e}/api-keys/${t}`),
+  fetchConnectedProviders: async () => c.fetch(`${ae}/connections`),
+  providerRedirect: fr,
+  providerSignup: async (e) => c.post(`${ae}/signup`, e),
+  deleteProvider: async (e, t) => c.delete(`${ae}/connections`, {
+    provider: e,
+    account: t
+  }),
+  createUnit: async (e) => c.post(H, e),
+  fetchUnits: async () => c.paginatedFetch(`${H}`),
+  fetchWorkspaceUnits: async (e) => c.paginatedFetch(`${H}?workspace_id=${e}`),
+  updateUnit: async (e, t = null) => c.patch(`${H}/${e.id}`, e, t),
+  deleteUnit: async (e) => c.delete(`${H}/${e}`),
+  getUnit: async (e) => c.fetch(`${H}/${e}`),
+  removeThingOwner: async (e, t) => c.patch(`${_}/${e}/ownership`, {
+    email: t,
+    removeOwner: !0
+  }),
+  addSecondaryOwner: async (e, t) => c.patch(`${_}/${e}/ownership`, {
+    email: t,
+    makeOwner: !0
+  }),
+  transferPrimaryOwnership: async (e, t) => c.patch(`${_}/${e}/ownership`, {
+    email: t,
+    transferPrimary: !0
+  }),
+  createThing: async (e) => c.post(_, e),
+  fetchThings: async () => c.paginatedFetch(`${_}`),
+  fetchThingsForWorkspace: async (e) => c.paginatedFetch(`${_}?workspace_id=${e}`),
+  fetchOwnedThings: async () => c.paginatedFetch(`${_}?owned_only=true`),
+  fetchThing: async (e) => c.fetch(`${_}/${e}`),
+  updateThing: async (e) => c.patch(`${_}/${e.id}`, e),
+  updateThingPrivacy: async (e, t) => c.patch(`${_}/${e}`, { isPrivate: t }),
+  deleteThing: async (e) => c.delete(`${_}/${e}`),
+  fetchMetadataForThingOwner: async (e) => c.paginatedFetch(
+    `${_}/${e}/metadata?include_assignable_metadata=true`
+  ),
+  fetchMetadataForThing: async (e) => c.fetch(`${_}/${e}/metadata`),
+  uploadSitePhotos: async (e, t) => c.post(`${_}/${e}/photos`, t),
+  fetchSitePhotos: async (e) => c.paginatedFetch(`${_}/${e}/photos`),
+  deleteSitePhoto: async (e, t) => c.delete(`${_}/${e}/photos`, { name: t }),
+  createSiteTag: async (e, t) => c.post(`${_}/${e}/tags`, t),
+  editSiteTag: async (e, t) => c.put(`${_}/${e}/tags`, t),
+  fetchSiteTags: async (e) => c.fetch(`${_}/${e}/tags`),
+  fetchUsersSiteTags: async () => c.fetch(`${qe}`),
+  deleteSiteTag: async (e, t) => c.delete(`${_}/${e}/tags`, t),
+  fetchWorkspaceTags: async (e) => c.fetch(`${qe}/keys?workspace_id=${e}`),
+  createHydroShareArchive: async (e) => c.post(`${_}/${e.thingId}/archive`, e),
+  updateHydroShareArchive: async (e, t) => c.patch(
+    `${_}/${e.thingId}/archive`,
+    e,
+    t
+  ),
+  fetchHydroShareArchive: async (e) => c.fetch(`${_}/${e}/archive`),
+  deleteHydroShareArchive: async (e) => c.delete(`${_}/${e}/archive`),
+  archiveToHydroShare: async (e) => c.post(`${_}/${e}/archive/trigger`),
+  createDatastream: async (e) => c.post(R, e),
+  fetchDatastreams: async (e) => {
+    const t = [];
+    if (e)
+      for (const [n, s] of Object.entries(e))
+        t.push(`${encodeURIComponent(n)}=${encodeURIComponent(s)}`);
+    const r = t.length ? `?${t.join("&")}` : "";
+    return c.paginatedFetch(`${R}${r}`);
+  },
+  fetchDatastreamsForThing: async (e) => c.paginatedFetch(`${R}?thing_id=${e}`),
+  fetchExpandedDatastreamsForThing: async (e) => c.paginatedFetch(
+    `${R}?thing_id=${e}&expand_related=true`
+  ),
+  fetchDatastreamsForDataSource: async (e) => c.paginatedFetch(`${R}?data_source_id=${e}`),
+  fetchDatastream: async (e) => c.fetch(`${R}/${e}`),
+  fetchDatastreamExpanded: async (e) => c.fetch(`${R}/${e}?expand_related=true`),
+  fetchUsersDatastreams: async () => c.paginatedFetch(`${R}?exclude_unowned=true`),
+  updateDatastream: async (e, t = null) => c.patch(`${R}/${e.id}`, e, t),
+  deleteDatastream: async (e) => c.delete(`${R}/${e}`),
+  downloadDatastreamCSV: async (e) => c.fetch(`${R}/${e}/csv`),
+  createObservedProperty: async (e) => c.post(Y, e),
+  fetchObservedProperty: async (e) => c.fetch(`${Y}/${e}`),
+  fetchObservedProperties: async () => c.paginatedFetch(`${Y}`),
+  fetchWorkspaceObservedProperties: async (e) => c.paginatedFetch(`${Y}?workspace_id=${e}`),
+  updateObservedProperty: async (e, t = null) => c.patch(`${Y}/${e.id}`, e, t),
+  deleteObservedProperty: async (e) => c.delete(`${Y}/${e}`),
+  createProcessingLevel: async (e) => c.post(V, e),
+  fetchProcessingLevels: async () => c.paginatedFetch(`${V}`),
+  fetchProcessingLevel: async (e) => c.fetch(`${V}/${e}`),
+  fetchWorkspaceProcessingLevels: async (e) => c.paginatedFetch(`${V}?workspace_id=${e}`),
+  updateProcessingLevel: async (e, t = null) => c.patch(`${V}/${e.id}`, e, t),
+  deleteProcessingLevel: async (e) => c.delete(`${V}/${e}`),
+  createSensor: async (e) => c.post(N, e),
+  fetchSensors: async () => c.paginatedFetch(`${N}`),
+  fetchSensor: async (e) => c.fetch(`${N}/${e}`),
+  fetchWorkspaceSensors: async (e) => c.paginatedFetch(`${N}?workspace_id=${e}`),
+  updateSensor: async (e, t = null) => c.patch(`${N}/${e.id}`, e, t),
+  deleteSensor: async (e) => c.delete(`${N}/${e}`),
+  createResultQualifier: async (e) => c.post(J, e),
+  fetchResultQualifiers: async () => c.paginatedFetch(`${J}`),
+  fetchWorkspaceResultQualifiers: async (e) => c.paginatedFetch(`${J}?workspace_id=${e}`),
+  updateResultQualifier: async (e, t = null) => c.patch(
+    `${J}/${e.id}`,
+    e,
+    t
+  ),
+  deleteResultQualifier: async (e) => c.delete(`${J}/${e}`),
+  createOrchestrationSystem: async (e) => c.post(X, e),
+  fetchOrchestrationSystems: async () => c.paginatedFetch(X),
+  fetchWorkspaceOrchestrationSystems: async (e) => c.paginatedFetch(`${X}?workspace_id=${e}`),
+  fetchOrchestrationSystem: async (e) => c.fetch(`${X}/${e}`),
+  updateOrchestrationSystem: async (e, t) => c.patch(`${X}/${e}`, t),
+  deleteOrchestrationSystem: async (e) => c.delete(`${X}/${e}`),
+  createDataSource: async (e) => c.post(
+    `${F}?expand_related=true`,
+    Ve(e)
+  ),
+  fetchDataSources: async () => c.paginatedFetch(`${F}?expand_related=true`),
+  fetchWorkspaceDataSources: async (e) => c.paginatedFetch(
+    `${F}?workspace_id=${e}&expand_related=true`
+  ),
+  fetchDataSource: async (e) => c.fetch(`${F}/${e}?expand_related=true`),
+  updateDataSource: async (e) => c.patch(
+    `${F}/${e.id}?expand_related=true`,
+    Ve(e)
+  ),
+  updateDataSourcePartial: async (e) => c.patch(
+    `${F}/${e.id}?expand_related=true`,
+    e
+  ),
+  deleteDataSource: async (e) => c.delete(`${F}/${e}`),
+  linkDatastreamToDataSource: async (e, t) => c.post(
+    `${F}/${e}/datastreams/${t}`
+  ),
+  unlinkDatastreamFromDataSource: async (e, t) => c.delete(
+    `${F}/${e}/datastreams/${t}`
+  ),
+  fetchObservations: async (e) => c.fetch(e),
+  deleteObservationsForDatastream: async (e) => c.post(`${R}/${e}/observations/bulk-delete`, {
+    phenomenonTimeStart: null,
+    phenomenonTimeEnd: null
+  }),
+  fetchUserTypes: async () => c.fetch(`${x}/user-types`),
+  fetchOrganizationTypes: async () => c.fetch(`${x}/organization-types`),
+  fetchSiteTypes: async () => c.fetch(`${_}/site-types`),
+  fetchSamplingFeatureTypes: async () => c.paginatedFetch(`${_}/sampling-feature-types`),
+  fetchSensorEncodingTypes: async () => c.paginatedFetch(`${N}/encoding-types`),
+  fetchMethodTypes: async () => c.paginatedFetch(`${N}/method-types`),
+  fetchVariableTypes: async () => c.paginatedFetch(`${Y}/variable-types`),
+  fetchUnitTypes: async () => c.paginatedFetch(`${H}/types`),
+  fetchDatastreamStatuses: async () => c.paginatedFetch(`${R}/statuses`),
+  fetchDatastreamAggregations: async () => c.paginatedFetch(`${R}/aggregation-statistics`),
+  fetchSampledMediums: async () => c.paginatedFetch(`${R}/sampled-mediums`)
 };
-var y = /* @__PURE__ */ ((s) => (s.ADD = "ADD", s.SUB = "SUB", s.MULT = "MULT", s.DIV = "DIV", s.ASSIGN = "ASSIGN", s))(y || {}), G = /* @__PURE__ */ ((s) => (s.LT = "Less than", s.LTE = "Less than or equal to", s.GT = "Greater than", s.GTE = "Greater than or equal to", s.E = "Equal", s))(G || {});
-const U = {
-  "Less than": (s, t) => s < t,
-  "Less than or equal to": (s, t) => s <= t,
-  "Greater than": (s, t) => s > t,
-  "Greater than or equal to": (s, t) => s >= t,
-  Equal: (s, t) => s == 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 M(s) {
+class ln {
+  name = "";
+  mappings = [];
+  extractorVariables = {};
+  constructor(t) {
+    Object.assign(this, t);
+  }
+}
+const kt = 1, ie = kt * 60, Ue = ie * 60, Oe = Ue * 24, dr = Oe * 7, pr = Ue * 30, yr = Oe * 365, te = {
+  [D.SECOND]: kt,
+  [D.MINUTE]: ie,
+  [D.HOUR]: Ue,
+  [D.DAY]: Oe,
+  [D.WEEK]: dr,
+  [D.MONTH]: pr,
+  [D.YEAR]: yr
+}, un = (e) => e.toLocaleString(void 0, {
+  year: "numeric",
+  month: "short",
+  day: "2-digit",
+  hour: "2-digit",
+  hour12: !1,
+  minute: "2-digit",
+  second: "2-digit"
+}), hn = (e) => {
+  let t, r;
+  e >= ie * 1e3 ? (t = e / (ie * 1e3), r = "m") : e >= 1e3 ? (t = e / 1e3, r = "s") : (t = e, r = "ms");
+  let n;
+  return r === "ms" ? n = Math.round(t).toString() : n = t.toFixed(2), `${n} ${r}`;
+}, we = async (e, t) => {
+  t && console.info(t);
+  const r = performance.now(), n = await e(), s = performance.now();
+  console.info(`	Done in ${(s - r).toFixed(2)} ms`);
+  const a = +(s - r);
+  return { response: n, duration: a };
+};
+function fn(e, t) {
+  const r = new Date(e);
+  return r.setHours(r.getHours() - t), r.toISOString();
+}
+const re = (e, t) => {
+  let r = 0, n = e.length;
+  for (; r < n; ) {
+    const s = r + n >> 1;
+    e[s] < t ? r = s + 1 : n = s;
+  }
+  return r;
+}, be = (e, t) => {
+  let r = 0, n = e.length;
+  for (; r < n; ) {
+    const s = r + n >> 1;
+    e[s] > t ? n = s : r = s + 1;
+  }
+  return r - 1;
+}, vt = `(function(){"use strict";function c(n,s,a,u,f,l,y,o){let r=0,e=o;for(let t=l;t<=y;t++)r<a.length&&t===a[r]?r++:(u[e]=n[t],f[e]=s[t],e++);return e-o}self.onmessage=n=>{const{bufferX:s,bufferY:a,outputBufferX:u,outputBufferY:f,start:l,end:y,deleteSegment:o,startTarget:r}=n.data,e=new Float64Array(s),t=new Float32Array(a),A=new Float64Array(u),g=new Float32Array(f);c(e,t,o,A,g,l,y,r),self.postMessage("Done")}})();
+`, Je = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", vt], { type: "text/javascript;charset=utf-8" });
+function gr(e) {
+  let t;
+  try {
+    if (t = Je && (self.URL || self.webkitURL).createObjectURL(Je), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(vt),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const _t = `(function(){"use strict";function F(n,l,a,o,s,y,g,f,i,w,A){let e=0,t=f;for(let r=y;r<=g;r++)if(o[t]=n[r],s[t]=l[r],t++,e<a.length&&r===a[e][0]){const u=a[e][0],c=a[e][1],d=n[u],h=n[c],m=l[u],D=l[c],x=h-d,P=D-m;let p=d+i;for(;p<h;)o[t]=p,s[t]=w?m+(p-d)*P/x:A,t++,p+=i;e++}return t-f}self.onmessage=n=>{const{bufferX:l,bufferY:a,outputBufferX:o,outputBufferY:s,start:y,end:g,gapsSegment:f,startTarget:i,fillDelta:w,interpolate:A,fillValue:e}=n.data,t=new Float64Array(l),r=new Float32Array(a),u=new Float64Array(o),c=new Float32Array(s);F(t,r,f,u,c,y,g,i,w,A,e),self.postMessage("Done")}})();
+`, Ke = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", _t], { type: "text/javascript;charset=utf-8" });
+function mr(e) {
+  let t;
+  try {
+    if (t = Ke && (self.URL || self.webkitURL).createObjectURL(Ke), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(_t),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const At = `(function(){"use strict";function g(o,n,c){for(let s=0;s<c.length;s++){const{indexes:t,lowerIdx:l,upperIdx:r}=c[s],i=o[l],f=n[l],a=o[r],d=n[r],p=a-i,w=d-f;if(p===0){for(let e=0;e<t.length;e++)n[t[e]]=f;continue}for(let e=0;e<t.length;e++){const u=t[e];n[u]=f+(o[u]-i)*w/p}}}self.onmessage=o=>{const{bufferX:n,bufferY:c,groups:s}=o.data,t=new Float64Array(n),l=new Float32Array(c);g(t,l,s),self.postMessage("Done")}})();
+`, Qe = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", At], { type: "text/javascript;charset=utf-8" });
+function wr(e) {
+  let t;
+  try {
+    if (t = Qe && (self.URL || self.webkitURL).createObjectURL(Qe), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(At),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const Lt = `(function(){"use strict";self.onmessage=r=>{const{bufferX:s,bufferY:o,jobs:a}=r.data,f=new Float64Array(s),n=new Float32Array(o);for(let e=0;e<a.length;e++){const{chunkStart:c,chunkEnd:l,startDatetime:u,value:i,extent:y}=a[e];for(let t=c;t<l;t++)n[t]=n[t]+i*((f[t]-u)/y)}self.postMessage("Done")}})();
+`, Ze = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Lt], { type: "text/javascript;charset=utf-8" });
+function br(e) {
+  let t;
+  try {
+    if (t = Ze && (self.URL || self.webkitURL).createObjectURL(Ze), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Lt),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const Tt = `(function(){"use strict";function u(f,o,a,n,l,c,s,i){let r=c,e=0,t=i;const w=a.length;for(;r<s&&e<w;){const y=a[e][0];f[r]<=y?(n[t]=f[r],l[t]=o[r],r++):(n[t]=y,l[t]=a[e][1],e++),t++}for(;r<s;)n[t]=f[r],l[t]=o[r],r++,t++;for(;e<w;)n[t]=a[e][0],l[t]=a[e][1],e++,t++;return t-i}self.onmessage=f=>{const{bufferX:o,bufferY:a,outputBufferX:n,outputBufferY:l,origStart:c,origEnd:s,insertions:i,outStart:r}=f.data,e=new Float64Array(o),t=new Float32Array(a),w=new Float64Array(n),y=new Float32Array(l);u(e,t,i,w,y,c,s,r),self.postMessage("Done")}})();
+`, et = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Tt], { type: "text/javascript;charset=utf-8" });
+function Sr(e) {
+  let t;
+  try {
+    if (t = et && (self.URL || self.webkitURL).createObjectURL(et), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Tt),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const $t = `(function(){"use strict";self.onmessage=i=>{const{bufferX:c,bufferY:g,outputBufferX:d,outputBufferY:y,indexes:n,outStart:r,amount:f,isMonth:Y,isYear:h,deltaMs:w}=i.data,s=new Float64Array(c),a=new Float32Array(g),l=new Float64Array(d),u=new Float32Array(y);if(Y)for(let t=0;t<n.length;t++){const e=n[t],o=new Date(s[e]);o.setMonth(o.getMonth()+f),l[r+t]=o.getTime(),u[r+t]=a[e]}else if(h)for(let t=0;t<n.length;t++){const e=n[t],o=new Date(s[e]);o.setFullYear(o.getFullYear()+f),l[r+t]=o.getTime(),u[r+t]=a[e]}else for(let t=0;t<n.length;t++){const e=n[t];l[r+t]=s[e]+w,u[r+t]=a[e]}self.postMessage("Done")}})();
+`, tt = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", $t], { type: "text/javascript;charset=utf-8" });
+function Er(e) {
+  let t;
+  try {
+    if (t = tt && (self.URL || self.webkitURL).createObjectURL(tt), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent($t),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const Rt = `(function(){"use strict";function a(e,t,o,c){const n=[];let r=e[t];for(let s=t+1;s<=o;s++){const f=e[s];f-r>c&&n.push(s-1,s),r=f}return n}self.onmessage=e=>{const{bufferX:t,start:o,endInclusive:c,threshold:n}=e.data,r=new Float64Array(t);self.postMessage(a(r,o,c,n))}})();
+`, rt = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Rt], { type: "text/javascript;charset=utf-8" });
+function kr(e) {
+  let t;
+  try {
+    if (t = rt && (self.URL || self.webkitURL).createObjectURL(rt), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Rt),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const It = `(function(){"use strict";function c(u,s,t){const n=[];if(s>=t)return n;let e=s,o=u[s];for(let r=s+1;r<t;r++){const f=u[r];f!==o&&(n.push(e,r-e,o),e=r,o=f)}return n.push(e,t-e,o),n}self.onmessage=u=>{const{bufferY:s,start:t,end:n}=u.data,e=new Float32Array(s);self.postMessage(c(e,t,n))}})();
+`, nt = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", It], { type: "text/javascript;charset=utf-8" });
+function vr(e) {
+  let t;
+  try {
+    if (t = nt && (self.URL || self.webkitURL).createObjectURL(nt), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(It),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const Mt = `(function(){"use strict";function o(s,i,t,n,l){const f=[];if(n==="Less than")for(let e=i;e<t;e++)s[e]-s[e-1]<l&&f.push(e);else if(n==="Less than or equal to")for(let e=i;e<t;e++)s[e]-s[e-1]<=l&&f.push(e);else if(n==="Greater than")for(let e=i;e<t;e++)s[e]-s[e-1]>l&&f.push(e);else if(n==="Greater than or equal to")for(let e=i;e<t;e++)s[e]-s[e-1]>=l&&f.push(e);else if(n==="Equal")for(let e=i;e<t;e++)s[e]-s[e-1]==l&&f.push(e);return f}self.onmessage=s=>{const{bufferY:i,start:t,end:n,comparator:l,value:f}=s.data,e=new Float32Array(i);self.postMessage(o(e,t,n,l,f))}})();
+`, st = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Mt], { type: "text/javascript;charset=utf-8" });
+function _r(e) {
+  let t;
+  try {
+    if (t = st && (self.URL || self.webkitURL).createObjectURL(st), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Mt),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+const Ut = `(function(){"use strict";function l(t,i,n,o,h){const f=[];if(o==="Less than")for(let e=i;e<n;e++){const s=t[e-1];(t[e]-s)/Math.abs(s)<h&&f.push(e)}else if(o==="Less than or equal to")for(let e=i;e<n;e++){const s=t[e-1];(t[e]-s)/Math.abs(s)<=h&&f.push(e)}else if(o==="Greater than")for(let e=i;e<n;e++){const s=t[e-1];(t[e]-s)/Math.abs(s)>h&&f.push(e)}else if(o==="Greater than or equal to")for(let e=i;e<n;e++){const s=t[e-1];(t[e]-s)/Math.abs(s)>=h&&f.push(e)}else if(o==="Equal")for(let e=i;e<n;e++){const s=t[e-1];(t[e]-s)/Math.abs(s)==h&&f.push(e)}return f}self.onmessage=t=>{const{bufferY:i,start:n,end:o,comparator:h,value:f}=t.data,e=new Float32Array(i);self.postMessage(l(e,n,o,h,f))}})();
+`, ot = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Ut], { type: "text/javascript;charset=utf-8" });
+function Ar(e) {
   let t;
   try {
-    if (t = b && (self.URL || self.webkitURL).createObjectURL(b), !t) throw "";
-    const a = new Worker(t, {
-      name: s?.name
+    if (t = ot && (self.URL || self.webkitURL).createObjectURL(ot), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
     });
-    return a.addEventListener("error", () => {
+    return r.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(t);
-    }), a;
+    }), r;
   } catch {
     return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(I),
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Ut),
       {
-        name: s?.name
+        name: e?.name
       }
     );
-  } finally {
-    t && (self.URL || self.webkitURL).revokeObjectURL(t);
   }
 }
-const N = `(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([N], { type: "text/javascript;charset=utf-8" });
-function C(s) {
+const Ot = `(function(){"use strict";function k(i,l,u,r,c){const f=[],b=r.length;for(let a=l;a<u;a++){const t=i[a];let e=!1;for(let n=0;n<b;n++){const o=r[n],s=c[n];if(o===0){if(t<s){e=!0;break}}else if(o===1){if(t<=s){e=!0;break}}else if(o===2){if(t>s){e=!0;break}}else if(o===3){if(t>=s){e=!0;break}}else if(t==s){e=!0;break}}e&&f.push(a)}return f}self.onmessage=i=>{const{bufferY:l,start:u,end:r,ops:c,values:f}=i.data,b=new Float32Array(l);self.postMessage(k(b,u,r,c,f))}})();
+`, at = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Ot], { type: "text/javascript;charset=utf-8" });
+function $e(e) {
   let t;
   try {
-    if (t = R && (self.URL || self.webkitURL).createObjectURL(R), !t) throw "";
-    const a = new Worker(t, {
-      name: s?.name
+    if (t = at && (self.URL || self.webkitURL).createObjectURL(at), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
     });
-    return a.addEventListener("error", () => {
+    return r.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(t);
-    }), a;
+    }), r;
   } catch {
     return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(N),
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Ot),
       {
-        name: s?.name
+        name: e?.name
       }
     );
-  } finally {
-    t && (self.URL || self.webkitURL).revokeObjectURL(t);
   }
 }
-const k = (s, t) => {
-  let a = 0, e = s.length;
-  for (; a < e; ) {
-    const n = a + e >> 1;
-    s[n] < t ? a = n + 1 : e = n;
+const xt = `(function(){"use strict";function e(l,t,o,s){const c=t.length;if(o==="ADD")for(let f=0;f<c;f++)l[t[f]]=l[t[f]]+s;else if(o==="SUB")for(let f=0;f<c;f++)l[t[f]]=l[t[f]]-s;else if(o==="MULT")for(let f=0;f<c;f++)l[t[f]]=l[t[f]]*s;else if(o==="DIV")for(let f=0;f<c;f++)l[t[f]]=l[t[f]]/s;else if(o==="ASSIGN")for(let f=0;f<c;f++)l[t[f]]=s}self.onmessage=l=>{const{bufferY:t,indexes:o,operator:s,value:c}=l.data,f=new Float32Array(t);e(f,o,s,c),self.postMessage("Done")}})();
+`, it = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", xt], { type: "text/javascript;charset=utf-8" });
+function Lr(e) {
+  let t;
+  try {
+    if (t = it && (self.URL || self.webkitURL).createObjectURL(it), !t) throw "";
+    const r = new Worker(t, {
+      name: e?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(xt),
+      {
+        name: e?.name
+      }
+    );
+  }
+}
+function Dt(e, t, r, n, s) {
+  const a = [], o = n.length;
+  for (let i = t; i < r; i++) {
+    const l = e[i];
+    let f = !1;
+    for (let u = 0; u < o; u++) {
+      const p = n[u], g = s[u];
+      if (p === 0) {
+        if (l < g) {
+          f = !0;
+          break;
+        }
+      } else if (p === 1) {
+        if (l <= g) {
+          f = !0;
+          break;
+        }
+      } else if (p === 2) {
+        if (l > g) {
+          f = !0;
+          break;
+        }
+      } else if (p === 3) {
+        if (l >= g) {
+          f = !0;
+          break;
+        }
+      } else if (l == g) {
+        f = !0;
+        break;
+      }
+    }
+    f && a.push(i);
+  }
+  return a;
+}
+function Tr(e, t, r, n, s) {
+  const a = [];
+  if (n === "Less than")
+    for (let o = t; o < r; o++)
+      e[o] - e[o - 1] < s && a.push(o);
+  else if (n === "Less than or equal to")
+    for (let o = t; o < r; o++)
+      e[o] - e[o - 1] <= s && a.push(o);
+  else if (n === "Greater than")
+    for (let o = t; o < r; o++)
+      e[o] - e[o - 1] > s && a.push(o);
+  else if (n === "Greater than or equal to")
+    for (let o = t; o < r; o++)
+      e[o] - e[o - 1] >= s && a.push(o);
+  else if (n === "Equal")
+    for (let o = t; o < r; o++)
+      e[o] - e[o - 1] == s && a.push(o);
+  return a;
+}
+function $r(e, t, r, n, s) {
+  const a = [];
+  if (n === "Less than")
+    for (let o = t; o < r; o++) {
+      const i = e[o - 1];
+      (e[o] - i) / Math.abs(i) < s && a.push(o);
+    }
+  else if (n === "Less than or equal to")
+    for (let o = t; o < r; o++) {
+      const i = e[o - 1];
+      (e[o] - i) / Math.abs(i) <= s && a.push(o);
+    }
+  else if (n === "Greater than")
+    for (let o = t; o < r; o++) {
+      const i = e[o - 1];
+      (e[o] - i) / Math.abs(i) > s && a.push(o);
+    }
+  else if (n === "Greater than or equal to")
+    for (let o = t; o < r; o++) {
+      const i = e[o - 1];
+      (e[o] - i) / Math.abs(i) >= s && a.push(o);
+    }
+  else if (n === "Equal")
+    for (let o = t; o < r; o++) {
+      const i = e[o - 1];
+      (e[o] - i) / Math.abs(i) == s && a.push(o);
+    }
+  return a;
+}
+function Rr(e, t, r, n) {
+  const s = [];
+  let a = e[t];
+  for (let o = t + 1; o <= r; o++) {
+    const i = e[o];
+    i - a > n && s.push(o - 1, o), a = i;
+  }
+  return s;
+}
+function Ir(e, t, r) {
+  const n = [];
+  if (t >= r) return n;
+  let s = t, a = e[t];
+  for (let o = t + 1; o < r; o++) {
+    const i = e[o];
+    i !== a && (n.push(s, o - s, a), s = o, a = i);
+  }
+  return n.push(s, r - s, a), n;
+}
+function Mr(e, t, r, n, s, a, o, i, l, f, u) {
+  let p = 0, g = i;
+  for (let y = a; y <= o; y++)
+    if (n[g] = e[y], s[g] = t[y], g++, p < r.length && y === r[p][0]) {
+      const d = r[p][0], h = r[p][1], b = e[d], w = e[h], m = t[d], S = t[h], A = w - b, L = S - m;
+      let T = b + l;
+      for (; T < w; )
+        n[g] = T, s[g] = f ? m + (T - b) * L / A : u, g++, T += l;
+      p++;
+    }
+  return g - i;
+}
+function Ur(e, t, r, n, s, a, o, i) {
+  let l = a, f = 0, u = i;
+  const p = r.length;
+  for (; l < o && f < p; ) {
+    const g = r[f][0];
+    e[l] <= g ? (n[u] = e[l], s[u] = t[l], l++) : (n[u] = g, s[u] = r[f][1], f++), u++;
   }
+  for (; l < o; )
+    n[u] = e[l], s[u] = t[l], l++, u++;
+  for (; f < p; )
+    n[u] = r[f][0], s[u] = r[f][1], f++, u++;
+  return u - i;
+}
+function Or(e, t, r, n, s, a, o, i) {
+  let l = 0, f = i;
+  for (let u = a; u <= o; u++)
+    l < r.length && u === r[l] ? l++ : (n[f] = e[u], s[f] = t[u], f++);
+  return f - i;
+}
+function xr(e, t, r, n) {
+  const s = r.length, a = new Array(s);
+  if (n.isMonth)
+    for (let o = 0; o < s; o++) {
+      const i = r[o], l = new Date(e[i]);
+      l.setMonth(l.getMonth() + n.amount), a[o] = [l.getTime(), t[i]];
+    }
+  else if (n.isYear)
+    for (let o = 0; o < s; o++) {
+      const i = r[o], l = new Date(e[i]);
+      l.setFullYear(l.getFullYear() + n.amount), a[o] = [l.getTime(), t[i]];
+    }
+  else
+    for (let o = 0; o < s; o++) {
+      const i = r[o];
+      a[o] = [e[i] + n.deltaMs, t[i]];
+    }
   return a;
-}, B = (s, t) => {
-  let a = 0, e = s.length;
-  for (; a < e; ) {
-    const n = a + e >> 1;
-    s[n] > t ? e = n : a = n + 1;
-  }
-  return a - 1;
-}, p = async (s, t) => {
-  const a = performance.now(), e = await s(), n = performance.now();
-  console.log(`	Done in ${(n - a).toFixed(2)} ms`);
-  const r = +(n - a);
-  return { response: e, duration: r };
-}, Y = 1, F = Y * 60, S = F * 60, D = S * 24, v = D * 7, H = S * 30, O = D * 365, A = {
-  s: Y,
-  m: F,
-  h: S,
-  D,
-  W: v,
-  M: H,
-  Y: O
-}, V = (s, t, a) => {
-  if (a === "M") {
-    const e = new Date(s);
-    return e.setMonth(e.getMonth() + t), e.getTime();
-  } else if (a === "Y") {
-    const e = new Date(s);
-    return e.setFullYear(e.getFullYear() + t), e.getTime();
-  } else
-    return s + t * A[a] * 1e3;
-}, L = 20 * 1e3, j = ["date", "value", "qualifier"];
-class q {
+}
+function Dr(e, t, r) {
+  for (let n = 0; n < r.length; n++) {
+    const { indexes: s, lowerIdx: a, upperIdx: o } = r[n], i = e[a], l = t[a], f = e[o], u = t[o], p = f - i, g = u - l;
+    if (p === 0) {
+      for (let y = 0; y < s.length; y++) t[s[y]] = l;
+      continue;
+    }
+    for (let y = 0; y < s.length; y++) {
+      const d = s[y];
+      t[d] = l + (e[d] - i) * g / p;
+    }
+  }
+}
+function Cr(e, t, r) {
+  for (let n = 0; n < r.length; n++) {
+    const s = r[n][0], a = r[n][1], o = r[n][2];
+    if (a <= s) continue;
+    const i = e[s], l = e[a] - i;
+    if (l !== 0)
+      for (let f = s; f < a; f++)
+        t[f] = t[f] + o * ((e[f] - i) / l);
+  }
+}
+function ct(e, t, r, n) {
+  const s = t.length;
+  if (r === "ADD")
+    for (let a = 0; a < s; a++) e[t[a]] = e[t[a]] + n;
+  else if (r === "SUB")
+    for (let a = 0; a < s; a++) e[t[a]] = e[t[a]] - n;
+  else if (r === "MULT")
+    for (let a = 0; a < s; a++) e[t[a]] = e[t[a]] * n;
+  else if (r === "DIV")
+    for (let a = 0; a < s; a++) e[t[a]] = e[t[a]] / n;
+  else if (r === "ASSIGN")
+    for (let a = 0; a < s; a++) e[t[a]] = n;
+}
+const Fr = 1, xe = `qc-utils:calibration:v${Fr}`, Pr = 720 * 60 * 60 * 1e3, ne = 5e4, se = 2e5, ce = {
+  spawnOverheadMs: 50,
+  // worst-case Windows
+  inlineThroughput: 5e4,
+  // 50M elements/sec, conservative
+  workerThroughput: 8e4,
+  // workers slightly faster in-loop once spawned
+  hwConcurrency: 4,
+  measuredAt: 0,
+  userAgent: "default"
+};
+let M = jr() ?? ce, De = null, K = null;
+const Re = /* @__PURE__ */ new Set(), Ie = {
+  // Filter ops — read-only scans, cheap kernels
+  [v.VALUE_THRESHOLD]: {
+    mode: "calibrated",
+    weight: 1,
+    rationale: "O(n) single-pass scan; baseline reference"
+  },
+  [v.CHANGE]: {
+    mode: "calibrated",
+    weight: 1.1,
+    rationale: "O(n) with one subtraction per step"
+  },
+  [v.RATE_OF_CHANGE]: {
+    mode: "calibrated",
+    weight: 1.4,
+    rationale: "O(n) with division + abs per step"
+  },
+  [v.FIND_GAPS]: {
+    mode: "calibrated",
+    weight: 0.9,
+    rationale: "O(n) on X only, mostly empty output"
+  },
+  [v.PERSISTENCE]: {
+    mode: "calibrated",
+    weight: 1.3,
+    rationale: "O(n) + chunk-boundary stitch"
+  },
+  [v.DATETIME_RANGE]: {
+    mode: "always-inline",
+    weight: 0,
+    rationale: "O(log n) binary search; never worth the worker hop"
+  },
+  [v.SELECTION]: {
+    mode: "always-inline",
+    weight: 0,
+    rationale: "Pure history bookkeeping"
+  },
+  // Edit ops — mutate Y in place or rebuild arrays
+  [E.CHANGE_VALUES]: {
+    mode: "calibrated",
+    weight: 0.7,
+    rationale: "O(k) in-place arithmetic on selection"
+  },
+  [E.ASSIGN_VALUES_BULK]: {
+    mode: "always-inline",
+    weight: 0,
+    rationale: "Single tight loop, already inline"
+  },
+  [E.ASSIGN_DATETIMES_BULK]: {
+    mode: "always-inline",
+    weight: 0,
+    rationale: "Composes delete+add which handle their own dispatch"
+  },
+  [E.INTERPOLATE]: {
+    mode: "calibrated",
+    weight: 1.5,
+    rationale: "Linear interp per consecutive group; in-place writes"
+  },
+  [E.DRIFT_CORRECTION]: {
+    mode: "calibrated",
+    weight: 1.2,
+    rationale: "O(range total) in-place math; one pass per range"
+  },
+  [E.SHIFT_DATETIMES]: {
+    mode: "calibrated",
+    weight: 1.1,
+    rationale: "O(k) per-point shift math; inline skips SAB allocation"
+  },
+  [E.ADD_POINTS]: {
+    mode: "calibrated",
+    weight: 1.8,
+    rationale: "Single merge pass over Y/X + insertions; fresh SAB per call"
+  },
+  [E.DELETE_POINTS]: {
+    mode: "calibrated",
+    weight: 1.4,
+    rationale: "Single skip-on-delete pass over Y/X; fresh SAB per call"
+  },
+  [E.FILL_GAPS]: {
+    mode: "calibrated",
+    weight: 1.3,
+    rationale: "Single copy-with-fills pass; fresh SAB sized to newLength"
+  }
+};
+function U(e, t) {
+  const r = Ie[e];
+  if (!r)
+    return {
+      useWorker: !0,
+      predictedInlineMs: 1 / 0,
+      predictedWorkerMs: 0,
+      reason: "unknown op; keeping default worker path"
+    };
+  if (r.mode === "always-inline")
+    return {
+      useWorker: !1,
+      predictedInlineMs: 0,
+      predictedWorkerMs: 0,
+      reason: r.rationale
+    };
+  if (typeof SharedArrayBuffer > "u")
+    return {
+      useWorker: !1,
+      predictedInlineMs: 0,
+      predictedWorkerMs: 1 / 0,
+      reason: "SharedArrayBuffer unavailable; forced inline"
+    };
+  if (r.mode === "always-worker")
+    return {
+      useWorker: !0,
+      predictedInlineMs: 1 / 0,
+      predictedWorkerMs: 0,
+      reason: r.rationale
+    };
+  const n = Br(e, t);
+  if (n <= 0)
+    return {
+      useWorker: !1,
+      predictedInlineMs: 0,
+      predictedWorkerMs: M.spawnOverheadMs,
+      reason: "zero work units"
+    };
+  const s = Math.max(
+    1,
+    Math.min(
+      t.parallelism ?? M.hwConcurrency,
+      M.hwConcurrency
+    )
+  ), a = r.weight * n / M.inlineThroughput, o = M.spawnOverheadMs + r.weight * n / (M.workerThroughput * s), i = a > o;
+  return {
+    useWorker: i,
+    predictedInlineMs: a,
+    predictedWorkerMs: o,
+    reason: i ? `worker faster (${o.toFixed(1)} vs ${a.toFixed(1)} ms)` : `inline faster (${a.toFixed(1)} vs ${o.toFixed(1)} ms)`
+  };
+}
+function Br(e, t) {
+  switch (e) {
+    case E.CHANGE_VALUES:
+    case E.INTERPOLATE:
+    case E.SHIFT_DATETIMES:
+    case E.DRIFT_CORRECTION:
+      return t.selectionSize ?? 0;
+    case E.DELETE_POINTS:
+      return (t.selectionSize ?? 0) + t.datasetSize * 0.25;
+    case E.ADD_POINTS: {
+      const r = Math.max(1, Math.log2(Math.max(t.datasetSize, 2)));
+      return t.datasetSize + (t.selectionSize ?? 0) * r;
+    }
+    default:
+      return t.datasetSize;
+  }
+}
+function dn(e) {
+  return Re.add(e), () => Re.delete(e);
+}
+function pn() {
+  return M;
+}
+function yn() {
+  return De;
+}
+function gn() {
+  return Object.keys(Ie).map((e) => ({ op: e, ...Ie[e] }));
+}
+function mn() {
+  M = ce, De = null;
+  try {
+    localStorage.removeItem(xe);
+  } catch {
+  }
+}
+async function wn(e = {}) {
+  if (typeof window > "u" || !(e.force || M.measuredAt === 0 || Date.now() - M.measuredAt > Pr)) return M;
+  if (K) await K;
+  else {
+    K = Nr().finally(() => {
+      K = null;
+    });
+    const r = await K;
+    M = r, Wr(r), De = r;
+    for (const n of Re) n(M);
+  }
+  return M;
+}
+async function Nr() {
+  if (!(typeof SharedArrayBuffer < "u"))
+    return {
+      ...ce,
+      measuredAt: Date.now(),
+      userAgent: navigator.userAgent,
+      hwConcurrency: navigator.hardwareConcurrency || ce.hwConcurrency,
+      sharedArrayBufferAvailable: !1,
+      samples: { spawnRoundtripMs: [], inlineScanMs: [], workerScanMs: [] }
+    };
+  const t = navigator.hardwareConcurrency || 4, r = new Float32Array(ne);
+  for (let h = 0; h < ne; h++) r[h] = Math.sin(h);
+  const n = await Se(3, () => {
+    const h = performance.now();
+    return Dt(r, 0, ne, [2], [0.5]), performance.now() - h;
+  }), s = Ee(n), a = ne / Math.max(s, 1e-3), o = new SharedArrayBuffer(256 * Float32Array.BYTES_PER_ELEMENT), i = await Se(3, async () => {
+    const h = performance.now();
+    return await new Promise((b) => {
+      const w = new $e();
+      w.onmessage = () => {
+        w.terminate(), b();
+      }, w.postMessage({
+        bufferY: o,
+        start: 0,
+        end: 256,
+        ops: [2],
+        values: [0.5]
+      });
+    }), performance.now() - h;
+  }), l = Ee(i), f = new SharedArrayBuffer(
+    se * Float32Array.BYTES_PER_ELEMENT
+  ), u = new Float32Array(f);
+  for (let h = 0; h < se; h++) u[h] = Math.sin(h);
+  const p = await Se(3, async () => {
+    const h = performance.now();
+    return await new Promise((b) => {
+      const w = new $e();
+      w.onmessage = () => {
+        w.terminate(), b();
+      }, w.postMessage({
+        bufferY: f,
+        start: 0,
+        end: se,
+        ops: [2],
+        values: [0.5]
+      });
+    }), performance.now() - h;
+  }), g = Math.max(Ee(p) - l, 0.1), y = se / g;
+  return {
+    spawnOverheadMs: l,
+    inlineThroughput: a,
+    workerThroughput: y,
+    hwConcurrency: t,
+    measuredAt: Date.now(),
+    userAgent: navigator.userAgent,
+    sharedArrayBufferAvailable: !0,
+    samples: {
+      spawnRoundtripMs: i,
+      inlineScanMs: n,
+      workerScanMs: p
+    }
+  };
+}
+async function Se(e, t) {
+  const r = [];
+  for (let n = 0; n < e; n++)
+    await new Promise((s) => setTimeout(s, 0)), r.push(await t());
+  return r;
+}
+function Ee(e) {
+  if (!e.length) return 0;
+  const t = [...e].sort((n, s) => n - s), r = Math.floor(t.length / 2);
+  return t.length % 2 ? t[r] : (t[r - 1] + t[r]) / 2;
+}
+function jr() {
+  if (typeof localStorage > "u") return null;
+  try {
+    const e = localStorage.getItem(xe);
+    if (!e) return null;
+    const t = JSON.parse(e);
+    return !t || typeof t.spawnOverheadMs != "number" ? null : t;
+  } catch {
+    return null;
+  }
+}
+function Wr(e) {
+  if (!(typeof localStorage > "u"))
+    try {
+      const t = {
+        spawnOverheadMs: e.spawnOverheadMs,
+        inlineThroughput: e.inlineThroughput,
+        workerThroughput: e.workerThroughput,
+        hwConcurrency: e.hwConcurrency,
+        measuredAt: e.measuredAt,
+        userAgent: e.userAgent
+      };
+      localStorage.setItem(xe, JSON.stringify(t));
+    } catch {
+    }
+}
+const Q = 20 * 1e3, Gr = 1024, Yr = ["date", "value", "qualifier"];
+class bn {
   /** The generated dataset to be used for plotting */
   dataset = {
-    dimensions: j,
+    dimensions: Yr,
     source: {
       x: new Float64Array(
         new SharedArrayBuffer(
-          L * Float64Array.BYTES_PER_ELEMENT,
+          Q * Float64Array.BYTES_PER_ELEMENT,
           {
-            maxByteLength: L * Float64Array.BYTES_PER_ELEMENT
+            maxByteLength: Q * Float64Array.BYTES_PER_ELEMENT
             // Max size the array can reach
           }
         )
       ),
       y: new Float32Array(
         new SharedArrayBuffer(
-          L * Float32Array.BYTES_PER_ELEMENT,
+          Q * Float32Array.BYTES_PER_ELEMENT,
           {
-            maxByteLength: L * Float32Array.BYTES_PER_ELEMENT
+            maxByteLength: Q * Float32Array.BYTES_PER_ELEMENT
             // Max size the array can reach
           }
         )
@@ -124,6 +2075,30 @@ class q {
     }
   };
   history = [];
+  /**
+   * Items popped off `history` by `undo()`, in undo order (top of stack
+   * at the end). `redo()` re-dispatches the top. A fresh `dispatchAction`
+   * / `dispatchFilter` call clears the stack — Word-style behavior where
+   * a new edit invalidates the redo chain.
+   */
+  redoStack = [];
+  /**
+   * True while `undo()` / `redo()` is replaying a captured history entry.
+   * Suppresses the redo-stack clearing that otherwise fires on every new
+   * dispatch, so the stack survives the internal replay.
+   */
+  _isReplaying = !1;
+  /**
+   * Set by each operation handler (or any of its subroutines) to record
+   * whether a worker was actually spawned during this dispatch. Sticky-
+   * upgrade semantics: the wrapper resets it to `"inline"` before the
+   * handler runs, and any code that spawns a worker flips it to
+   * `"worker"`. Once flipped it stays flipped for the rest of the
+   * dispatch — so an op whose top-level decision is "inline" but whose
+   * sub-op (e.g. `_shift` → `_deleteDataPoints`) still spawns workers
+   * will honestly show `"worker"` on its history entry.
+   */
+  _pendingExecutionMode = "inline";
   loadingTime = null;
   isLoading = !0;
   rawData;
@@ -134,10 +2109,10 @@ class q {
     if (!t)
       return;
     this.isLoading = !0;
-    const a = await p(() => {
+    const r = await we(() => {
       this._growBuffer(t.datetimes.length), this._resizeTo(t.datetimes.length), this.dataX.set(t.datetimes), this.dataY.set(t.dataValues);
     });
-    this.loadingTime = a.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,22 +2137,22 @@ class q {
    * @param newLength The total number of elements that the view will contain
    */
   _growBuffer(t) {
-    const a = t * Float64Array.BYTES_PER_ELEMENT;
-    let e = this.dataX.buffer.byteLength;
-    for (; a > 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 n = this.dataX.buffer.byteLength;
+    for (; r > n; )
+      n += Q * Float64Array.BYTES_PER_ELEMENT;
+    if (n * Float64Array.BYTES_PER_ELEMENT > this.dataX.buffer.maxByteLength) {
+      const s = new SharedArrayBuffer(
         this.dataX.buffer.byteLength,
         {
-          maxByteLength: e * Float64Array.BYTES_PER_ELEMENT
+          maxByteLength: n * Float64Array.BYTES_PER_ELEMENT
         }
-      ), r = new SharedArrayBuffer(
+      ), a = new SharedArrayBuffer(
         this.dataY.buffer.byteLength,
         {
-          maxByteLength: e * Float32Array.BYTES_PER_ELEMENT
+          maxByteLength: n * Float32Array.BYTES_PER_ELEMENT
         }
-      ), o = new Float64Array(n), i = new Float32Array(r);
+      ), o = new Float64Array(s), i = new Float32Array(a);
       o.set(this.dataX), i.set(this.dataY), this.dataset.source.x = o, this.dataset.source.y = i;
     }
     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 +2168,47 @@ class q {
    * @returns
    */
   async reloadHistory(t) {
-    const a = this.history.slice(0, t + 1);
-    await this.reload(), await this.dispatch(a.map((e) => [e.method, ...e.args || []]));
+    const r = this.history.slice(0, t + 1);
+    return this.redoStack.length = 0, await this.reload(), await this.dispatch(r.map((n) => [n.method, ...n.args || []]));
   }
   /**
    * Remove a history item
    * @param index
    */
   async removeHistoryItem(t) {
-    const a = [...this.history];
-    a.splice(t, 1), await this.reload(), await this.dispatch(a.map((e) => [e.method, ...e.args || []]));
+    const r = [...this.history];
+    return r.splice(t, 1), this.redoStack.length = 0, await this.reload(), await this.dispatch(r.map((n) => [n.method, ...n.args || []]));
+  }
+  /**
+   * Undo the most recent history entry. Pushes it onto `redoStack` so a
+   * subsequent `redo()` can re-apply it, then reloads from the raw
+   * dataset and replays the remaining history in order.
+   */
+  async undo() {
+    if (!this.history.length) return [];
+    const t = this.history[this.history.length - 1], r = this.history.slice(0, -1);
+    await this.reload(), this.redoStack.push(t), this._isReplaying = !0;
+    try {
+      return await this.dispatch(r.map((n) => [n.method, ...n.args || []]));
+    } finally {
+      this._isReplaying = !1;
+    }
+  }
+  /**
+   * Re-apply the most recently undone entry from `redoStack`. The replay
+   * runs through `dispatch`, which pushes a fresh history entry for it;
+   * `_isReplaying` guards the redo stack from being wiped during the
+   * dispatch.
+   */
+  async redo() {
+    if (!this.redoStack.length) return [];
+    const t = this.redoStack.pop();
+    this._isReplaying = !0;
+    try {
+      return await this.dispatch([[t.method, ...t.args || []]]);
+    } finally {
+      this._isReplaying = !1;
+    }
   }
   get beginTime() {
     return this.dataset.source.x.length ? new Date(this.dataset.source.x[0]) : null;
@@ -211,135 +2217,255 @@ class q {
     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, ...a) {
-    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 dispatchAction(t, ...r) {
+    const n = {
+      [E.ADD_POINTS]: this._addDataPoints,
+      [E.CHANGE_VALUES]: this._changeValues,
+      [E.ASSIGN_VALUES_BULK]: this._assignValuesBulk,
+      [E.DELETE_POINTS]: this._deleteDataPoints,
+      [E.DRIFT_CORRECTION]: this._driftCorrection,
+      [E.INTERPOLATE]: this._interpolate,
+      [E.SHIFT_DATETIMES]: this._shift,
+      [E.ASSIGN_DATETIMES_BULK]: this._assignDatetimesBulk,
+      [E.FILL_GAPS]: this._fillGaps
+    }, s = {
+      [E.ADD_POINTS]: "mdi-plus",
+      [E.CHANGE_VALUES]: "mdi-pencil",
+      [E.ASSIGN_VALUES_BULK]: "mdi-pencil",
+      [E.DELETE_POINTS]: "mdi-trash-can",
+      [E.DRIFT_CORRECTION]: "mdi-chart-sankey",
+      [E.INTERPOLATE]: "mdi-transit-connection-horizontal",
+      [E.SHIFT_DATETIMES]: "mdi-calendar",
+      [E.ASSIGN_DATETIMES_BULK]: "mdi-calendar",
+      [E.FILL_GAPS]: "mdi-keyboard-space"
     };
-    let r = [];
+    let a = [];
     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,
-            args: h,
-            icon: n[i],
-            isLoading: !1
-          };
-          this.history.push(l);
-        }
-        for (let o = this.history.length - t.length; o < this.history.length; o++) {
-          const i = this.history[o];
-          i.isLoading = !0;
-          const h = await p(async () => await e[i.method].apply(
-            this,
-            i.args
-          ));
-          i.duration = h.duration, i.isLoading = !1, r.push(h.response);
-        }
-      } else {
-        const o = {
-          method: t,
-          args: a,
-          icon: n[t],
-          isLoading: !0
-        };
-        this.history.push(o);
-        const i = await p(async () => await e[t].apply(this, a));
-        r = i.response, o.duration = i.duration, o.isLoading = !1;
-      }
+      this._isReplaying || (this.redoStack.length = 0);
+      const o = {
+        method: t,
+        args: r,
+        icon: s[t],
+        isLoading: !0
+      };
+      this.history.push(o);
+      const i = this.history.length - 1;
+      this._pendingExecutionMode = "inline";
+      const l = await we(async () => await n[t].apply(this, r));
+      a = l.response;
+      const f = this.history[i];
+      f && (f.duration = l.duration, f.executionMode = this._pendingExecutionMode, f.isLoading = !1);
     } catch (o) {
       console.log(
         `Failed to execute operation: ${t} with arguments: `,
-        a
+        r
       ), console.log(o);
     }
-    return r;
+    return a;
+  }
+  async dispatch(t, ...r) {
+    const n = async (s, a) => v[s] ? await this.dispatchFilter(s, ...a) : await this.dispatchAction(s, ...a);
+    if (Array.isArray(t)) {
+      let s = [];
+      for (let a = 0; a < t.length; a++) {
+        const o = t[a][0], i = t[a].slice(1, t[a].length);
+        s = await n(o, i);
+      }
+      return s;
+    } else
+      return await n(t, r);
   }
-  /** Filter operations do not transform the data and are not logged in history */
-  async dispatchFilter(t, ...a) {
-    const e = {
-      [T.FIND_GAPS]: this._findGaps,
-      [T.VALUE_THRESHOLD]: this._valueThreshold,
-      [T.PERSISTENCE]: this._persistence,
-      [T.RATE_OF_CHANGE]: this._rateOfChange
+  /** Filter operations do not transform the data and return a selection */
+  async dispatchFilter(t, ...r) {
+    const n = {
+      [v.FIND_GAPS]: this._findGaps,
+      [v.VALUE_THRESHOLD]: this._valueThreshold,
+      [v.DATETIME_RANGE]: this._datetimeRange,
+      [v.PERSISTENCE]: this._persistence,
+      [v.CHANGE]: this._change,
+      [v.RATE_OF_CHANGE]: this._rateOfChange,
+      [v.SELECTION]: this._selection
+    }, s = {
+      [v.FIND_GAPS]: "mdi-plus",
+      [v.PERSISTENCE]: "mdi-plus",
+      [v.CHANGE]: "mdi-plus",
+      [v.RATE_OF_CHANGE]: "mdi-plus",
+      [v.VALUE_THRESHOLD]: "mdi-plus",
+      [v.DATETIME_RANGE]: "mdi-plus",
+      [v.SELECTION]: "mdi-plus"
     };
-    let n = [];
+    let a = [];
     try {
-      if (Array.isArray(t))
-        for (let r = 0; r < t.length; r++) {
-          const o = t[r][0], i = t[r].slice(1, t[r].length), h = await e[o].apply(this, i);
-          n.push(h);
-        }
-      else
-        n = await e[t].apply(this, a);
-    } catch (r) {
+      this._isReplaying || (this.redoStack.length = 0);
+      const o = {
+        method: t,
+        args: r,
+        icon: s[t],
+        isLoading: !0
+      }, i = this.history[this.history.length - 1];
+      let l;
+      v[i?.method] ? (l = this.history.length - 1, this.history[l] = o) : (this.history.push(o), l = this.history.length - 1), this._pendingExecutionMode = "inline";
+      const f = await we(async () => await n[t].apply(this, r));
+      a = f.response;
+      const u = this.history[l];
+      u && (u.duration = f.duration, u.executionMode = this._pendingExecutionMode, u.selected = f.response, u.isLoading = !1);
+    } catch (o) {
       console.log(
         `Failed to execute filter operation: ${t} with arguments: `,
-        a
-      ), console.log(r);
+        r
+      ), console.log(o);
     }
-    return n;
+    return a;
   }
   /**
    * @param index An array containing the list of index of values to perform the operations on.
    * @param operator The operator that will be applied
    * @param value The value to use in the operation
-   * @returns The modified DataFrame
-   */
-  _changeValues(t, a, e) {
-    const n = (r) => {
-      switch (a) {
-        case y.ADD:
-          return r + e;
-        case y.ASSIGN:
-          return e;
-        case y.DIV:
-          return r / e;
-        case y.MULT:
-          return r * e;
-        case y.SUB:
-          return r - e;
-        default:
-          return r;
-      }
-    };
-    t.forEach((r) => {
-      this.dataset.source.y[r] = n(this.dataset.source.y[r]);
-    });
+   * @returns an array of index values to keep selected in the plot
+   */
+  /**
+   * Multi-threaded apply of an arithmetic operator to Y at the previously-filtered selection.
+   *  1. Selection is read from the previous history entry (the last entry is this operation itself).
+   *  2. Selection indexes are sharded into disjoint chunks; workers write in place to shared Y.
+   *  3. Writes are conflict-free because the selection carries distinct indexes.
+   */
+  async _changeValues(t, r) {
+    const n = this.history[this.history.length - 2]?.selected;
+    if (!n || n.length === 0) return [];
+    const s = n.length;
+    if (!U(E.CHANGE_VALUES, {
+      datasetSize: this.dataset.source.y.length,
+      selectionSize: s
+    }).useWorker || s < Gr)
+      return ct(this.dataY, n, t, r), [];
+    this._pendingExecutionMode = "worker";
+    const o = Math.min(navigator.hardwareConcurrency || 1, s), i = Math.ceil(s / o), l = [], f = [];
+    for (let u = 0; u < o; u++) {
+      const p = u * i, g = Math.min((u + 1) * i, s);
+      if (p >= g) break;
+      const y = n.slice(p, g);
+      f.push(
+        new Promise((d) => {
+          const h = new Lr();
+          l.push(h), h.postMessage({
+            bufferY: this.dataY.buffer,
+            indexes: y,
+            operator: t,
+            value: r
+          }), h.onmessage = (b) => {
+            d(b.data);
+          };
+        })
+      );
+    }
+    return await Promise.all(f), l.forEach((u) => u.terminate()), [];
   }
-  _interpolate(t) {
-    this._getConsecutiveGroups(t).forEach((e) => {
-      const n = e[0], r = e[e.length - 1];
-      let o = Math.max(0, n - 1), i = Math.min(this.dataset.source.y.length - 1, r + 1);
-      const h = this.dataset.source.x, l = this.dataset.source.y;
-      for (let c = 0; c < e.length; c++)
-        this.dataset.source.y[e[c]] = this._interpolateLinear(
-          h[e[c]],
-          h[o],
-          l[o],
-          h[i],
-          l[i]
-        );
-    });
+  /**
+   * Apply an arithmetic operator to Y in-place on the main thread. Thin
+   * wrapper around {@link changeValuesCore} kept so `_assignValuesBulk`
+   * and callers outside this module can use the same routine the
+   * CHANGE_VALUES fast path does.
+   */
+  _applyOperatorInPlace(t, r, n) {
+    ct(this.dataY, t, r, n);
   }
-  /** Interpolate existing values in the data source */
-  _interpolateLinear(t, a, e, n, r) {
-    return e + (t - a) * (r - e) / (n - a);
+  /**
+   * One-shot assignment of distinct Y-values at the indices logged by the
+   * previous SELECTION filter entry. Args: `(values: number[])`, where
+   * `values[i]` is written to `dataY[selection[i]]`. Runs as a single
+   * tight loop on the main thread — no workers, no per-row dispatch
+   * ceremony. Intended for table-driven edits.
+   *
+   * Expected dispatch order (matches CHANGE_VALUES):
+   *   [[SELECTION, indices], [ASSIGN_VALUES_BULK, values]]
+   * The SELECTION entry carries the indices for history, so this op does
+   * not log them again.
+   */
+  async _assignValuesBulk(t) {
+    const r = this.history[this.history.length - 2]?.selected;
+    if (!r || !r.length || !t?.length) return [];
+    const n = Math.min(r.length, t.length), s = this.dataY;
+    for (let a = 0; a < n; a++) s[r[a]] = t[a];
+    return [];
+  }
+  /**
+   * One-shot assignment of distinct datetimes (epoch-ms) at the indices
+   * logged by the previous SELECTION filter entry. Internally: compute
+   * the replacement (x, y) pairs, do a single delete + single add — so
+   * the reindex-and-sort step runs once regardless of how many rows changed.
+   *
+   * Expected dispatch order (matches SHIFT_DATETIMES pattern):
+   *   [[SELECTION, indices], [ASSIGN_DATETIMES_BULK, datetimes]]
+   */
+  async _assignDatetimesBulk(t) {
+    const r = this.history[this.history.length - 2]?.selected;
+    if (!r || !r.length || !t?.length) return [];
+    const n = Math.min(r.length, t.length), s = new Array(n), a = new Array(n);
+    for (let o = 0; o < n; o++)
+      s[o] = [t[o], this.dataY[r[o]]], a[o] = r[o];
+    return a.sort((o, i) => o - i), await this._deleteDataPoints(a), await this._addDataPoints(s), [];
+  }
+  /**
+   * Multi-threaded linear interpolation over the selected indexes.
+   *  1. Main thread partitions the selected indexes into consecutive groups and computes each group's lower/upper anchors.
+   *  2. Groups are sharded across workers (disjoint by construction, so in-place writes are safe).
+   *  3. Each worker writes interpolated Y values directly into the shared Y buffer — no output copy needed since only a subset of Y changes.
+   */
+  async _interpolate(t) {
+    const r = this._getConsecutiveGroups(t);
+    if (r.length === 0 || r[0].length === 0) return;
+    const n = this.dataset.source.y.length, s = r.map((u) => ({
+      indexes: u,
+      lowerIdx: Math.max(0, u[0] - 1),
+      upperIdx: Math.min(n - 1, u[u.length - 1] + 1)
+    }));
+    if (!U(E.INTERPOLATE, {
+      datasetSize: n,
+      selectionSize: t.length
+    }).useWorker) {
+      Dr(this.dataX, this.dataY, s);
+      return;
+    }
+    this._pendingExecutionMode = "worker";
+    const o = Math.min(
+      navigator.hardwareConcurrency || 1,
+      s.length
+    ), i = Math.ceil(s.length / o), l = [], f = [];
+    for (let u = 0; u < o; u++) {
+      const p = s.slice(
+        u * i,
+        (u + 1) * i
+      );
+      if (p.length === 0) break;
+      f.push(
+        new Promise((g) => {
+          const y = new wr();
+          l.push(y), y.postMessage({
+            bufferX: this.dataX.buffer,
+            bufferY: this.dataY.buffer,
+            groups: p
+          }), y.onmessage = (d) => {
+            g(d.data);
+          };
+        })
+      );
+    }
+    await Promise.all(f), l.forEach((u) => u.terminate());
   }
+  /** Interpolate existing values in the data source */
+  // private _interpolateLinear(
+  //   datetime: number,
+  //   lowerDatetime: number,
+  //   lowerValue: number,
+  //   upperDatetime: number,
+  //   upperValue: number,
+  // ) {
+  //   const interpolatedValue =
+  //     lowerValue +
+  //     ((datetime - lowerDatetime) * (upperValue - lowerValue)) /
+  //     (upperDatetime - lowerDatetime);
+  //   return interpolatedValue;
+  // }
   /**
    * Shifts the selected indexes by specified amount of units. Elements are reinserted according to their datetime.
    * @param index The index of the elements to shift
@@ -347,60 +2473,141 @@ class q {
    * @param unit {@link TimeUnit}
    * @returns
    */
-  async _shift(t, a, e) {
-    const n = t.map((r) => [
-      V(this.dataX[r], a, e),
-      this.dataY[r]
-    ]);
-    await this._deleteDataPoints(t), await this._addDataPoints(n);
-  }
-  async _fillGapsV2(t, a, e, n) {
-    const r = navigator.hardwareConcurrency || 1, o = [], i = [], h = this.dataX.length, l = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
-      maxByteLength: this.dataX.buffer.maxByteLength
-    }), c = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
-      maxByteLength: this.dataY.buffer.maxByteLength
-    });
-    for (let u = 0; u < r; u++)
-      i.push(
-        new Promise((d) => {
-          const E = new C();
-          o.push(E), E.postMessage({
+  async _shift(t, r, n) {
+    if (t.length === 0) return;
+    const s = n === D.MONTH, a = n === D.YEAR, o = !s && !a ? r * te[n] * 1e3 : 0, i = t.length;
+    if (!U(E.SHIFT_DATETIMES, {
+      datasetSize: this.dataset.source.x.length,
+      selectionSize: i
+    }).useWorker) {
+      const m = xr(
+        this.dataX,
+        this.dataY,
+        t,
+        { amount: r, isMonth: s, isYear: a, deltaMs: o }
+      );
+      await this._deleteDataPoints(t), await this._addDataPoints(m);
+      return;
+    }
+    this._pendingExecutionMode = "worker";
+    const f = new SharedArrayBuffer(
+      i * Float64Array.BYTES_PER_ELEMENT
+    ), u = new SharedArrayBuffer(
+      i * Float32Array.BYTES_PER_ELEMENT
+    ), p = Math.min(navigator.hardwareConcurrency || 1, i), g = Math.ceil(i / p), y = [], d = [];
+    for (let m = 0; m < p; m++) {
+      const S = m * g, A = Math.min((m + 1) * g, i);
+      if (S >= A) break;
+      const L = t.slice(S, A);
+      d.push(
+        new Promise((T) => {
+          const I = new Er();
+          y.push(I), I.postMessage({
             bufferX: this.dataX.buffer,
             bufferY: this.dataY.buffer,
-            outputBufferX: l,
-            outputBufferY: c
-          }), E.onmessage = (g) => {
-            d(g.data);
+            outputBufferX: f,
+            outputBufferY: u,
+            indexes: L,
+            outStart: S,
+            amount: r,
+            isMonth: s,
+            isYear: a,
+            deltaMs: o
+          }), I.onmessage = (j) => {
+            T(j.data);
           };
         })
       );
-    await Promise.all(i), o.forEach((u) => u.terminate()), this.dataset.source.x = new Float64Array(l), this.dataset.source.y = new Float32Array(c), this._resizeTo(h);
+    }
+    await Promise.all(d), y.forEach((m) => m.terminate());
+    const h = new Float64Array(f), b = new Float32Array(u), w = new Array(i);
+    for (let m = 0; m < i; m++)
+      w[m] = [h[m], b[m]];
+    await this._deleteDataPoints(t), await this._addDataPoints(w);
   }
   /**
-   * Find gaps and fill them with placeholder value
-   * @param gap Intervals to detect as gaps
-   * @param fill Interval used to fill the detected gaps
-   * @param interpolateValues If true, the new values will be linearly interpolated
-   * @returns
+   * Multi-threaded version of {@link _fillGaps}.
+   *  1. The main thread scans once for gaps and computes the number of fill points per gap.
+   *  2. The original array is split into equal segments; each gap is assigned to the segment containing its left index.
+   *  3. Cumulative fill counts before each segment give each worker's output startTarget, ensuring no overlap.
+   *  4. Each worker copies its segment to the output buffer and inserts its gap fills inline.
    */
-  // TODO: this needs to be improved using web workers
-  _fillGaps(t, a, e, n) {
-    const r = this._findGaps(t[0], t[1], n);
-    for (let o = r.length - 1; o >= 0; o--) {
-      const i = r[o], h = this.dataX[i[0]], l = this.dataX[i[1]], c = [], u = a[0] * A[a[1]] * 1e3;
-      let d = h + u;
-      for (; d < l; ) {
-        const E = e ? this._interpolateLinear(
-          d,
-          this.dataX[i[0]],
-          this.dataY[i[0]],
-          this.dataX[i[1]],
-          this.dataY[i[1]]
-        ) : -9999;
-        c.push([d, E]), d += u;
+  async _fillGaps(t, r, n, s) {
+    const a = this.dataX.length;
+    if (a === 0) return;
+    const o = t[0] * te[t[1]] * 1e3, i = r[0] * te[r[1]] * 1e3, l = -9999, f = s?.[0] ?? 0, u = s?.[1] ?? a - 1, p = this.dataX, g = [], y = [];
+    let d = 0;
+    for (let k = f + 1; k <= u; k++)
+      if (p[k] - p[k - 1] > o) {
+        let C = 0, W = p[k - 1] + i;
+        for (; W < p[k]; )
+          C++, W += i;
+        C > 0 && (g.push([k - 1, k]), y.push(C), d += C);
       }
-      this._addDataPoints(c);
+    if (d === 0) return;
+    const h = a + d, b = h * Float64Array.BYTES_PER_ELEMENT, w = h * Float32Array.BYTES_PER_ELEMENT, m = new SharedArrayBuffer(b, {
+      maxByteLength: Math.max(this.dataX.buffer.maxByteLength, b)
+    }), S = new SharedArrayBuffer(w, {
+      maxByteLength: Math.max(this.dataY.buffer.maxByteLength, w)
+    });
+    if (!U(E.FILL_GAPS, {
+      datasetSize: a,
+      selectionSize: d
+    }).useWorker) {
+      const k = new Float64Array(m), B = new Float32Array(S);
+      Mr(
+        this.dataX,
+        this.dataY,
+        g,
+        k,
+        B,
+        0,
+        a - 1,
+        0,
+        i,
+        n,
+        l
+      ), this.dataset.source.x = k, this.dataset.source.y = B, this._resizeTo(h);
+      return;
+    }
+    this._pendingExecutionMode = "worker";
+    const L = navigator.hardwareConcurrency || 1, T = Math.ceil(a / L), I = [];
+    let j = 0;
+    for (let k = 0; k < L; k++) {
+      const B = k * T, C = Math.min((k + 1) * T - 1, a - 1), W = [];
+      let Z = 0;
+      for (; j < g.length && g[j][0] <= C; )
+        W.push(g[j]), Z += y[j], j++;
+      I.push({ start: B, end: C, gapsSegment: W, fillsInSegment: Z });
+    }
+    const he = new Array(L).fill(0);
+    for (let k = 1; k < L; k++)
+      he[k] = he[k - 1] + I[k - 1].fillsInSegment;
+    const Ce = [], Fe = [];
+    for (let k = 0; k < L; k++) {
+      const { start: B, end: C, gapsSegment: W } = I[k], Z = B + he[k];
+      Fe.push(
+        new Promise((Ct) => {
+          const fe = new mr();
+          Ce.push(fe), fe.postMessage({
+            bufferX: this.dataX.buffer,
+            bufferY: this.dataY.buffer,
+            outputBufferX: m,
+            outputBufferY: S,
+            start: B,
+            end: C,
+            gapsSegment: W,
+            startTarget: Z,
+            fillDelta: i,
+            interpolate: n,
+            fillValue: l
+          }), fe.onmessage = (Ft) => {
+            Ct(Ft.data);
+          };
+        })
+      );
     }
+    await Promise.all(Fe), Ce.forEach((k) => k.terminate()), this.dataset.source.x = new Float64Array(m), this.dataset.source.y = new Float32Array(S), this._resizeTo(h);
   }
   /**
    Deletes data points from a large array using worker threads.
@@ -410,42 +2617,64 @@ class q {
     4. Each worker processes its segment linearly, skipping deletions and copying kept elements to their computed positions.
     * @param deleteIndices 
    */
-  // TODO: implement similar multithread solutions for other operations
   async _deleteDataPoints(t) {
-    const a = navigator.hardwareConcurrency || 1, e = Math.ceil(this.dataX.length / a), n = [], r = [];
-    for (let u = 0; u < a; u++) {
-      const d = u * e, E = Math.min((u + 1) * e - 1, this.dataX.length - 1), g = k(t, d), _ = B(t, E), m = t.slice(g, _ + 1);
-      r.push({ start: d, end: E, deleteSegment: m });
-    }
-    const o = new Array(a).fill(0);
-    for (let u = 1; u < a; u++)
-      o[u] = o[u - 1] + r[u - 1].deleteSegment.length;
-    const i = [], h = this.dataX.length - t.length, l = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
+    const r = this.dataX.length, n = r - t.length;
+    if (!U(E.DELETE_POINTS, {
+      datasetSize: r,
+      selectionSize: t.length
+    }).useWorker) {
+      const y = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
+        maxByteLength: this.dataX.buffer.maxByteLength
+      }), d = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
+        maxByteLength: this.dataY.buffer.maxByteLength
+      }), h = new Float64Array(y), b = new Float32Array(d);
+      Or(
+        this.dataX,
+        this.dataY,
+        t,
+        h,
+        b,
+        0,
+        r - 1,
+        0
+      ), this.dataset.source.x = h, this.dataset.source.y = b, this._resizeTo(n);
+      return;
+    }
+    this._pendingExecutionMode = "worker";
+    const a = navigator.hardwareConcurrency || 1, o = Math.ceil(this.dataX.length / a), i = [], l = [];
+    for (let y = 0; y < a; y++) {
+      const d = y * o, h = Math.min((y + 1) * o - 1, this.dataX.length - 1), b = re(t, d), w = be(t, h), m = t.slice(b, w + 1);
+      l.push({ start: d, end: h, deleteSegment: m });
+    }
+    const f = new Array(a).fill(0);
+    for (let y = 1; y < a; y++)
+      f[y] = f[y - 1] + l[y - 1].deleteSegment.length;
+    const u = [], p = new SharedArrayBuffer(this.dataX.buffer.byteLength, {
       maxByteLength: this.dataX.buffer.maxByteLength
-    }), c = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
+    }), g = new SharedArrayBuffer(this.dataY.buffer.byteLength, {
       maxByteLength: this.dataY.buffer.maxByteLength
     });
-    for (let u = 0; u < a; u++) {
-      const { start: d, end: E, deleteSegment: g } = r[u], _ = d - o[u];
-      i.push(
+    for (let y = 0; y < a; y++) {
+      const { start: d, end: h, deleteSegment: b } = l[y], w = d - f[y];
+      u.push(
         new Promise((m) => {
-          const w = new M();
-          n.push(w), w.postMessage({
+          const S = new gr();
+          i.push(S), S.postMessage({
             bufferX: this.dataX.buffer,
             bufferY: this.dataY.buffer,
-            outputBufferX: l,
-            outputBufferY: c,
+            outputBufferX: p,
+            outputBufferY: g,
             start: d,
-            end: E,
-            deleteSegment: g,
-            startTarget: _
-          }), w.onmessage = (P) => {
-            m(P.data);
+            end: h,
+            deleteSegment: b,
+            startTarget: w
+          }), S.onmessage = (A) => {
+            m(A.data);
           };
         })
       );
     }
-    await Promise.all(i), n.forEach((u) => u.terminate()), this.dataset.source.x = new Float64Array(l), this.dataset.source.y = new Float32Array(c), this._resizeTo(h);
+    await Promise.all(u), i.forEach((y) => y.terminate()), this.dataset.source.x = new Float64Array(p), this.dataset.source.y = new Float32Array(g), this._resizeTo(n);
   }
   /**
    *
@@ -453,10 +2682,63 @@ class q {
    * @param end The end index
    * @param value The drift amount
    */
-  _driftCorrection(t, a, e) {
-    const n = this.dataset.source.x, r = this.dataset.source.y, o = n[t], h = n[a] - o;
-    for (let l = t; l < a; l++)
-      this.dataset.source.y[l] = r[l] + e * ((n[l] - o) / h);
+  /**
+   * Multi-threaded drift correction over one or more [start, end, value] ranges.
+   *  1. Main thread reads each range's anchors (startDatetime, extent) once and chunks the range.
+   *  2. All chunks across all ranges are flattened into jobs and distributed round-robin across a fixed pool of workers.
+   *  3. Each worker applies y_n = y_0 + value * ((x_i - startDatetime) / extent) in place on its jobs.
+   *  4. Batching all ranges into a single call yields a single history entry.
+   */
+  async _driftCorrection(t) {
+    if (!t || t.length === 0) return;
+    const r = this.dataset.source.x, n = navigator.hardwareConcurrency || 1;
+    let s = 0;
+    for (const [p, g] of t)
+      g > p && (s += g - p);
+    if (!U(E.DRIFT_CORRECTION, {
+      datasetSize: r.length,
+      selectionSize: s
+    }).useWorker) {
+      Cr(r, this.dataY, t);
+      return;
+    }
+    this._pendingExecutionMode = "worker";
+    const o = [];
+    for (const [p, g, y] of t) {
+      if (g <= p) continue;
+      const d = r[p], h = r[g] - d;
+      if (h === 0) continue;
+      const b = g - p, w = Math.max(1, Math.ceil(b / n));
+      for (let m = p; m < g; m += w)
+        o.push({
+          chunkStart: m,
+          chunkEnd: Math.min(m + w, g),
+          startDatetime: d,
+          value: y,
+          extent: h
+        });
+    }
+    if (o.length === 0) return;
+    const i = Math.min(n, o.length), l = Array.from(
+      { length: i },
+      () => []
+    );
+    o.forEach((p, g) => l[g % i].push(p));
+    const f = [], u = [];
+    for (const p of l)
+      p.length !== 0 && u.push(
+        new Promise((g) => {
+          const y = new br();
+          f.push(y), y.postMessage({
+            bufferX: this.dataX.buffer,
+            bufferY: this.dataY.buffer,
+            jobs: p
+          }), y.onmessage = (d) => {
+            g(d.data);
+          };
+        })
+      );
+    await Promise.all(u), f.forEach((p) => p.terminate());
   }
   /** Traverses the index array and returns groups of consecutive values.
    * i.e.: `[0, 1, 3, 4, 6] => [[0, 1], [3, 4], [6]]`
@@ -464,28 +2746,73 @@ class q {
    * @param index: the index array (sorted)
    */
   _getConsecutiveGroups(t) {
-    const a = [[]];
-    return t.reduce((e, n) => {
-      const r = e[e.length - 1];
-      return !r.length || n == r[r.length - 1] + 1 ? r.push(n) : e.push([n]), e;
-    }, a), a;
+    const r = [[]];
+    return t.reduce((n, s) => {
+      const a = n[n.length - 1];
+      return !a.length || s == a[a.length - 1] + 1 ? a.push(s) : n.push([s]), n;
+    }, r), r;
   }
   /**
-   * Adds data points. Their insert index is determined using `findFirstGreaterOrEqual` in the x-axis.
-   * @param dataPoints
+   * Adds data points using worker threads.
+   *  1. Main thread sorts insertions by datetime and computes each insertion's target index via binary search on the original X.
+   *  2. The original array is split into equal chunks; each insertion is assigned to the chunk containing its target index.
+   *  3. `firstIns` per chunk doubles as the prefix sum of insertions placed before the chunk, giving each worker its outStart in the output buffer without overlap.
+   *  4. Each worker linearly merges its original slice with its insertion slice (both already sorted by datetime) into the output buffer. Originals win on datetime ties, matching the original `findLastLessOrEqual` semantics.
    */
   async _addDataPoints(t) {
-    const a = this.dataX.length + t.length;
-    this._growBuffer(a), t.sort((r, o) => r[0] - o[0]);
-    const e = t.map((r) => B(this.dataX, r[0]) + 1);
-    this._resizeTo(a), e.push(this.dataX.length);
-    let n = t.length;
-    for (let r = e.length - 1; r > 0; r--) {
-      const o = e[r - 1], i = e[r] - 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[r - 1][0], this.dataY[o + n] = t[r - 1][1];
+    if (t.length === 0) return;
+    const r = this.dataX.length, n = r + t.length;
+    t.sort((d, h) => d[0] - h[0]);
+    const s = n * Float64Array.BYTES_PER_ELEMENT, a = n * Float32Array.BYTES_PER_ELEMENT, o = new SharedArrayBuffer(s, {
+      maxByteLength: Math.max(this.dataX.buffer.maxByteLength, s)
+    }), i = new SharedArrayBuffer(a, {
+      maxByteLength: Math.max(this.dataY.buffer.maxByteLength, a)
+    });
+    if (!U(E.ADD_POINTS, {
+      datasetSize: r,
+      selectionSize: t.length
+    }).useWorker) {
+      const d = new Float64Array(o), h = new Float32Array(i);
+      Ur(
+        this.dataX,
+        this.dataY,
+        t,
+        d,
+        h,
+        0,
+        r,
+        0
+      ), this.dataset.source.x = d, this.dataset.source.y = h, this._resizeTo(n);
+      return;
+    }
+    this._pendingExecutionMode = "worker";
+    const f = t.map(
+      (d) => be(this.dataX, d[0]) + 1
+    ), u = Math.max(
+      1,
+      Math.min(navigator.hardwareConcurrency || 1, Math.max(r, 1))
+    ), p = Math.ceil(Math.max(r, 1) / u), g = [], y = [];
+    for (let d = 0; d < u; d++) {
+      const h = d * p, b = Math.min((d + 1) * p, r), w = re(f, h), m = d === u - 1 ? t.length : re(f, b), S = t.slice(w, m), A = h + w;
+      h >= b && S.length === 0 || y.push(
+        new Promise((L) => {
+          const T = new Sr();
+          g.push(T), T.postMessage({
+            bufferX: this.dataX.buffer,
+            bufferY: this.dataY.buffer,
+            outputBufferX: o,
+            outputBufferY: i,
+            origStart: h,
+            origEnd: b,
+            insertions: S,
+            outStart: A
+          }), T.onmessage = (I) => {
+            L(I.data);
+          };
+        })
+      );
     }
+    await Promise.all(y), g.forEach((d) => d.terminate()), this.dataset.source.x = new Float64Array(o), this.dataset.source.y = new Float32Array(i), this._resizeTo(n);
   }
   // =======================
   // FILTER OPERATIONS
@@ -493,16 +2820,130 @@ class q {
   /**
    * Filter by applying a set of logical operations
    * @param appliedFilters
+   * @returns an array of index values to select in the plot
+   */
+  /**
+   * Filter by applying a set of logical operations, using worker threads.
+   *  1. Main thread encodes filters as numeric opcodes + thresholds (cheaper than string compares in the hot loop).
+   *  2. Workers scan disjoint chunks of Y; an index is selected if ANY filter matches (short-circuit).
+   *  3. Results from each chunk are concatenated in order to preserve ascending indexes.
+   *
+   * Opcodes: 0=LT, 1=LTE, 2=GT, 3=GTE, 4=E.
+   */
+  async _valueThreshold(t) {
+    const r = Object.keys(t);
+    if (r.length === 0) return [];
+    const n = {
+      [q.LT]: 0,
+      [q.LTE]: 1,
+      [q.GT]: 2,
+      [q.GTE]: 3,
+      [q.E]: 4
+    }, s = r.map((h) => n[h] ?? 4), a = r.map((h) => t[h]), o = this.dataset.source.y, i = o.length;
+    if (i === 0) return [];
+    if (!U(v.VALUE_THRESHOLD, {
+      datasetSize: i
+    }).useWorker)
+      return Dt(o, 0, i, s, a);
+    this._pendingExecutionMode = "worker";
+    const f = Math.min(navigator.hardwareConcurrency || 1, i), u = Math.ceil(i / f), p = [], g = [];
+    for (let h = 0; h < f; h++) {
+      const b = h * u, w = Math.min((h + 1) * u, i);
+      if (b >= w) break;
+      g.push(
+        new Promise((m) => {
+          const S = new $e();
+          p.push(S), S.postMessage({
+            bufferY: this.dataY.buffer,
+            start: b,
+            end: w,
+            ops: s,
+            values: a
+          }), S.onmessage = (A) => {
+            m(A.data);
+          };
+        })
+      );
+    }
+    const y = await Promise.all(g);
+    p.forEach((h) => h.terminate());
+    const d = [];
+    for (let h = 0; h < y.length; h++) {
+      const b = y[h];
+      for (let w = 0; w < b.length; w++) d.push(b[w]);
+    }
+    return d;
+  }
+  /**
+   *
+   * @param comparator
+   * @param value
    * @returns
    */
-  _valueThreshold(t) {
-    const a = [];
-    return this.dataset.source.y.forEach((e, n) => {
-      Object.keys(t).some((r) => x[r]?.(
-        e,
-        t[r]
-      )) && a.push(n);
-    }), a;
+  /**
+   * Find points where the relative rate `(curr - prev) / |prev|` satisfies the comparator, using worker threads.
+   *  1. Main thread partitions scan range [1, dataY.length) into chunks; `Y[i-1]` is safely read from the shared buffer across chunk boundaries.
+   *  2. Each worker runs a hoisted branch matching the comparator and returns matching indexes in ascending order.
+   *  3. Main thread concatenates results in chunk order, preserving ascending order.
+   */
+  async _rateOfChange(t, r) {
+    const n = this.dataset.source.y;
+    if (n.length < 2) return [];
+    const s = 1, a = n.length, o = a - s;
+    if (!U(v.RATE_OF_CHANGE, {
+      datasetSize: n.length
+    }).useWorker)
+      return $r(n, s, a, t, r);
+    this._pendingExecutionMode = "worker";
+    const l = Math.min(navigator.hardwareConcurrency || 1, o), f = Math.ceil(o / l), u = [], p = [];
+    for (let d = 0; d < l; d++) {
+      const h = s + d * f, b = Math.min(s + (d + 1) * f, a);
+      if (h >= b) break;
+      p.push(
+        new Promise((w) => {
+          const m = new Ar();
+          u.push(m), m.postMessage({
+            bufferY: this.dataY.buffer,
+            start: h,
+            end: b,
+            comparator: t,
+            value: r
+          }), m.onmessage = (S) => {
+            w(S.data);
+          };
+        })
+      );
+    }
+    const g = await Promise.all(p);
+    u.forEach((d) => d.terminate());
+    const y = [];
+    for (let d = 0; d < g.length; d++) {
+      const h = g[d];
+      for (let b = 0; b < h.length; b++) y.push(h[b]);
+    }
+    return y;
+  }
+  /**
+   * Select all points whose datetime falls inside `[from, to]` (inclusive).
+   * `dataX` is sorted ascending, so binary search bounds the range in
+   * O(log n) — no workers required. Pass `undefined` for either bound to
+   * leave that side unconstrained; omitting both selects the full series.
+   */
+  async _datetimeRange(t, r) {
+    const n = this.dataset.source.x, s = n.length;
+    if (s === 0) return [];
+    const a = t == null ? 0 : re(n, t), o = r == null ? s - 1 : be(n, r);
+    if (a > o) return [];
+    const i = new Array(o - a + 1);
+    for (let l = a; l <= o; l++) i[l - a] = l;
+    return i;
+  }
+  /**
+   * @param index
+   * @returns
+   */
+  async _selection(t) {
+    return (!t || !t.length) && this.history.pop(), t;
   }
   /**
    *
@@ -510,57 +2951,227 @@ class q {
    * @param value
    * @returns
    */
-  _rateOfChange(t, a) {
-    const e = [], n = this.dataset.source.y;
-    for (let r = 1; r < n.length; r++) {
-      const o = n[r - 1], h = (n[r] - o) / Math.abs(o);
-      U[t]?.(
-        h,
-        a
-      ) && e.push(r);
+  /**
+   * Find points where the change from the previous value satisfies the comparator, using worker threads.
+   *  1. Main thread partitions scan range [1, dataY.length) into chunks (each chunk's first index safely reads Y[i-1] from the shared buffer).
+   *  2. Each worker runs a hoisted branch matching the comparator and returns matching indexes in ascending order.
+   *  3. Main thread concatenates results in chunk order, preserving ascending order.
+   */
+  async _change(t, r) {
+    const n = this.dataset.source.y;
+    if (n.length < 2) return [];
+    const s = 1, a = n.length, o = a - s;
+    if (!U(v.CHANGE, {
+      datasetSize: n.length
+    }).useWorker)
+      return Tr(n, s, a, t, r);
+    this._pendingExecutionMode = "worker";
+    const l = Math.min(navigator.hardwareConcurrency || 1, o), f = Math.ceil(o / l), u = [], p = [];
+    for (let d = 0; d < l; d++) {
+      const h = s + d * f, b = Math.min(s + (d + 1) * f, a);
+      if (h >= b) break;
+      p.push(
+        new Promise((w) => {
+          const m = new _r();
+          u.push(m), m.postMessage({
+            bufferY: this.dataY.buffer,
+            start: h,
+            end: b,
+            comparator: t,
+            value: r
+          }), m.onmessage = (S) => {
+            w(S.data);
+          };
+        })
+      );
+    }
+    const g = await Promise.all(p);
+    u.forEach((d) => d.terminate());
+    const y = [];
+    for (let d = 0; d < g.length; d++) {
+      const h = g[d];
+      for (let b = 0; b < h.length; b++) y.push(h[b]);
     }
-    return e;
+    return y;
   }
   /**
-   * Find gaps in the data
+   * Find gaps in the data using worker threads.
+   *  1. Main thread slices the scan range [start, end] into equal chunks with a 1-index overlap so adjacent workers observe the boundary delta correctly.
+   *  2. Each worker scans its chunk and returns a flat list of [leftIdx, rightIdx] pairs for gaps whose delta exceeds the threshold.
+   *  3. Main thread collects all pairs and dedups via Set — identical return shape to the original implementation.
    * @param value The time value
    * @param unit The time unit (TimeUnit)
    * @param range If specified, the gaps will be found only within the range
-   * @returns
    */
-  _findGaps(t, a, e) {
-    const n = [], r = this.dataset.source.x;
-    let o = 0, i = r.length;
-    e?.[0] && e?.[1] && (o = e[0], i = e[1]);
-    let h = r[o];
-    for (let l = o + 1; l <= i; l++) {
-      const c = r[l];
-      c - h > t * A[a] * 1e3 && n.push([l - 1, l]), h = c;
+  async _findGaps(t, r, n) {
+    const s = this.dataset.source.x;
+    let a = 0, o = s.length;
+    if (n?.[0] && n?.[1] && (a = n[0], o = n[1]), o <= a) return [];
+    const i = t * te[r] * 1e3;
+    if (!U(v.FIND_GAPS, {
+      datasetSize: o - a
+    }).useWorker) {
+      const b = Rr(s, a, o - 1, i), w = /* @__PURE__ */ new Set();
+      for (let m = 0; m < b.length; m++) w.add(b[m]);
+      return [...w];
+    }
+    this._pendingExecutionMode = "worker";
+    const f = o - a, u = Math.min(navigator.hardwareConcurrency || 1, f), p = Math.ceil(f / u), g = [], y = [];
+    for (let b = 0; b < u; b++) {
+      const w = a + b * p, m = Math.min(a + (b + 1) * p, o);
+      if (w >= m) break;
+      y.push(
+        new Promise((S) => {
+          const A = new kr();
+          g.push(A), A.postMessage({
+            bufferX: this.dataX.buffer,
+            start: w,
+            endInclusive: m,
+            threshold: i
+          }), A.onmessage = (L) => {
+            S(L.data);
+          };
+        })
+      );
     }
-    return n;
+    const d = await Promise.all(y);
+    g.forEach((b) => b.terminate());
+    const h = /* @__PURE__ */ new Set();
+    for (let b = 0; b < d.length; b++) {
+      const w = d[b];
+      for (let m = 0; m < w.length; m++) h.add(w[m]);
+    }
+    return [...h];
   }
   /**
-   * Find points where the values are the same at least x times in a row
-   * @param times The number of times in a row that points can be equal
+   * Find points where the values are the same at least `times` in a row, using worker threads.
+   *  1. Main thread splits [start, end) into chunks and each worker emits its maximal runs of equal Y values as flat (startIndex, length, value) triplets.
+   *  2. Main thread stitches runs that cross chunk boundaries (same value, adjacent indexes).
+   *  3. Every run whose stitched length is >= `times` contributes all of its indexes to the selection.
+   *
+   * Matches the Python reference implementation in `edit_service.py::persistence` — every member of a qualifying run is selected (including the run's first index).
+   * @param times The minimum run length to qualify
    * @param range If specified, the points will be found only within the range
-   * @returns
    */
-  _persistence(t, a) {
-    let e = [], n = this.dataset.source.y, r = 0, o = n.length;
-    a?.[0] && a?.[1] && (r = a[0], o = a[1]);
-    let i = n[r], h = [];
-    for (let l = r + 1; l < o; l++)
-      n[l] != i || l === o ? (h.length >= t && (e = [...e, ...h]), h = []) : h.push(l);
-    return e;
+  async _persistence(t, r) {
+    const n = this.dataset.source.y;
+    let s = 0, a = n.length;
+    if (r?.[0] && r?.[1] && (s = r[0], a = r[1]), a <= s) return [];
+    const o = a - s;
+    if (!U(v.PERSISTENCE, {
+      datasetSize: o
+    }).useWorker) {
+      const w = Ir(n, s, a), m = [];
+      for (let S = 0; S < w.length; S += 3) {
+        const A = w[S], L = w[S + 1];
+        if (L >= t)
+          for (let T = 0; T < L; T++) m.push(A + T);
+      }
+      return m;
+    }
+    this._pendingExecutionMode = "worker";
+    const l = Math.min(navigator.hardwareConcurrency || 1, o), f = Math.ceil(o / l), u = [], p = [];
+    for (let w = 0; w < l; w++) {
+      const m = s + w * f, S = Math.min(s + (w + 1) * f, a);
+      if (m >= S) break;
+      p.push(
+        new Promise((A) => {
+          const L = new vr();
+          u.push(L), L.postMessage({
+            bufferY: this.dataY.buffer,
+            start: m,
+            end: S
+          }), L.onmessage = (T) => {
+            A(T.data);
+          };
+        })
+      );
+    }
+    const g = await Promise.all(p);
+    u.forEach((w) => w.terminate());
+    const y = [], d = [], h = [];
+    for (let w = 0; w < g.length; w++) {
+      const m = g[w];
+      for (let S = 0; S < m.length; S += 3) {
+        const A = m[S], L = m[S + 1], T = m[S + 2], I = y.length - 1;
+        I >= 0 && h[I] === T && y[I] + d[I] === A ? d[I] += L : (y.push(A), d.push(L), h.push(T));
+      }
+    }
+    const b = [];
+    for (let w = 0; w < y.length; w++) {
+      const m = d[w];
+      if (m >= t) {
+        const S = y[w];
+        for (let A = 0; A < m; A++) b.push(S + A);
+      }
+    }
+    return b;
   }
 }
 export {
-  f as EnumEditOperations,
-  T as EnumFilterOperations,
-  X as FilterOperation,
-  x as FilterOperationFn,
-  q as ObservationRecord,
-  y as Operator,
-  U as RateOfChangeComparator,
-  G as RateOfChangeOperation
+  x as ACCOUNT_BASE,
+  Me as AUTH_BASE,
+  rn as ApiKey,
+  O as BASE_URL,
+  sn as Collaborator,
+  mt as DEFAULT_SNACK_DURATION,
+  on as DataSource,
+  Xr as Datastream,
+  E as EnumEditOperations,
+  v as EnumFilterOperations,
+  q as FilterOperation,
+  Nt as HydroShareArchive,
+  Q as INCREASE_AMOUNT,
+  jt as Location,
+  Bt as LogicalOperation,
+  tn as OAuthProvider,
+  bn as ObservationRecord,
+  Jr as ObservedProperty,
+  Pt as Operator,
+  Zr as Organization,
+  ae as PROVIDER_BASE,
+  ln as Payload,
+  Wt as PermissionAction,
+  Gt as PermissionResource,
+  nr as Position,
+  Hr as PostHydroShareArchive,
+  Kr as ProcessingLevel,
+  Qr as ResultQualifier,
+  ge as SESSION_BASE,
+  qr as Sensor,
+  sr as Snack,
+  wt as SnackColor,
+  bt as SnackIcon,
+  St as SnackTitle,
+  or as Snackbar,
+  qe as TAG_BASE,
+  _ as THINGS_BASE,
+  zr as Thing,
+  D as TimeUnit,
+  Vr as Unit,
+  en as User,
+  nn as Workspace,
+  cn as api,
+  c as apiMethods,
+  mn as clearCalibration,
+  Et as createPatchObject,
+  wn as ensureCalibration,
+  Yt as extractErrorMessage,
+  re as findFirstGreaterOrEqual,
+  be as findLastLessOrEqual,
+  un as formatDate,
+  hn as formatDuration,
+  lt as getCSRFToken,
+  pn as getCalibration,
+  yn as getLastBenchmarkDetail,
+  an as getObservationsEndpoint,
+  gn as getOperationTable,
+  we as measureEllapsedTime,
+  dn as onCalibrationChange,
+  ut as requestInterceptor,
+  ht as responseInterceptor,
+  Nr as runBenchmarks,
+  U as shouldUseWorker,
+  fn as subtractHours,
+  te as timeUnitMultipliers
 };