on-zero 0.4.25 → 0.4.27

package/dist/cjs/httpPullTransport.native.js

@@ -0,0 +1,695 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var httpPullTransport_exports = {};
+__export(httpPullTransport_exports, {
+  ensureHttpPullTransport: () => ensureHttpPullTransport,
+  installHttpPullTransport: () => installHttpPullTransport
+});
+module.exports = __toCommonJS(httpPullTransport_exports);
+function _assert_this_initialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _call_super(_this, derived, args) {
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_is_native_reflect_construct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function construct(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2) _set_prototype_of(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _get_prototype_of(o) {
+  _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+function _is_native_function(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+  if (call && (_type_of(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+  return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */new Map() : void 0;
+  _wrap_native_super = function wrapNativeSuper(Class2) {
+    if (Class2 === null || !_is_native_function(Class2)) return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _set_prototype_of(Wrapper, Class2);
+  };
+  return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (_) {}
+  return (_is_native_reflect_construct = function () {
+    return !!result;
+  })();
+}
+var COOKIE_WIDTH = 20;
+function installHttpPullTransport(opts) {
+  var _class;
+  var previousWebSocket = globalThis.WebSocket;
+  var _opts_fetch;
+  var fetchImpl = (_opts_fetch = opts.fetch) !== null && _opts_fetch !== void 0 ? _opts_fetch : globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("installHttpPullTransport requires a fetch implementation");
+  }
+  var state = {
+    origin: new URL(opts.origin),
+    originString: trimTrailingSlash(new URL(opts.origin).toString()),
+    fetch: fetchImpl,
+    nativeWebSocket: previousWebSocket,
+    sockets: /* @__PURE__ */new Set(),
+    pullIntervalMs: opts.pullIntervalMs,
+    nextPokeID: 0
+  };
+  var Shim = (_class = function _class2(url, protocols) {
+    "use strict";
+
+    _class_call_check(this, _class2);
+    if (shouldIntercept(state.origin, url)) {
+      return new ZeroHttpSocket(state, url, protocols);
+    }
+    if (!state.nativeWebSocket) {
+      throw new Error(`No native WebSocket available for ${String(url)}`);
+    }
+    return new state.nativeWebSocket(url, protocols);
+  }, _define_property(_class, "CONNECTING", 0), _define_property(_class, "OPEN", 1), _define_property(_class, "CLOSING", 2), _define_property(_class, "CLOSED", 3), _class);
+  globalThis.WebSocket = Shim;
+  return {
+    pull: async function () {
+      await Promise.all([...state.sockets].map(function (socket) {
+        return socket.pull();
+      }));
+    },
+    get connections() {
+      return state.sockets.size;
+    },
+    uninstall: function () {
+      if (globalThis.WebSocket === Shim) {
+        globalThis.WebSocket = previousWebSocket;
+      }
+    }
+  };
+}
+var transportsByOrigin = /* @__PURE__ */new Map();
+function ensureHttpPullTransport(opts) {
+  var key = trimTrailingSlash(new URL(opts.origin).toString());
+  var existing = transportsByOrigin.get(key);
+  if (existing) return existing;
+  var transport = installHttpPullTransport(opts);
+  transportsByOrigin.set(key, transport);
+  return transport;
+}
+var ZeroHttpSocket = /* @__PURE__ */function () {
+  "use strict";
+
+  function ZeroHttpSocket2(state, url, protocols) {
+    var _this = this;
+    _class_call_check(this, ZeroHttpSocket2);
+    var _decoded_initConnectionMessage;
+    _define_property(this, "state", void 0);
+    _define_property(this, "CONNECTING", void 0);
+    _define_property(this, "OPEN", void 0);
+    _define_property(this, "CLOSING", void 0);
+    _define_property(this, "CLOSED", void 0);
+    _define_property(this, "url", void 0);
+    _define_property(this, "readyState", void 0);
+    _define_property(this, "connectURL", void 0);
+    _define_property(this, "authToken", void 0);
+    _define_property(this, "listeners", void 0);
+    _define_property(this, "clientID", void 0);
+    _define_property(this, "clientGroupID", void 0);
+    _define_property(this, "wsid", void 0);
+    _define_property(this, "cookie", void 0);
+    _define_property(this, "pendingGotQueriesPatch", void 0);
+    _define_property(this, "pullInFlight", void 0);
+    _define_property(this, "pullAfterCurrent", void 0);
+    _define_property(this, "pushChain", void 0);
+    _define_property(this, "nextLocalCookieID", void 0);
+    _define_property(this, "openTimer", void 0);
+    _define_property(this, "pullTimer", void 0);
+    this.state = state;
+    this.CONNECTING = 0;
+    this.OPEN = 1;
+    this.CLOSING = 2;
+    this.CLOSED = 3;
+    this.readyState = this.CONNECTING;
+    this.listeners = {
+      open: /* @__PURE__ */new Set(),
+      message: /* @__PURE__ */new Set(),
+      close: /* @__PURE__ */new Set(),
+      error: /* @__PURE__ */new Set()
+    };
+    this.pendingGotQueriesPatch = [];
+    this.pullAfterCurrent = false;
+    this.pushChain = Promise.resolve();
+    this.nextLocalCookieID = 0;
+    this.connectURL = toHttpURL(url);
+    this.url = String(url);
+    var _this_connectURL_searchParams_get;
+    this.clientID = (_this_connectURL_searchParams_get = this.connectURL.searchParams.get("clientID")) !== null && _this_connectURL_searchParams_get !== void 0 ? _this_connectURL_searchParams_get : "";
+    var _this_connectURL_searchParams_get1;
+    this.clientGroupID = (_this_connectURL_searchParams_get1 = this.connectURL.searchParams.get("clientGroupID")) !== null && _this_connectURL_searchParams_get1 !== void 0 ? _this_connectURL_searchParams_get1 : "";
+    var _this_connectURL_searchParams_get2;
+    this.wsid = (_this_connectURL_searchParams_get2 = this.connectURL.searchParams.get("wsid")) !== null && _this_connectURL_searchParams_get2 !== void 0 ? _this_connectURL_searchParams_get2 : `zero-http-${Date.now()}`;
+    var baseCookie = this.connectURL.searchParams.get("baseCookie");
+    this.cookie = baseCookie ? baseCookie : null;
+    var decoded = decodeSecProtocol(protocols);
+    this.authToken = decoded.authToken;
+    this.queueDesiredQueries((_decoded_initConnectionMessage = decoded.initConnectionMessage) === null || _decoded_initConnectionMessage === void 0 ? void 0 : _decoded_initConnectionMessage[1]);
+    this.state.sockets.add(this);
+    this.openTimer = setTimeout(function () {
+      return _this.open();
+    }, 0);
+  }
+  _create_class(ZeroHttpSocket2, [{
+    key: "addEventListener",
+    value: function addEventListener(type, listener) {
+      var _this_listeners_type;
+      if (listener) (_this_listeners_type = this.listeners[type]) === null || _this_listeners_type === void 0 ? void 0 : _this_listeners_type.add(listener);
+    }
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(type, listener) {
+      var _this_listeners_type;
+      if (listener) (_this_listeners_type = this.listeners[type]) === null || _this_listeners_type === void 0 ? void 0 : _this_listeners_type.delete(listener);
+    }
+  }, {
+    key: "dispatchEvent",
+    value: function dispatchEvent(event) {
+      this.emit(event.type, event);
+      return true;
+    }
+  }, {
+    key: "send",
+    value: function send(data) {
+      if (this.readyState !== this.OPEN) {
+        throw new Error("cannot send on a socket that is not open");
+      }
+      var message = JSON.parse(data);
+      switch (message[0]) {
+        case "initConnection":
+        case "changeDesiredQueries":
+          this.queueDesiredQueries(message[1]);
+          this.requestPullAfterCurrent();
+          return;
+        case "updateAuth":
+          this.authToken = message[1].auth;
+          return;
+        case "push":
+          this.enqueuePush(message[1]);
+          return;
+        case "ping":
+          this.emitMessage(["pong", {}]);
+          return;
+        case "pull":
+          this.run(this.answerMutationRecoveryPull(message[1]));
+          return;
+        case "deleteClients":
+        case "ackMutationResponses":
+          return;
+        default:
+          throw new Error(`unsupported zero-http upstream message ${message[0]}`);
+      }
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      var code = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 1e3,
+        reason = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+      if (this.readyState === this.CLOSED) return;
+      if (this.openTimer) clearTimeout(this.openTimer);
+      if (this.pullTimer) clearInterval(this.pullTimer);
+      this.readyState = this.CLOSED;
+      this.state.sockets.delete(this);
+      this.emit("close", {
+        code,
+        reason,
+        wasClean: code <= 1001
+      });
+    }
+  }, {
+    key: "pull",
+    value: function pull() {
+      var _this = this;
+      if (this.readyState === this.CLOSED) return Promise.resolve();
+      if (this.pullInFlight) return this.pullInFlight;
+      this.pullInFlight = this.fetchPull(this.clientGroupID, this.cookie).then(function (response) {
+        if (response.unchanged) {
+          _this.emitGotQueriesPatch(response.cookie);
+          return;
+        }
+        _this.emitPoke(response);
+      }).catch(function (error) {
+        _this.fail(error);
+        throw error;
+      }).finally(async function () {
+        var pullAgain = _this.pullAfterCurrent;
+        _this.pullAfterCurrent = false;
+        _this.pullInFlight = void 0;
+        if (pullAgain && _this.readyState !== _this.CLOSED) await _this.pull();
+      });
+      return this.pullInFlight;
+    }
+  }, {
+    key: "open",
+    value: function open() {
+      var _this = this;
+      if (this.readyState !== this.CONNECTING) return;
+      this.readyState = this.OPEN;
+      this.emit("open", {});
+      this.emitMessage(["connected", {
+        wsid: this.wsid,
+        timestamp: Date.now()
+      }]);
+      setTimeout(function () {
+        return _this.run(_this.pull());
+      }, 0);
+      if (this.state.pullIntervalMs) {
+        this.pullTimer = setInterval(function () {
+          _this.run(_this.pull());
+        }, this.state.pullIntervalMs);
+      }
+    }
+  }, {
+    key: "queueDesiredQueries",
+    value: function queueDesiredQueries(body) {
+      var desiredQueriesPatch = body === null || body === void 0 ? void 0 : body.desiredQueriesPatch;
+      if (!Array.isArray(desiredQueriesPatch)) return;
+      this.pendingGotQueriesPatch.push(...gotQueriesPatch(desiredQueriesPatch));
+    }
+  }, {
+    key: "push",
+    value: async function push(body) {
+      var response = await this.postJSON("/push", body);
+      this.emitMessage(["pushResponse", response.pushResponse]);
+      this.requestPullAfterCurrent();
+    }
+  }, {
+    key: "enqueuePush",
+    value: function enqueuePush(body) {
+      var _this = this;
+      var nextPush = this.pushChain.then(async function () {
+        if (_this.readyState === _this.CLOSED) return;
+        await _this.push(body);
+      });
+      this.pushChain = nextPush.catch(function () {});
+      this.run(nextPush);
+    }
+  }, {
+    key: "requestPullAfterCurrent",
+    value: function requestPullAfterCurrent() {
+      if (this.pullInFlight) {
+        this.pullAfterCurrent = true;
+        return;
+      }
+      this.run(this.pull());
+    }
+  }, {
+    key: "answerMutationRecoveryPull",
+    value: async function answerMutationRecoveryPull(body) {
+      var response = await this.fetchPull(body.clientGroupID, body.cookie);
+      var cookie = toWebSocketCookie(response.cookie);
+      var _ref;
+      this.emitMessage(["pull", {
+        requestID: body.requestID,
+        cookie: (_ref = cookie !== null && cookie !== void 0 ? cookie : this.cookie) !== null && _ref !== void 0 ? _ref : "0",
+        lastMutationIDChanges: response.unchanged ? {} : response.lastMutationIDChanges
+      }]);
+    }
+  }, {
+    key: "fetchPull",
+    value: async function fetchPull(clientGroupID, cookie) {
+      return await this.postJSON("/pull", {
+        clientID: this.clientID,
+        clientGroupID,
+        cookie: toHttpCookie(cookie)
+      });
+    }
+  }, {
+    key: "postJSON",
+    value: async function postJSON(path, body) {
+      var response = await this.state.fetch(`${this.state.originString}${path}`, {
+        method: "POST",
+        headers: {
+          authorization: this.authToken ? `Bearer ${this.authToken}` : "",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new ZeroHttpResponseError(path, response.status);
+      }
+      return response.json();
+    }
+  }, {
+    key: "run",
+    value: function run(promise) {
+      var _this = this;
+      void promise.catch(function (error) {
+        return _this.fail(error);
+      });
+    }
+  }, {
+    key: "fail",
+    value: function fail(error) {
+      if (this.readyState === this.CLOSED) return;
+      if (isAuthHTTPError(error)) {
+        this.emitMessage(["error", {
+          kind: "Unauthorized",
+          message: error.message,
+          origin: "server"
+        }]);
+        if (this.readyState !== this.CLOSED) this.close(1e3, error.message);
+        return;
+      }
+      this.emit("error", {
+        error
+      });
+      this.close(1011, errorMessage(error));
+    }
+  }, {
+    key: "emitPoke",
+    value: function emitPoke(response) {
+      var nextCookie = toWebSocketCookie(response.cookie);
+      if (isStaleCookie(this.cookie, response.cookie)) {
+        throw new Error(`zero-http pull returned stale cookie ${response.cookie} for ${this.cookie}`);
+      }
+      var pokeID = `zero-http-${++this.state.nextPokeID}`;
+      var gotQueries = this.pendingGotQueriesPatch;
+      this.pendingGotQueriesPatch = [];
+      this.emitMessage(["pokeStart", {
+        pokeID,
+        baseCookie: this.cookie,
+        schemaVersions: {
+          minSupportedVersion: 1,
+          maxSupportedVersion: 1
+        },
+        timestamp: Date.now()
+      }]);
+      this.emitMessage(["pokePart", {
+        pokeID,
+        lastMutationIDChanges: response.lastMutationIDChanges,
+        rowsPatch: response.rowsPatch
+      }]);
+      if (gotQueries.length > 0) {
+        this.emitMessage(["pokePart", {
+          pokeID,
+          gotQueriesPatch: gotQueries
+        }]);
+      }
+      this.emitMessage(["pokeEnd", {
+        pokeID,
+        cookie: nextCookie
+      }]);
+      this.cookie = nextCookie;
+    }
+  }, {
+    key: "emitGotQueriesPatch",
+    value: function emitGotQueriesPatch(cookie) {
+      if (this.pendingGotQueriesPatch.length === 0) return;
+      var serverCookie = cookie !== null && cookie !== void 0 ? cookie : toHttpCookie(this.cookie);
+      if (serverCookie === null) return;
+      var nextCookie = toLocalWebSocketCookie(serverCookie, ++this.nextLocalCookieID);
+      var pokeID = `zero-http-${++this.state.nextPokeID}`;
+      var gotQueries = this.pendingGotQueriesPatch;
+      this.pendingGotQueriesPatch = [];
+      this.emitMessage(["pokeStart", {
+        pokeID,
+        baseCookie: this.cookie,
+        schemaVersions: {
+          minSupportedVersion: 1,
+          maxSupportedVersion: 1
+        },
+        timestamp: Date.now()
+      }]);
+      this.emitMessage(["pokePart", {
+        pokeID,
+        gotQueriesPatch: gotQueries
+      }]);
+      this.emitMessage(["pokeEnd", {
+        pokeID,
+        cookie: nextCookie
+      }]);
+      this.cookie = nextCookie;
+    }
+  }, {
+    key: "emitMessage",
+    value: function emitMessage(message) {
+      if (this.readyState !== this.OPEN) return;
+      this.emit("message", {
+        data: JSON.stringify(message)
+      });
+    }
+  }, {
+    key: "emit",
+    value: function emit(type, event) {
+      var handler = this[`on${type}`];
+      if (typeof handler === "function") handler.call(this, event);
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.listeners[type][Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var listener = _step.value;
+          if (typeof listener === "function") listener(event);else listener.handleEvent(event);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+  }]);
+  return ZeroHttpSocket2;
+}();
+function shouldIntercept(origin, url) {
+  var candidate = toHttpURL(url);
+  if (candidate.origin !== origin.origin) return false;
+  return candidate.pathname === `${trimTrailingSlash(origin.pathname)}/sync/v51/connect`;
+}
+function toHttpURL(url) {
+  var parsed = new URL(url);
+  if (parsed.protocol === "ws:") parsed.protocol = "http:";
+  if (parsed.protocol === "wss:") parsed.protocol = "https:";
+  return parsed;
+}
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function decodeSecProtocol(protocols) {
+  var protocol = Array.isArray(protocols) ? protocols[0] : protocols;
+  if (!protocol) return {};
+  try {
+    var decoded = decodeURIComponent(protocol);
+    var json = new TextDecoder().decode(Uint8Array.from(globalThis.atob(decoded), function (char) {
+      return char.charCodeAt(0);
+    }));
+    var parsed = JSON.parse(json);
+    return {
+      authToken: parsed.authToken,
+      initConnectionMessage: Array.isArray(parsed.initConnectionMessage) ? parsed.initConnectionMessage : void 0
+    };
+  } catch (e) {
+    return {};
+  }
+}
+function gotQueriesPatch(patch) {
+  var got = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = patch[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var op = _step.value;
+      if (op.op === "clear") got.push({
+        op: "clear"
+      });else if (op.hash) got.push({
+        op: op.op,
+        hash: op.hash
+      });
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return got;
+}
+function toHttpCookie(cookie) {
+  if (cookie === null || cookie === "") return null;
+  var parsed = Number(cookie.slice(0, COOKIE_WIDTH));
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`zero-http cookie is not numeric: ${cookie}`);
+  }
+  return parsed;
+}
+function toWebSocketCookie(cookie) {
+  return cookie === null ? null : String(cookie).padStart(COOKIE_WIDTH, "0");
+}
+function toLocalWebSocketCookie(cookie, localID) {
+  return `${String(cookie).padStart(COOKIE_WIDTH, "0")}#${String(localID).padStart(6, "0")}`;
+}
+function isStaleCookie(current, next) {
+  var currentNumber = toHttpCookie(current);
+  return currentNumber !== null && next <= currentNumber;
+}
+function errorMessage(error) {
+  return _instanceof(error, Error) ? error.message : String(error);
+}
+var ZeroHttpResponseError = /* @__PURE__ */function (Error1) {
+  "use strict";
+
+  _inherits(ZeroHttpResponseError2, Error1);
+  function ZeroHttpResponseError2(path, status) {
+    _class_call_check(this, ZeroHttpResponseError2);
+    var _this;
+    _this = _call_super(this, ZeroHttpResponseError2, [`zero-http ${path} failed with ${status}`]), _define_property(_this, "path", void 0), _define_property(_this, "status", void 0), _this.path = path, _this.status = status;
+    return _this;
+  }
+  return ZeroHttpResponseError2;
+}(_wrap_native_super(Error));
+function isAuthHTTPError(error) {
+  return _instanceof(error, ZeroHttpResponseError) && (error.status === 401 || error.status === 403);
+}
+//# sourceMappingURL=httpPullTransport.native.js.map