u8-mqtt 0.5.2 → 0.6.0

package/esm/deno/full-v5.js

@@ -0,0 +1,1798 @@
+function encode_varint(n, a=[]) {
+  do {
+    const ni = n & 0x7f;
+    n >>>= 7;
+    a.push( ni | (0===n ? 0 : 0x80) );
+  } while (n > 0)
+  return a
+}
+
+
+/*
+export function decode_varint_loop(u8, i=0) {
+  let i0 = i
+  let shift = 0, n = (u8[i] & 0x7f)
+  while ( 0x80 & u8[i++] )
+    n |= (u8[i] & 0x7f) << (shift += 7)
+
+  return [n, i, i0]
+}
+*/
+
+
+function decode_varint$1(u8, i=0) {
+  let i0 = i;
+  // unrolled for a max of 4 chains
+  let n = (u8[i] & 0x7f) <<  0;
+  if ( 0x80 & u8[i++] ) {
+    n |= (u8[i] & 0x7f) <<  7;
+    if ( 0x80 & u8[i++] ) {
+      n |= (u8[i] & 0x7f) << 14;
+      if ( 0x80 & u8[i++] ) {
+        n |= (u8[i] & 0x7f) << 21;
+      }
+    }
+  }
+  return [n, i, i0]
+}
+
+const mqtt_props = /* #__PURE__ */
+  init_mqtt_props();
+
+function init_mqtt_props() {
+  let mqtt_props = new Map();
+
+  let entries = [
+    [ 0x01, 'u8',   'payload_format_indicator'],
+    [ 0x02, 'u32',  'message_expiry_interval'],
+    [ 0x03, 'utf8', 'content_type'],
+    [ 0x08, 'utf8', 'response_topic'],
+    [ 0x09, 'bin',  'correlation_data'],
+    [ 0x0B, 'vint', 'subscription_identifier'],
+    [ 0x11, 'u32',  'session_expiry_interval'],
+    [ 0x12, 'utf8', 'assigned_client_identifier'],
+    [ 0x13, 'u16',  'server_keep_alive'],
+    [ 0x15, 'utf8', 'authentication_method'],
+    [ 0x16, 'bin',  'authentication_data'],
+    [ 0x17, 'u8',   'request_problem_information'],
+    [ 0x18, 'u32',  'will_delay_interval'],
+    [ 0x19, 'u8',   'request_response_information'],
+    [ 0x1A, 'utf8', 'response_information'],
+    [ 0x1C, 'utf8', 'server_reference'],
+    [ 0x1F, 'utf8', 'reason_string'],
+    [ 0x21, 'u16',  'receive_maximum'],
+    [ 0x22, 'u16',  'topic_alias_maximum'],
+    [ 0x23, 'u16',  'topic_alias'],
+    [ 0x24, 'u8',   'maximum_qos'],
+    [ 0x25, 'u8',   'retain_available'],
+    [ 0x26, 'pair', 'user_properties', {op: 'kv_obj'}],
+    [ 0x27, 'u32',  'maximum_packet_size'],
+    [ 0x28, 'u8',   'wildcard_subscription_available'],
+    [ 0x29, 'u8',   'subscription_identifiers_available', {op: 'u8_vec'}],
+    [ 0x2A, 'u8',   'shared_subscription_available'],
+  ];
+
+  for (let [id, type, name, extra] of entries) {
+    let prop_obj = {id, type, name, ...extra};
+    mqtt_props.set(prop_obj.id, prop_obj);
+    mqtt_props.set(prop_obj.name, prop_obj);
+  }
+
+  return mqtt_props
+}
+
+class U8_Reason extends Number {
+  static of(v, pkt_kind, by_kind) {
+    let self = new this(v);
+    self.reason = by_kind?.[pkt_kind]?.get(v) || pkt_kind;
+    return self
+  }
+}
+
+class mqtt_reader_v4 {
+  static of(buf) { return this.prototype.of(buf) }
+  of(buf) {
+    let step = (width, k) => (k=0|step.k, step.k=k+width, k);
+    return {__proto__: this, buf, step}
+  }
+
+  has_more() {
+    return this.buf.byteLength > (this.step.k|0)
+  }
+
+  u8() {
+    return this.buf[this.step(1)]
+  }
+
+  u16() {
+    let {buf, step} = this, i = step(2);
+    return (buf[i]<<8) | buf[i+1]
+  }
+
+  u32() {
+    let {buf, step} = this, i = step(4);
+    return (buf[i]<<24) | (buf[i+1]<<16) | (buf[i+2]<<8) | buf[i+3]
+  }
+
+  vint() {
+    let {buf, step} = this;
+    let [n, vi, vi0] = decode_varint$1(buf, step.k|0);
+    step(vi - vi0);
+    return n
+  }
+
+  bin() {
+    let {buf, step} = this, i = step(2);
+    let len = (buf[i]<<8) | buf[i+1];
+    i = step(len);
+    return buf.subarray(i, i+len)
+  }
+
+  utf8() { return new TextDecoder('utf-8').decode(this.bin()) }
+  pair() { return [ this.utf8(), this.utf8() ] }
+
+  flags(FlagsType) { return new FlagsType(this.buf[this.step(1)]) }
+
+  reason(pkt_kind) {
+    let v = this.buf[this.step(1)];
+    if (null != v)
+      return U8_Reason.of(v, pkt_kind, this._reasons_by)
+  }
+
+  flush() {
+    let {buf, step} = this;
+    this.step = this.buf = null;
+    return buf.subarray(step.k|0)
+  }
+
+}
+
+let mqtt_reader_v5$1 = class mqtt_reader_v5 extends mqtt_reader_v4 {
+  props() {
+    let {buf, step} = this;
+    let [n, vi, vi0] = decode_varint$1(buf, step.k|0);
+    step(n + vi - vi0);
+    if (0 === n) return null
+
+    let res={}, fork = this.of(buf.subarray(vi, step.k|0));
+    while (fork.has_more()) {
+      let v, pk = fork.u8(), pt = mqtt_props.get( pk );
+
+      if (!pt) {
+        res.error = `Unknown mqtt_prop enum ${pk}`;
+        return res
+      }
+
+      v = fork[pt.type]();
+      if (pt.op) // accumulate operation
+        v = fork[pt.op](res[pt.name], v);
+
+      res[pt.name] = v;
+    }
+    return res
+  }
+
+  kv_obj(obj=Object.create(null), [k,v]) {
+    obj[k] = v;
+    return obj
+  }
+  u8_vec(vec=[], u8) {
+    vec.push(u8);
+    return vec
+  }
+
+  /*
+  vbuf() {
+    let {buf, step} = this
+    let [n, vi, vi0] = decode_varint(buf, step.k|0)
+    step(n + vi - vi0)
+    return 0 === n ? null
+      : buf.subarray(vi, step.k|0)
+  }
+  */
+};
+
+function mqtt_reader_info(mqtt_reader, ... info_fn_list) {
+  mqtt_reader = class extends mqtt_reader {
+    static reasons(pkt_type, ...reason_entries) {
+      let proto = this.prototype;
+      proto._reasons_by = {... proto._reasons_by};
+
+      let lut = (proto._reasons_by[pkt_type] ||= new Map());
+      for (let [u8, reason] of reason_entries)
+        lut.set( u8, reason );
+
+      return this
+    }
+  };
+
+  for (let fn_info of info_fn_list)
+    fn_info(mqtt_reader);
+
+  return mqtt_reader
+}
+
+class mqtt_writer_v4 {
+  static of() { return this.prototype.of() }
+  of() { return {__proto__: this, $:[]} }
+
+  static init() { return this }
+
+  as_pkt(pkt_id) { return this.pack([pkt_id]) }
+
+  push(...z) { this.$.push(...z); }
+  pack(hdr) {
+    let z, i, n=0, parts = this.$;
+    this.$ = false;
+    for (z of parts) n += z.length;
+
+    hdr = encode_varint(n, hdr);
+    i = hdr.length;
+
+    let pkt = new Uint8Array(i + n);
+    pkt.set(hdr, 0);
+    for (z of parts) {
+      pkt.set(z, i);
+      i += z.length;
+    }
+    return pkt
+  }
+
+  u8(v) { this.push([ v & 0xff ]); }
+  u16(v) { this.push([ (v>>>8) & 0xff, v & 0xff ]); }
+  u32(v) { this.push([ (v>>>24) & 0xff, (v>>>16) & 0xff, (v>>>8) & 0xff, v & 0xff ]); }
+  vint(v) { this.push( encode_varint(v) );}
+
+  bin(u8_buf) {
+    if (! u8_buf) return this.u16(0)
+    if ('string' === typeof u8_buf)
+      return this.utf8(u8_buf)
+
+    if (u8_buf.length !== u8_buf.byteLength)
+      u8_buf = new Uint8Array(u8_buf);
+
+    this.u16(u8_buf.byteLength);
+    this.push(u8_buf);
+  }
+
+  utf8(v) {
+    let u8_buf = new TextEncoder('utf-8').encode(v);
+    this.u16(u8_buf.byteLength);
+    this.push(u8_buf);
+  }
+  pair(k,v) { this.utf8(k); this.utf8(v); }
+
+  flags(v, enc_flags, b0=0) {
+    if (undefined !== v && isNaN(+v))
+      v = enc_flags(v, 0);
+
+    v |= b0;
+    this.push([v]);
+    return v
+  }
+
+  reason(v) { this.push([v | 0]); }
+
+  flush(buf) {
+    if (null != buf)
+      this.push(
+        'string' === typeof buf
+          ? new TextEncoder('utf-8').encode(buf)
+          : buf );
+
+    this.push = false;
+  }
+}
+
+
+class mqtt_writer_v5 extends mqtt_writer_v4 {
+  props(props) {
+    if (! props)
+      return this.u8(0)
+
+    if (! Array.isArray(props))
+      props = props.entries
+        ? Array.from(props.entries())
+        : Object.entries(props);
+
+    if (0 === props.length)
+      return this.u8(0)
+
+    let fork = this.of();
+    for (let [name, value] of props) {
+      let pt = mqtt_props.get(name);
+      if (!pt)
+        throw new Error(`Unknown mqtt_prop "${name}"`)
+      fork[pt.op || 'one'](value, pt);
+    }
+    this.push(fork.pack());
+  }
+
+  one(value, pt) {
+    this.u8(pt.id);
+    this[pt.type](value);
+  }
+  kv_obj(obj, pt) {
+    for (let kv of Object.entries(obj)) {
+      this.u8(pt.id);
+      this.pair(kv);
+    }
+  }
+  u8_vec(vec, pt) {
+    for (let v of vec) {
+      this.u8(pt.id);
+      this.u8(v);
+    }
+  }
+}
+
+function mqtt_decode_connect(ns, mqtt_reader) {
+  class _connect_flags_ extends Number {
+    get reserved() { return this & 0x01 !== 0 }
+    get clean_start() { return this & 0x02 !== 0 }
+    get will_flag() { return this & 0x04 !== 0 }
+    get will_qos() { return (this >>> 3) & 0x3 }
+    get will_retain() { return this & 0x20 !== 0 }
+    get password() { return this & 0x40 !== 0 }
+    get username() { return this & 0x80 !== 0 }
+  }
+
+  return ns[0x1] = (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+    if ('MQTT' !== rdr.utf8())
+      throw new Error('Invalid mqtt_connect packet')
+
+    pkt._base_.mqtt_level = pkt.mqtt_level = rdr.u8();
+
+    let flags = pkt.flags =
+      rdr.flags(_connect_flags_);
+
+    pkt.keep_alive = rdr.u16();
+
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+
+
+
+    pkt.client_id = rdr.utf8();
+    if (flags.will_flag) {
+      let will = pkt.will = {};
+      if (5 <= pkt.mqtt_level)
+        will.props = rdr.props();
+
+      will.topic = rdr.utf8();
+      will.payload = rdr.bin();
+      will.qos = flags.will_qos;
+      will.retain = flags.will_retain;
+    }
+
+    if (flags.username)
+      pkt.username = rdr.utf8();
+
+    if (flags.password)
+      pkt.password = rdr.bin();
+    return pkt }
+}
+
+function mqtt_decode_connack(ns, mqtt_reader) {
+  class _connack_flags_ extends Number {
+    get session_present() { return this & 0x01 !== 0 }
+  }
+
+  return ns[0x2] = (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+
+    pkt.flags =
+      rdr.flags(_connack_flags_);
+
+    pkt.reason = rdr.reason(pkt.type);
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+    return pkt }
+}
+
+
+function _connack_v4(mqtt_reader) {
+  mqtt_reader.reasons('connack',
+    // MQTT 3.1.1
+    [ 0x00, 'Success'],
+    [ 0x01, 'Connection refused, unacceptable protocol version'],
+    [ 0x02, 'Connection refused, identifier rejected'],
+    [ 0x03, 'Connection refused, server unavailable'],
+    [ 0x04, 'Connection refused, bad user name or password'],
+    [ 0x05, 'Connection refused, not authorized'],
+  );
+}
+
+function _connack_v5(mqtt_reader) {
+  _connack_v4(mqtt_reader);
+
+  mqtt_reader.reasons('connack',
+    // MQTT 5.0
+    [ 0x81, 'Malformed Packet'],
+    [ 0x82, 'Protocol Error'],
+    [ 0x83, 'Implementation specific error'],
+    [ 0x84, 'Unsupported Protocol Version'],
+    [ 0x85, 'Client Identifier not valid'],
+    [ 0x86, 'Bad User Name or Password'],
+    [ 0x87, 'Not authorized'],
+    [ 0x88, 'Server unavailable'],
+    [ 0x89, 'Server busy'],
+    [ 0x8A, 'Banned'],
+    [ 0x8C, 'Bad authentication method'],
+    [ 0x90, 'Topic Name invalid'],
+    [ 0x95, 'Packet too large'],
+    [ 0x97, 'Quota exceeded'],
+    [ 0x99, 'Payload format invalid'],
+    [ 0x9A, 'Retain not supported'],
+    [ 0x9B, 'QoS not supported'],
+    [ 0x9C, 'Use another server'],
+    [ 0x9D, 'Server moved'],
+    [ 0x9F, 'Connection rate exceeded'],
+  );
+}
+
+function mqtt_decode_publish(ns, mqtt_reader) {
+  return ns[0x3] = (pkt, u8_body) => {
+    let {hdr} = pkt;
+    pkt.dup = Boolean(hdr & 0x8);
+    pkt.retain = Boolean(hdr & 0x1);
+    let qos = pkt.qos = (hdr>>1) & 0x3;
+
+    let rdr = mqtt_reader.of(u8_body);
+    pkt.topic = rdr.utf8();
+    if (0 !== qos)
+      pkt.pkt_id = rdr.u16();
+
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+
+    pkt.payload = rdr.flush();
+    return pkt }
+}
+
+function mqtt_decode_puback(ns, mqtt_reader) {
+  return ns[0x4] = (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+
+    pkt.pkt_id = rdr.u16();
+    if (5 <= pkt.mqtt_level) {
+      pkt.reason = rdr.reason(pkt.type);
+      pkt.props = rdr.props();
+    }
+
+    return pkt }
+}
+
+
+function _puback_v5(mqtt_reader) {
+  mqtt_reader.reasons('puback',
+    // MQTT 5.0
+    [ 0x00, 'Success'],
+    [ 0x10, 'No matching subscribers'],
+    [ 0x80, 'Unspecified error'],
+    [ 0x83, 'Implementation specific error'],
+    [ 0x87, 'Not authorized'],
+    [ 0x90, 'Topic Name invalid'],
+    [ 0x91, 'Packet identifier in use'],
+    [ 0x97, 'Quota exceeded'],
+    [ 0x99, 'Payload format invalid'],
+  );
+}
+
+function mqtt_decode_pubxxx(ns, mqtt_reader) {
+  return ns[0x5] = ns[0x6] = ns[0x7] = (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+
+    pkt.pkt_id = rdr.u16();
+    pkt.reason = rdr.reason('pubxxx', mqtt_reader);
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+    return pkt }
+}
+
+function _pubxxx_v4(mqtt_reader) {
+  mqtt_reader.reasons('pubxxx',
+    // MQTT 3.1.1
+    [ 0x00, 'Success' ],
+    [ 0x92, 'Packet Identifier not found' ],
+  );
+}
+
+function mqtt_decode_subscribe(ns, mqtt_reader) {
+  class _subscription_options_ extends Number {
+    get qos() { return this & 0x3 }
+    get retain() { return this & 0x4 !== 0 }
+    get retain_handling() { return (this >> 2) & 0x3 }
+  }
+
+  return ns[0x8] = (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+
+    pkt.pkt_id = rdr.u16();
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+
+    let topic, opts, topic_list = pkt.topics = [];
+    while (rdr.has_more()) {
+      topic = rdr.utf8();
+      opts = rdr.flags(_subscription_options_);
+      topic_list.push({topic, opts});
+    }
+
+    return pkt }
+}
+
+function _mqtt_decode_suback(mqtt_reader) {
+  return (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+
+    pkt.pkt_id = rdr.u16();
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+
+    let answers = pkt.answers = [];
+    while (rdr.has_more())
+      answers.push(
+        rdr.reason(pkt.type) );
+
+    return pkt }
+}
+
+function mqtt_decode_suback(ns, mqtt_reader) {
+  return ns[0x9] = _mqtt_decode_suback(mqtt_reader)
+}
+
+function _suback_v4(mqtt_reader) {
+  mqtt_reader.reasons('suback',
+    // MQTT 3.1.1
+    [ 0x00, 'Granted QoS 0'],
+    [ 0x01, 'Granted QoS 1'],
+    [ 0x02, 'Granted QoS 2'],
+  );
+}
+
+function _suback_v5(mqtt_reader) {
+  _suback_v4(mqtt_reader);
+
+  mqtt_reader.reasons('suback',
+    // MQTT 5.0
+    [ 0x80, 'Unspecified error'],
+    [ 0x83, 'Implementation specific error'],
+    [ 0x87, 'Not authorized'],
+    [ 0x8F, 'Topic Filter invalid'],
+    [ 0x91, 'Packet Identifier in use'],
+    [ 0x97, 'Quota exceeded'],
+    [ 0x9E, 'Shared Subscriptions not supported'],
+    [ 0xA1, 'Subscription Identifiers not supported'],
+    [ 0xA2, 'Wildcard Subscriptions not supported'],
+  );
+}
+
+function mqtt_decode_unsubscribe(ns, mqtt_reader) {
+  return ns[0xa] = (pkt, u8_body) => {
+    let rdr = mqtt_reader.of(u8_body);
+
+    pkt.pkt_id = rdr.u16();
+    if (5 <= pkt.mqtt_level)
+      pkt.props = rdr.props();
+
+    let topic_list = pkt.topics = [];
+    while (rdr.has_more())
+      topic_list.push(rdr.utf8());
+
+    return pkt }
+}
+
+function mqtt_decode_unsuback(ns, mqtt_reader) {
+  return ns[0xb] = _mqtt_decode_suback(mqtt_reader)
+}
+
+function _unsuback_v4(mqtt_reader) {
+  mqtt_reader.reasons('unsuback',
+    // MQTT 3.1.1
+    [ 0x00, 'Success'],
+    [ 0x11, 'No subscription existed'],
+    [ 0x80, 'Unspecified error'],
+    [ 0x83, 'Implementation specific error'],
+    [ 0x87, 'Not authorized'],
+    [ 0x8F, 'Topic Filter invalid'],
+    [ 0x91, 'Packet Identifier in use'],
+  );
+}
+
+function mqtt_decode_pingxxx(ns) {
+  return ns[0xc] = ns[0xd] = pkt => pkt
+}
+
+function mqtt_decode_disconnect(ns, mqtt_reader) {
+  return ns[0xe] = (pkt, u8_body) => {
+    if (u8_body && 5 <= pkt.mqtt_level) {
+      let rdr = mqtt_reader.of(u8_body);
+      pkt.reason = rdr.reason(pkt.type);
+      pkt.props = rdr.props();
+    }
+    return pkt }
+}
+
+
+function _disconnect_v5(mqtt_reader) {
+  mqtt_reader.reasons('disconnect',
+    // MQTT 5.0
+    [ 0x00, 'Normal disconnection'],
+    [ 0x04, 'Disconnect with Will Message'],
+    [ 0x80, 'Unspecified error'],
+    [ 0x81, 'Malformed Packet'],
+    [ 0x82, 'Protocol Error'],
+    [ 0x83, 'Implementation specific error'],
+    [ 0x87, 'Not authorized'],
+    [ 0x89, 'Server busy'],
+    [ 0x8B, 'Server shutting down'],
+    [ 0x8D, 'Keep Alive timeout'],
+    [ 0x8E, 'Session taken over'],
+    [ 0x8F, 'Topic Filter invalid'],
+    [ 0x90, 'Topic Name invalid'],
+    [ 0x93, 'Receive Maximum exceeded'],
+    [ 0x94, 'Topic Alias invalid'],
+    [ 0x95, 'Packet too large'],
+    [ 0x96, 'Message rate too high'],
+    [ 0x97, 'Quota exceeded'],
+    [ 0x98, 'Administrative action'],
+    [ 0x99, 'Payload format invalid'],
+    [ 0x9A, 'Retain not supported'],
+    [ 0x9B, 'QoS not supported'],
+    [ 0x9C, 'Use another server'],
+    [ 0x9D, 'Server moved'],
+    [ 0x9E, 'Shared Subscriptions not supported'],
+    [ 0x9F, 'Connection rate exceeded'],
+    [ 0xA0, 'Maximum connect time'],
+    [ 0xA1, 'Subscription Identifiers not supported'],
+    [ 0xA2, 'Wildcard Subscriptions not supported'],
+  );
+}
+
+function mqtt_decode_auth(ns, mqtt_reader) {
+  return ns[0xf] = (pkt, u8_body) => {
+    if ( 5 <= pkt.mqtt_level ) {
+      let rdr = mqtt_reader.of(u8_body);
+      pkt.reason = rdr.reason(pkt.type);
+      pkt.props = rdr.props();
+    }
+    return pkt }
+}
+
+
+function _auth_v5(mqtt_reader) {
+  mqtt_reader.reasons('auth',
+    // MQTT 5.0
+    [ 0x00, 'Success' ],
+    [ 0x18, 'Continue authentication' ],
+    [ 0x19, 'Re-authenticate' ],
+  );
+}
+
+function mqtt_encode_connect(ns, mqtt_writer) {
+  const _c_mqtt_proto = new Uint8Array([
+    0, 4, 0x4d, 0x51, 0x54, 0x54 ]);
+
+  const _enc_flags_connect = flags => 0
+      | ( flags.reserved ? 0x01 : 0 )
+      | ( (flags.will_qos & 0x3) << 3 )
+      | ( flags.clean_start ? 0x02 : 0 )
+      | ( flags.will_flag ? 0x04 : 0 )
+      | ( flags.will_retain ? 0x20 : 0 )
+      | ( flags.password ? 0x40 : 0 )
+      | ( flags.username ? 0x80 : 0 );
+
+  const _enc_flags_will = will => 0x4
+      | ( (will.qos & 0x3) << 3 )
+      | ( will.retain ? 0x20 : 0 );
+
+  return ns.connect = ( mqtt_level, pkt ) => {
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.push(_c_mqtt_proto);
+    wrt.u8( mqtt_level );
+
+    let {will, username, password} = pkt;
+    let flags = wrt.flags(
+      pkt.flags,
+      _enc_flags_connect,
+      0 | (username ? 0x80 : 0)
+        | (password ? 0x40 : 0)
+        | (will ? _enc_flags_will(will) : 0) );
+
+    wrt.u16(pkt.keep_alive);
+
+    if (5 <= mqtt_level)
+      wrt.props(pkt.props);
+
+
+    wrt.utf8(pkt.client_id);
+    if (flags & 0x04) { // .will_flag
+      if (5 <= mqtt_level)
+        wrt.props(will.props);
+
+      wrt.utf8(will.topic);
+      wrt.bin(will.payload);
+    }
+
+    if (flags & 0x80) // .username
+      wrt.utf8(username);
+
+    if (flags & 0x40) // .password
+      wrt.bin(password);
+
+    return wrt.as_pkt(0x10)
+  }
+}
+
+function mqtt_encode_connack(ns, mqtt_writer) {
+  const _enc_flags_connack = flags =>
+    flags.session_present ? 1 : 0;
+
+  return ns.connack = (mqtt_level, pkt) => {
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.flags( pkt.flags, _enc_flags_connack );
+
+    if (5 <= mqtt_level) {
+      wrt.reason( pkt.reason );
+      wrt.props( pkt.props );
+
+    } else {
+      wrt.reason( pkt.return_code || pkt.reason );
+    }
+
+    return wrt.as_pkt(0x20)
+  }
+}
+
+function mqtt_encode_publish(ns, mqtt_writer) {
+  return ns.publish = ( mqtt_level, pkt ) => {
+    let qos = (pkt.qos & 0x3) << 1;
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.utf8(pkt.topic);
+    if (0 !== qos)
+      wrt.u16(pkt.pkt_id);
+
+    if ( 5 <= mqtt_level) {
+      wrt.props(pkt.props);
+      wrt.flush(pkt.payload);
+    } else {
+      wrt.flush(pkt.payload);
+    }
+
+    return wrt.as_pkt(
+      0x30 | qos | (pkt.dup ? 0x8 : 0) | (pkt.retain ? 0x1 : 0) )
+  }
+}
+
+function mqtt_encode_puback(ns, mqtt_writer) {
+  return ns.puback = ( mqtt_level, pkt ) => {
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.u16(pkt.pkt_id);
+    if (5 <= mqtt_level) {
+      wrt.reason(pkt.reason);
+      wrt.props(pkt.props);
+    }
+
+    return wrt.as_pkt(0x40)
+  }
+}
+
+function mqtt_encode_pubxxx(ns, mqtt_writer) {
+  ns.pubrec = _enc_pubxxx(0x50);
+  ns.pubrel = _enc_pubxxx(0x62);
+  ns.pubcomp = _enc_pubxxx(0x70);
+
+
+  function _enc_pubxxx(hdr) {
+    return ( mqtt_level, pkt ) => {
+      let wrt = mqtt_writer.of(pkt);
+
+      wrt.u16(pkt.pkt_id);
+      if (5 <= mqtt_level) {
+        wrt.props(pkt.props);
+        wrt.reason(pkt.reason);
+
+      } else {
+        wrt.reason( pkt.return_code || pkt.reason );
+      }
+
+      return wrt.as_pkt(hdr)
+    }
+  }
+}
+
+function mqtt_encode_subscribe(ns, mqtt_writer) {
+  const _enc_subscribe_flags = opts => 0
+      | ( opts.qos & 0x3 )
+      | ( opts.retain ? 0x4 : 0 )
+      | ( (opts.retain_handling & 0x3) << 2 );
+
+  return ns.subscribe = ( mqtt_level, pkt ) => {
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.u16(pkt.pkt_id);
+    if (5 <= mqtt_level)
+      wrt.props(pkt.props);
+
+    let f0 = _enc_subscribe_flags(pkt);
+    for (let each of pkt.topics) {
+      if ('string' === typeof each) {
+        wrt.utf8(each);
+        wrt.u8(f0);
+      } else {
+        let [topic, opts] =
+          Array.isArray(each) ? each
+            : [each.topic, each.opts];
+
+        wrt.utf8(topic);
+        if (undefined === opts) wrt.u8(f0);
+        else wrt.flags(opts, _enc_subscribe_flags);
+      }
+    }
+
+    return wrt.as_pkt(0x82)
+  }
+}
+
+function mqtt_encode_xxsuback(ns, mqtt_writer) {
+  ns.suback = _enc_xxsuback(0x90);
+  ns.unsuback = _enc_xxsuback(0xb0);
+
+
+  function _enc_xxsuback(hdr) {
+    return ( mqtt_level, pkt ) => {
+      let wrt = mqtt_writer.of(pkt);
+
+      wrt.u16(pkt.pkt_id);
+      if (5 <= mqtt_level)
+        wrt.props(pkt.props);
+
+      for (let ans of pkt.answers)
+        wrt.reason(ans);
+
+      return wrt.as_pkt(hdr)
+    }
+  }
+}
+
+function mqtt_encode_unsubscribe(ns, mqtt_writer) {
+  return ns.unsubscribe = ( mqtt_level, pkt ) => {
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.u16(pkt.pkt_id);
+    if (5 <= mqtt_level)
+      wrt.props(pkt.props);
+
+    for (let topic of pkt.topics)
+      wrt.utf8(topic);
+
+    return wrt.as_pkt(0xa2)
+  }
+}
+
+function mqtt_encode_pingxxx(ns) {
+  ns.pingreq  = () => new Uint8Array([ 0xc0, 0 ]);
+  ns.pingresp = () => new Uint8Array([ 0xd0, 0 ]);
+}
+
+function mqtt_encode_disconnect(ns, mqtt_writer) {
+  return ns.disconnect = ( mqtt_level, pkt ) => {
+    let wrt = mqtt_writer.of(pkt);
+
+    if (pkt && 5 <= mqtt_level) {
+      if (pkt.reason || pkt.props) {
+        wrt.reason(pkt.reason);
+        wrt.props(pkt.props);
+      }
+    }
+
+    return wrt.as_pkt(0xe0)
+  }
+}
+
+function mqtt_encode_auth(ns, mqtt_writer) {
+  return ns.auth = ( mqtt_level, pkt ) => {
+    if (5 > mqtt_level)
+      throw new Error('Auth packets are only available after MQTT 5.x')
+
+    let wrt = mqtt_writer.of(pkt);
+
+    wrt.reason(pkt.reason);
+    wrt.props(pkt.props);
+
+    return wrt.as_pkt(0xf0)
+  }
+}
+
+const mqtt_reader_v5 = /* #__PURE__ */
+  mqtt_reader_info(
+    mqtt_reader_v5$1,
+    _connack_v5,
+    _puback_v5,
+    _pubxxx_v4,
+    _suback_v5,
+    _unsuback_v4,
+    _disconnect_v5,
+    _auth_v5,
+  );
+
+const mqtt_decode_v5 =  [
+  mqtt_decode_connect,
+  mqtt_decode_connack,
+  mqtt_decode_publish,
+  mqtt_decode_puback,
+  mqtt_decode_pubxxx,
+  mqtt_decode_subscribe,
+  mqtt_decode_suback,
+  mqtt_decode_unsubscribe,
+  mqtt_decode_unsuback,
+  mqtt_decode_pingxxx,
+  mqtt_decode_disconnect,
+  mqtt_decode_auth,
+];
+
+
+const mqtt_encode_v5 =  [
+  mqtt_encode_connect,
+  mqtt_encode_connack,
+  mqtt_encode_publish,
+  mqtt_encode_puback,
+  mqtt_encode_pubxxx,
+  mqtt_encode_subscribe,
+  mqtt_encode_xxsuback,
+  mqtt_encode_unsubscribe,
+  mqtt_encode_pingxxx,
+  mqtt_encode_disconnect,
+  mqtt_encode_auth,
+];
+
+
+const mqtt_opts_v5 = 
+  { decode_fns: mqtt_decode_v5,
+    mqtt_reader: mqtt_reader_v5,
+    encode_fns: mqtt_encode_v5,
+    mqtt_writer: mqtt_writer_v5, };
+
+function parse(str, loose) {
+	if (str instanceof RegExp) return { keys:false, pattern:str };
+	var c, o, tmp, ext, keys=[], pattern='', arr = str.split('/');
+	arr[0] || arr.shift();
+
+	while (tmp = arr.shift()) {
+		c = tmp[0];
+		if (c === '*') {
+			keys.push('wild');
+			pattern += '/(.*)';
+		} else if (c === ':') {
+			o = tmp.indexOf('?', 1);
+			ext = tmp.indexOf('.', 1);
+			keys.push( tmp.substring(1, !!~o ? o : !!~ext ? ext : tmp.length) );
+			pattern += !!~o && !~ext ? '(?:/([^/]+?))?' : '/([^/]+?)';
+			if (!!~ext) pattern += (!!~o ? '?' : '') + '\\' + tmp.substring(ext);
+		} else {
+			pattern += '/' + tmp;
+		}
+	}
+
+	return {
+		keys: keys,
+		pattern: new RegExp('^' + pattern + (loose ? '(?=$|\/)' : '\/?$'), 'i')
+	};
+}
+
+const _isfn = v => typeof v === 'function';
+const _isstr = v => typeof v === 'string';
+
+function _interval(fn_callback) {
+  let tid;
+  return (( td ) => {
+    tid = clearInterval(tid);
+    if (td) {
+      tid = setInterval(fn_callback, 1000 * td);
+      
+        // ensure the interval allows the Deno event loop to exit
+        Deno.unrefTimer(tid);
+      
+        
+        
+      return true} }) }
+
+/*
+class AbstractTopicRouter ::
+  async invoke(pkt, ctx) ::
+  add(topic_route, ...args) ::
+  remove(topic_route, priority) ::
+  clear(priority) ::
+  find(topic) :: // optional
+  mqtt_topic(topic_route)
+*/
+
+const with_topic_router = mqtt_topic_router =>
+  MQTTKlass => class extends MQTTKlass {
+    static _aliases() {
+      return super._aliases() +
+        ' sub_topic:subscribe_topic unsub_topic:unsubscribe_topic'}
+
+    _init_router(opt, self, target) {
+      this._subs = [];
+      let router = this.router = target.router =
+        mqtt_topic_router(opt, this, target);
+      return router?.invoke}
+
+    on_sub(suback, pkt) {
+      suback.pkt = pkt;
+      this._subs.push(suback);
+      return suback}
+    subs_settled() {
+      return Promise.allSettled(
+        this._subs.splice(0,Infinity)) }
+
+    // alias: sub_topic
+    subscribe_topic(topic_route, ...args) {
+      let router = this.router;
+      router.add(topic_route, true, args.pop() );// handler
+      let topic = router.mqtt_topic(topic_route);
+      this.subscribe(topic, ...args );// ex, topic_prefix
+      return this }// fluent api -- return this and track side effects
+
+    // alias: unsub_topic
+    unsubscribe_topic(topic_route, ...args) {
+      let router = this.router;
+      router.remove(topic_route, true);
+      let topic = router.mqtt_topic(topic_route);
+      return this.unsubscribe(topic, ...args ) }// topic_prefix
+
+    // add topic handlers without corresponding subscribe packet
+    on_topic(...args) {
+      this.router.add(...args);
+      return this} };
+
+// Use [regexparam][] for url-like topic parsing
+//  [regexparam]: https://github.com/lukeed/regexparam
+
+
+const with_topic_path_router = /* #__PURE__ */
+  with_topic_router(mqtt_topic_path_router);
+
+
+const mqtt_topic = topic_route =>
+  topic_route
+    .replace(/[*].*$/, '#')
+    .replace(/:\w[^\/]*/g, '+');
+
+/* From the [MQTT v5 Spec](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Topic_Names_and)
+4.7.1.2 Multi-level wildcard -- (‘#’ U+0023)
+... MUST be specified either on its own or following a topic level separator.
+In either case it MUST be the last character specified in the Topic Filter
+
+4.7.1.3 Single-level wildcard -- (‘+’ U+002B)
+...it MUST occupy an entire level of the filter.
+*/
+
+const as_topic_path = (topic_route, id) =>(
+  id=1,
+  topic_route
+    .replace(/#$/, '*' )// replace MQTT '#' multi-level wildcard at end
+    .replace(/\+/g, () => `:$${id++}` ) );// replace MQTT '+' single-level wildcards
+
+function _ignore(pkt, params, ctx) {ctx.done = true;}
+
+function mqtt_topic_path_router() {
+  let pri_lsts = [[],[]], rm = Symbol();
+  let find = topic => _routes_iter(pri_lsts, topic);
+
+  // return duck-type compatible with AbstractTopicRouter in ./with_topic_router
+  return {find, mqtt_topic,
+    add(topic_route, ...args) {
+      let fn = args.pop();
+      let priority = args.pop();
+
+      if (! _isfn(fn)) {
+        if (fn) {throw new TypeError()}
+        fn = _ignore;}
+
+      let rte = parse(as_topic_path(topic_route));
+
+      rte.key = topic_route;
+      rte.tgt = fn;
+      pri_lsts[priority ? 0 : 1].push(rte);
+      return this}
+
+  , remove(topic_route, priority) {
+      let lst = pri_lsts[priority ? 0 : 1];
+      return _route_remove([lst], topic_route)}
+
+  , clear(priority) {
+      pri_lsts[priority ? 0 : 1] = [];
+      if (null == priority) {
+        pri_lsts[1] = []; } }// null clears both lists
+
+  , async invoke(pkt, ctx) {
+      ctx.idx = 0;
+      ctx.rm = rm;
+
+      for (let [fn, params] of find(pkt.topic)) {
+        let res = await fn(pkt, params, ctx);
+
+        if (rm === res) {
+          _route_remove(pri_lsts, fn);}
+
+        if (ctx.done) {
+          break}
+        else ctx.idx++;}
+
+      if (1 === pkt.qos) {
+        await ctx.mqtt.puback(pkt);} } } }
+
+
+function * _routes_iter(all_route_lists, topic) {
+  topic = topic.replace(/^[\/]*/, '/'); // ensure '/' prefix for regexparam library
+  for (let route_list of all_route_lists) {
+    for (let {keys, pattern, tgt} of route_list) {
+      let match = pattern.exec(topic);
+      if (match) {
+        let params = keys
+          ? keys.reduce(
+              (o, k, i) => (o[k] = match[1+i], o)
+            , {})
+          : match.groups ?? match;
+        yield [tgt, params];} } } }
+
+
+function _route_remove(all_route_lists, query) {
+  let fn_match = route =>(
+    route===query
+    || route.tgt===query
+    || route.key===query);
+  for (let lst of all_route_lists) {
+    let i = lst.findIndex(fn_match);
+    if (0 <= i) {
+      lst.splice(i,1);
+      return true} }
+  return false}
+
+/*
+export function decode_varint_loop(u8, i=0) {
+  let i0 = i
+  let shift = 0, n = (u8[i] & 0x7f)
+  while ( 0x80 & u8[i++] )
+    n |= (u8[i] & 0x7f) << (shift += 7)
+
+  return [n, i, i0]
+}
+*/
+
+
+function decode_varint(u8, i=0) {
+  let i0 = i;
+  // unrolled for a max of 4 chains
+  let n = (u8[i] & 0x7f) <<  0;
+  if ( 0x80 & u8[i++] ) {
+    n |= (u8[i] & 0x7f) <<  7;
+    if ( 0x80 & u8[i++] ) {
+      n |= (u8[i] & 0x7f) << 14;
+      if ( 0x80 & u8[i++] ) {
+        n |= (u8[i] & 0x7f) << 21;
+      }
+    }
+  }
+  return [n, i, i0]
+}
+
+function mqtt_raw_dispatch(opt) {
+  let u8 = new Uint8Array(0);
+  return u8_buf => {
+    u8 = 0 === u8.byteLength
+      ? u8_buf : _u8_join(u8, u8_buf);
+
+    let res = [];
+    while (1) {
+      let [len_body, len_vh] = decode_varint(u8, 1);
+      let len_pkt = len_body + len_vh;
+
+      if ( u8.byteLength < len_pkt )
+        return res
+
+      let b0 = u8[0];
+      let u8_body = 0 === len_body ? null
+        : u8.subarray(len_vh, len_pkt);
+
+      u8 = u8.subarray(len_pkt);
+
+      let pkt = opt.decode_pkt(b0, u8_body, opt);
+      if (null != pkt)
+        res.push( pkt );
+    }
+  }
+}
+
+function _u8_join(a, b) {
+  let alen = a.byteLength, r = new Uint8Array(alen + b.byteLength);
+  r.set(a, 0);
+  r.set(b, alen);
+  return r
+}
+
+const _pkt_types = ['~', 'connect', 'connack', 'publish', 'puback', 'pubrec', 'pubrel', 'pubcomp', 'subscribe', 'suback', 'unsubscribe', 'unsuback', 'pingreq', 'pingresp', 'disconnect', 'auth'];
+
+function mqtt_pkt_ctx(mqtt_level, opts, pkt_ctx) {
+  pkt_ctx = {
+    __proto__: pkt_ctx || opts.pkt_ctx,
+    mqtt_level,
+    get hdr() { return this.b0 & 0xf },
+    get id() { return this.b0 >>> 4 },
+    get type() { return _pkt_types[this.b0 >>> 4] },
+  };
+
+  let op, _decode_by_id=[], _encode_by_type={};
+  for (op of opts.encode_fns)
+    op(_encode_by_type, opts.mqtt_writer);
+  for (op of opts.decode_fns)
+    op(_decode_by_id, opts.mqtt_reader);
+
+  return {
+    pkt_ctx,
+
+    encode_pkt(type, pkt) {
+      return _encode_by_type[type]( mqtt_level, pkt ) },
+
+    decode_pkt(b0, u8_body) {
+      if (b0.map) // Uint8Array in first arg
+        return mqtt_raw_dispatch(this)(b0)[0]
+
+      let fn_decode = _decode_by_id[b0>>>4] || _decode_by_id[0];
+      return fn_decode?.({__proto__: this.pkt_ctx, b0}, u8_body) },
+
+    mqtt_stream() {
+      let self = { __proto__: this, pkt_ctx: { __proto__: pkt_ctx } };
+      self.pkt_ctx._base_ = self.pkt_ctx;
+      self.decode = mqtt_raw_dispatch(self);
+      return self
+    },
+  }
+}
+
+async function _mqtt_cmd_evt(target, answer, pkt, ctx) {
+  /* target : on_mqtt_type = {
+        mqtt_pkt(pkt, ctx) {}, // generic
+
+        mqtt_auth(pkt, ctx) {},
+        mqtt_connect(pkt, ctx) {},
+        mqtt_connack(pkt, ctx) {},
+        mqtt_disconnect(pkt, ctx) {},
+
+        mqtt_publish(pkt, ctx) {},
+        mqtt_subscribe(pkt, ctx) {},
+        mqtt_unsubscribe(pkt, ctx) {},
+
+        mqtt_pingreq(pkt, ctx) {},
+        mqtt_pingresp(pkt, ctx) {},
+    } */
+
+  let pkt_fn = target[`mqtt_${pkt.type}`] || target.mqtt_pkt;
+  await pkt_fn?.call(target, pkt, ctx);}
+
+function _mqtt_cmd_type(target, answer, pkt, ctx) {
+  answer(pkt.type, pkt);
+  _mqtt_cmd_evt(target, answer, pkt, ctx);}
+
+function _mqtt_cmd_id(target, answer, pkt) {
+  answer(pkt.pkt_id, pkt);}
+
+
+const _mqtt_cmdids =[
+  _ => {}    // 0x0 reserved
+, _mqtt_cmd_evt   // 0x1 connect
+, _mqtt_cmd_type  // 0x2 connack
+, _mqtt_cmd_evt   // 0x3 publish
+, _mqtt_cmd_id    // 0x4 puback
+, _mqtt_cmd_id    // 0x5 pubrec
+, _mqtt_cmd_id    // 0x6 pubrel
+, _mqtt_cmd_id    // 0x7 pubcomp
+, _mqtt_cmd_evt   // 0x8 subscribe
+, _mqtt_cmd_id    // 0x9 suback
+, _mqtt_cmd_evt   // 0xa unsubscribe
+, _mqtt_cmd_id    // 0xb unsuback
+, _mqtt_cmd_type  // 0xc pingreq
+, _mqtt_cmd_type  // 0xd pingresp
+, _mqtt_cmd_evt   // 0xe disconnect
+, _mqtt_cmd_type  ];// 0xf auth
+
+function _mqtt_dispatch(opt, target) {
+  let hashbelt=[], rotate_ts=0;
+  // default rotate at 1s across 5 buckets
+  let { td: rotate_td=1000, n: rotate_n=5 } = opt?.rotate || {};
+
+  // Promise / future scaffolding
+  let _pkt_id=100, _ftr_key; // use _ftr_key to reuse _by_key closure
+  let _ftr_by_key = fn_answer => hashbelt[0].set(_ftr_key, fn_answer);
+
+  on_mqtt([]); // init hashbelt and rotate_ts
+  return [on_mqtt, pkt_future]
+
+
+  function pkt_future(pkt_or_key) {
+    if (! _isstr(pkt_or_key)) {
+      _pkt_id = (_pkt_id + 1) & 0xffff; // 16-bit unsigned short
+      _ftr_key = pkt_or_key.pkt_id = _pkt_id;}
+    else _ftr_key = pkt_or_key;
+
+    return new Promise(_ftr_by_key)}
+
+  function answer(key, pkt) {
+    for (let map of hashbelt) {
+      let fn_answer = map.get(key);
+      if (fn_answer) {
+        map.delete(key);
+
+        fn_answer([pkt, /*err*/]); // option/maybe monad
+        return true} }
+    return false}
+
+  function on_mqtt(pkt_list, ctx) {
+    for (let pkt of pkt_list) {
+      _mqtt_cmdids[pkt.id](target, answer, pkt, ctx);}
+
+    // rotate after rotate_ts
+    let now = Date.now();
+    if (now > rotate_ts) {
+      rotate_ts = rotate_td + now;
+      hashbelt.unshift(new Map());
+      while (hashbelt.length > rotate_n) {
+        for (let fn_answer of hashbelt.pop().values()) {
+          fn_answer([/*pkt*/, 'expired']); } } } } }// option/maybe monad
+
+class MQTTError extends Error {
+  constructor(mqtt_pkt, reason=mqtt_pkt.reason) {
+    // use hex-encoded reasons to match MQTT spec documentation
+    super(`[0x${reason.toString(16)}] ${reason.reason}`);
+    this.mqtt_pkt = mqtt_pkt;
+    this.reason = reason;} }
+
+class MQTTBase {
+  // Handshaking Packets
+  async connect(pkt={}) {
+    let cid = pkt.client_id;
+    if (! _isstr(cid)) {
+      // see init_client_id implementation in core.jsy
+      pkt.client_id = cid = this.client_id || this.init_client_id(cid);}
+    this.client_id = cid;
+
+    if (null == pkt.keep_alive) {
+      pkt.keep_alive = 60;}
+
+    let response = await this._send0('connect', pkt, 'connack');
+    if (0 != response[0].reason) {// compare to 0 to coerce to number
+      throw new this.MQTTError(response[0])}
+    return this.conn.on_conn(pkt, response)}
+
+  async disconnect(pkt={}) {
+    let response = await this._send0('disconnect', pkt);
+    return this.conn.on_dis(pkt, response)}
+
+  async auth(pkt={}) {
+    let response = await this._send0('auth', pkt, 'auth');
+    if (response[0].reason) {
+      throw new this.MQTTError(response[0])}
+    return this.conn.on_auth(pkt, response)}
+
+  ping() {return this._send('pingreq', null, 'pingresp')}
+  puback({pkt_id}) {return this._send('puback', {pkt_id})}
+
+  // alias: sub
+  subscribe(pkt, ex, topic_prefix) {
+    pkt = _as_topics(pkt, ex, topic_prefix);
+    let suback = this._send('subscribe', pkt, pkt);
+    return this.on_sub?.(suback, pkt) ?? suback}
+
+  // alias: unsub
+  unsubscribe(pkt, ex, topic_prefix) {
+    pkt = _as_topics(pkt, ex, topic_prefix);
+    return this._send('unsubscribe', pkt, pkt)}
+
+
+  post(topic, payload, pub_opt) {// qos:0
+    return this.pub({topic, payload, qos:0}, pub_opt)}
+  send(topic, payload, pub_opt) {// qos:1
+    return this.pub({topic, payload, qos:1}, pub_opt)}
+  store(topic, payload, pub_opt) {// qos:1, retain: 1
+    return this.pub({topic, payload, qos:1, retain: 1}, pub_opt)}
+
+  // alias: json_post
+  obj_post(topic, msg, pub_opt) {// qos:0
+    return this.pub({topic, msg, arg: 'msg', qos:0}, pub_opt)}
+  // alias: json_send
+  obj_send(topic, msg, pub_opt) {// qos:1
+    return this.pub({topic, msg, arg: 'msg', qos:1}, pub_opt)}
+  // alias: json_store
+  obj_store(topic, msg, pub_opt) {// qos:1, retain: 1
+    return this.pub({topic, msg, arg: 'msg', qos:1, retain: 1}, pub_opt)}
+
+  // alias: publish -- because 'pub' is shorter for semantic aliases above
+  async pub(pkt, pub_opt) {
+    if (undefined === pkt.payload) {
+      if (_isfn(pub_opt)) {
+        // pub_opt as a function is fn_encode value
+        pub_opt = {fn_encode: pub_opt};}
+
+      let msg = pkt.msg, fn_encode = pub_opt?.fn_encode;
+      if (null == msg || _isfn(msg)) {
+        // when msg is a function, return closure using fn_encode
+        if (msg) {pub_opt = {...pub_opt, fn_encode: msg};}
+        // return a single-value closure to publish packets
+        return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)}
+
+      // Encode payload from msg; fn_encode allows alternative to JSON.stringify
+      pkt.payload = fn_encode
+        ? await fn_encode(msg)
+        : JSON.stringify(msg);}
+
+    if (pub_opt) {
+      if (pub_opt.props) {
+        pkt.props = pub_opt.props;}
+      if (pub_opt.xform) {
+        pkt = pub_opt.xform(pkt) || pkt;} }
+
+    return this._send('publish', pkt,
+      pkt.qos ? pkt : null ) }// key
+
+
+  // Internal API
+
+  /* async _send0(type, pkt) -- provided by conn and transport */
+  /* async _send(type, pkt) -- provided by conn and transport */
+
+  _init_dispatch(opt) {
+    this.constructor?._once_();
+    let target ={__proto__: opt.on_mqtt_type};
+    target.mqtt_publish ||=
+      this._init_router?.(opt, this, target);
+    return _mqtt_dispatch(opt, target)}
+
+  static _aliases() {
+    return ' publish:pub sub:subscribe unsub:unsubscribe json_post:obj_post json_send:obj_send json_store:obj_store'}
+
+  static _once_(klass=this) {
+    klass._once_ = _=>0;
+    var alias, name, p = klass.prototype;
+    p.MQTTError = MQTTError;
+    for (alias of klass._aliases().split(/\s+/)) {
+      [alias, name] = alias.split(':');
+      p[alias] = p[name];} } }
+
+
+function _as_topics(pkt, ex, topic_prefix) {
+  if (ex?.trim) {// string
+    topic_prefix = ex;
+    ex = null;}
+
+  pkt =(
+    pkt.trim // string
+      ? {topics:[pkt], ... ex}
+    : pkt[Symbol.iterator]
+      ? {topics:[... pkt], ... ex}
+    : ex ? {...pkt, ...ex}
+    : pkt);
+
+  if (topic_prefix) {
+    // particularly useful with shared queues, e.g.
+    //   topic_prefix = '$share/some-queue-name/'
+    let _prefix_topics = v =>
+      v.trim ? topic_prefix+v : v.map(_prefix_topics);
+
+    pkt.topics = pkt.topics.map(_prefix_topics);}
+  return pkt}
+
+const _defer_obj = o =>(
+  o.p = new Promise((a,e) => { o.a=a; o.e=e; })
+  , o);
+
+function _dfn_reset(client, attr, fn_after) {
+  // a resetable deferred for a function
+  let self = {set}, afn = async (...args) => (await self.p)(...args);
+  return set()
+
+  function set() {
+    if (afn !== client[attr]) {
+      _defer_obj(self).p.then(fn_after, _=>0);
+      client[attr] = afn;}
+    return self} }
+
+function _mqtt_conn(opt, client, [on_mqtt, pkt_future]) {
+  let _abort;
+  let _dfn_send0 = _dfn_reset(client, '_send0', // client._send0 getter/setter
+    _=> client.conn_emit('on_live', conn.has_connected));
+  let _dfn_ready = _dfn_reset(client, '_send', // client._send getter/setter
+    _=> client.conn_emit('on_ready'));
+  let _keep_alive_ival = _interval (() =>client._send0('pingreq') );// resettable interval for keep_alive ping
+
+  let conn = Object.create({
+    ping: (td=conn.keep_alive) => _keep_alive_ival(td)
+
+  , on_conn(pkt, response) {
+      conn.has_connected = true;
+      conn.keep_alive = opt.keep_alive || response[0].props?.server_keep_alive || pkt.keep_alive;
+      client.conn_emit('on_conn');
+      return opt.use_auth
+        ? response // wait on enhanced authentication step
+        : conn.on_auth(null, response) }// otherwise, connect is also auth
+
+  , on_auth(pkt, response) {
+      _dfn_ready.a(_dfn_send0.p);
+      if (0 != opt.keep_alive) {
+        conn.ping();}
+      client.conn_emit('on_auth', !pkt);
+      return response}
+
+  , on_dis(pkt, response) {
+      conn.reset(false);
+      return response}
+
+  , reset(err) {
+      if (err) {
+        _dfn_send0.e(err); }// send error to uses of _send0 (connect, auth)
+      _abort.e(err); // abort in-progress connections
+
+      delete conn.is_set;
+      conn.ready = handshake();
+      client.conn_emit('on_disconnect', false===err, err);}
+
+  , abort() {
+      _dfn_ready.e(err); // abort all messages awaiting ready state
+      return conn.reset(err)}
+
+  , async setup(gate, send_u8_pkt, init_msg_loop) {
+      if (conn.is_set) {
+        throw new Error() }// already in-progress
+
+      conn.is_set = true;
+      await gate;
+
+      // setup send/recv MQTT parsing context
+      let mqtt_ctx = client.mqtt_ctx.mqtt_stream();
+
+       {// setup inbound message loop
+        let sess_ctx = {mqtt: client}; // mutable session context
+        let on_mqtt_chunk = u8 => on_mqtt(mqtt_ctx.decode(u8), sess_ctx);
+        init_msg_loop(on_mqtt_chunk, conn);}
+
+      // setup outbound message path and transport connection
+      send_u8_pkt = await send_u8_pkt;
+      _dfn_send0.a(
+        async (type, pkt, key) => {
+          let res = undefined !== key
+            ? pkt_future(key) : true;
+
+          await send_u8_pkt(
+            mqtt_ctx.encode_pkt(type, pkt));
+          return res} ); } });
+
+  conn.ready = handshake();
+  return conn
+
+  async function handshake() {
+    _abort = _defer_obj({});
+
+    _keep_alive_ival(0); // clearInterval on keep alive ping
+    _dfn_send0.set(); // reset client._send0 if necessary
+    _dfn_ready.set(); // reset client._send if necessary
+
+    try {
+      // set client._send0 as passtrhough after transport connection
+      client._send0 = await Promise.race([_dfn_send0.p, _abort.p]);
+
+      // set client._send as passtrhough after ready
+      client._send = await Promise.race([_dfn_ready.p, _abort.p]);
+      return true}
+    catch (err) {
+      return false} } }
+
+const pkt_api ={
+  utf8(u8) {return new TextDecoder('utf-8').decode(u8 || this.payload )}
+, json(u8) {return JSON.parse( this.utf8(u8) || null )}
+, text(u8) {return this.utf8(u8)} };
+
+const opt_default ={
+  sess_stg: globalThis.sessionStorage};
+
+class MQTTCore extends MQTTBase {
+  constructor(opt) {
+    super();
+    this.with(opt);
+    opt ={...opt_default, ...opt};
+    // settings for MQTTCore
+    this.sess_stg = opt.sess_stg;
+    // setup connection and dispatch
+    this.conn = _mqtt_conn(opt, this,
+      this._init_dispatch(opt)); }
+
+  with(fns_ns) {
+    for (let [k,v] of Object.entries(fns_ns)) {
+      if (_isfn(v)) {this[k] = v;} }
+    return this}
+
+
+  static mqtt_ctx(mqtt_level, mqtt_opts, pkt_ctx=pkt_api) {
+    let klass = class extends this {};
+    klass.prototype.mqtt_ctx =
+      mqtt_pkt_ctx(mqtt_level, mqtt_opts, pkt_ctx);
+    return klass}
+
+
+  async conn_emit(evt, arg, err_arg) {
+    this.log_conn?.(evt, arg, err_arg);
+    try {
+      let fn_evt = this[await evt]; // microtask break using `await evt`
+      if (fn_evt) {
+        await fn_evt.call(this, this, arg, err_arg);}
+      else if (err_arg) {throw err_arg} }
+    catch (err) {
+      this.on_error(err, evt);} }
+
+  on_error(err, evt) {
+    console.warn('[[u8-mqtt error: %s]]', evt, err); }
+  log_conn(evt, arg, err_arg) {
+    console.info('[[u8-mqtt conn: %s]]', evt, arg, err_arg); }
+
+
+  // automatic Client Id for connect()
+  init_client_id(parts=['u8-mqtt--','']) {
+    let sess_stg = this.sess_stg;
+    let key, cid = sess_stg?.getItem(key=parts.join(' '));
+    if (! cid) {
+      cid = parts.join(Math.random().toString(36).slice(2));
+      sess_stg?.setItem(key, cid);}
+    return cid}
+
+
+  on_live(client, is_reconnect) {
+    if (is_reconnect) {
+      return client.connect()} }
+
+  // on_ready(client) ::
+  // on_reconnect(client) ::
+  on_disconnect(client, intentional) {
+    if (! intentional) {
+      return client.on_reconnect?.()} }
+
+  _use_conn(fn_reconnect) {
+    return (this.reconnect = fn_reconnect)?.()}
+  with_autoreconnect(opt=2000) {
+    if (opt.toFixed) {opt ={delay: opt};}
+    return this.with({
+      on_reconnect() {
+        this.delay(opt.delay || 2000)
+          .then(this.reconnect)
+          .then(opt.reconnect, opt.error);} }) }
+
+  delay(ms) {
+    return new Promise(done => setTimeout(done, ms)) }
+
+  with_async_iter(async_iter, write_u8_pkt) {
+    this.conn.setup(async_iter,
+      write_u8_pkt,
+      async (on_mqtt_chunk, conn) => {
+        try {
+          async_iter = await async_iter;
+          for await (let chunk of async_iter)
+            on_mqtt_chunk(chunk);
+          conn.reset();}
+        catch (err) {
+          conn.reset(err);} } );
+    return this}
+
+
+
+  
+    with_tcp(...opt) {
+      opt = this._conn_opt(opt);
+      opt.transport = 'tcp';
+      return this._use_conn (() =>
+        this.with_deno_iter(
+          Deno.connect(opt)) ) }
+
+    with_tls(...opt) {
+      opt = this._conn_opt(opt);
+      return this._use_conn (() =>
+        this.with_deno_iter(
+          Deno.connectTls(opt)) ) }
+
+    with_deno_iter(transport) {
+      return this.with_async_iter(
+        transport.then(Deno.iter),
+        transport.then(write_stream =>
+          u8_pkt => write_stream.write(u8_pkt)) ) }
+
+    _conn_opt([a0, a1, a2]) {
+      // (port, hostname, options) or (url, options)
+      if (Number.isFinite(a0)) {
+        return {...a2, port: a0, hostname: a1}}
+
+      a0 = new URL(a0);
+      return {...a1, port: a0.port, hostname: a0.hostname}}
+
+  
+    
+      
+      
+        
+          
+
+    
+      
+      
+        
+          
+
+    
+      
+      
+        
+      
+      
+
+
+  with_stream(read_stream, write_stream) {
+    if (undefined === write_stream) {
+      write_stream = read_stream;}
+
+    return this.with_async_iter(read_stream,
+      u8_pkt => write_stream.write(u8_pkt)) }
+
+
+  with_websock(websock) {
+    if (! websock?.send) {
+      websock = new URL(websock || 'ws://127.0.0.1:9001');
+      return this._use_conn (() =>
+        this.with_websock(
+          new WebSocket(websock, ['mqtt'])) ) }
+
+    websock.binaryType = 'arraybuffer';
+
+    let ws_ready, readyState = websock.readyState;
+    if (1 !== readyState) {
+      if (0 !== readyState) {
+        throw new Error('WS readyState') }
+
+      ws_ready = new Promise(ready => websock.onopen = ready); }
+
+    this.conn.setup(ws_ready,
+      u8_pkt => websock.send(u8_pkt),
+      (on_mqtt_chunk, conn) => {
+        websock.onmessage = evt =>(
+          on_mqtt_chunk(new Uint8Array(evt.data)) );
+
+        websock.onclose = evt => {
+          if (! evt.wasClean) {
+            var err = new Error('websocket close');
+            err.code = evt.code;
+            err.reason = evt.reason;}
+
+          conn.reset(err);}; } );
+
+    return this} }
+
+const version = '0.6.0-deno';
+
+const MQTTClient_v4 = /* #__PURE__ */
+  with_topic_path_router(
+    MQTTCore.mqtt_ctx(4, mqtt_opts_v5) );
+
+const MQTTClient_v5 = /* #__PURE__ */
+  with_topic_path_router(
+    MQTTCore.mqtt_ctx(5, mqtt_opts_v5) );
+
+const mqtt_v4 = opt =>
+  new MQTTClient_v4(opt);
+
+const mqtt_v5 = opt =>
+  new MQTTClient_v5(opt);
+
+export { MQTTClient_v5 as MQTTClient, MQTTClient_v4, MQTTClient_v5, mqtt_v5 as default, mqtt_v5 as mqtt, mqtt_v4, mqtt_v5, version };
+//# sourceMappingURL=full-v5.js.map