visaljs 0.0.9 → 0.0.11

package/node/prelude/internal/udp.js

@@ -0,0 +1,177 @@
+// Node's udp_wrap binding (UDP and SendWrap, as src/udp_wrap.cc defines them) over the host's UDP
+// handles (src/host_udp.c): what lib/dgram.js calls, with the same results (0 or a negative errno,
+// a send's length + 1 when it went at once) and callbacks (onmessage, a SendWrap's oncomplete).
+import {
+  errnoMessage, errnoName, udpAddress, udpBind, udpBufferSize, udpClose, udpConnect, udpDisconnect, udpFd, udpHasRef, udpMembership, udpOpen, udpOpenFd,
+  udpRecvStart, udpRecvStop, udpRef, udpSend, udpSendQueue, udpSetBroadcast, udpSetMulticastInterface, udpSetMulticastLoopback,
+  udpSetMulticastTTL, udpSetTTL, udpSourceMembership,
+} from "visaljs:host";
+import { Buffer } from "../buffer.js";
+
+const UDP_MESSAGE = 0, UDP_SENT = 1;
+let nextAsyncId = 1;
+
+export class SendWrap {}
+
+export class UDP {
+  constructor() {
+    this._id = udpOpen((event, a, b) => this._event(event, a, b));
+    this._pending = [];  /* SendWraps whose sends were queued, in order */
+    this._closeCallback = null;
+    this._asyncId = nextAsyncId++;
+    this.onmessage = null;
+    this.onerror = null;
+  }
+
+  _event(event, a, b) {
+    if (event === UDP_MESSAGE) {
+      if (typeof a === "number") this.onmessage?.(a, this, undefined, undefined);
+      else this.onmessage?.(a.byteLength, this, Buffer.from(a.buffer, a.byteOffset, a.byteLength), { address: b[0], family: b[1], port: b[2] });
+    } else if (event === UDP_SENT) {
+      const req = this._pending.shift();
+      req?.oncomplete?.(a, b);
+    } else {
+      this._closeCallback?.();
+    }
+  }
+
+  getAsyncId() {
+    return this._asyncId;
+  }
+
+  open(fd) {
+    return udpOpenFd(this._id, fd);
+  }
+
+  get fd() {
+    return udpFd(this._id);
+  }
+
+  bind(ip, port, flags) {
+    return udpBind(this._id, ip, port, flags);
+  }
+
+  bind6(ip, port, flags) {
+    return udpBind(this._id, ip, port, flags);
+  }
+
+  connect(ip, port) {
+    return udpConnect(this._id, ip, port);
+  }
+
+  connect6(ip, port) {
+    return udpConnect(this._id, ip, port);
+  }
+
+  disconnect() {
+    return udpDisconnect(this._id);
+  }
+
+  /** send(req, list, count, port, ip, hasCallback), or a connected socket's send(req, list, count, hasCallback). */
+  send(req, list, count, port, ip) {
+    const connected = typeof port !== "number";
+    const err = udpSend(this._id, list, connected ? null : ip, connected ? 0 : port);
+    if (err === 0) this._pending.push(req);
+    return err;
+  }
+
+  send6(req, list, count, port, ip) {
+    return this.send(req, list, count, port, ip);
+  }
+
+  recvStart() {
+    return udpRecvStart(this._id);
+  }
+
+  recvStop() {
+    return udpRecvStop(this._id);
+  }
+
+  getsockname(out) {
+    return address(udpAddress(this._id, false), out);
+  }
+
+  getpeername(out) {
+    return address(udpAddress(this._id, true), out);
+  }
+
+  setBroadcast(on) {
+    return udpSetBroadcast(this._id, on);
+  }
+
+  setTTL(ttl) {
+    return udpSetTTL(this._id, ttl);
+  }
+
+  setMulticastTTL(ttl) {
+    return udpSetMulticastTTL(this._id, ttl);
+  }
+
+  setMulticastLoopback(on) {
+    return udpSetMulticastLoopback(this._id, on);
+  }
+
+  setMulticastInterface(iface) {
+    return udpSetMulticastInterface(this._id, iface);
+  }
+
+  addMembership(group, iface) {
+    return udpMembership(this._id, group, iface ?? null, true);
+  }
+
+  dropMembership(group, iface) {
+    return udpMembership(this._id, group, iface ?? null, false);
+  }
+
+  addSourceSpecificMembership(source, group, iface) {
+    return udpSourceMembership(this._id, source, group, iface ?? null, true);
+  }
+
+  dropSourceSpecificMembership(source, group, iface) {
+    return udpSourceMembership(this._id, source, group, iface ?? null, false);
+  }
+
+  /* the size, or undefined with what failed in ctx (for ERR_SOCKET_BUFFER_SIZE) */
+  bufferSize(size, recv, ctx) {
+    const r = udpBufferSize(this._id, size, recv);
+    if (r >= 0) return r;
+    ctx.errno = r;
+    ctx.code = errnoName(r);
+    ctx.message = errnoMessage(r);
+    ctx.syscall = recv ? "uv_recv_buffer_size" : "uv_send_buffer_size";
+    return undefined;
+  }
+
+  getSendQueueSize() {
+    return udpSendQueue(this._id, false);
+  }
+
+  getSendQueueCount() {
+    return udpSendQueue(this._id, true);
+  }
+
+  close(callback) {
+    if (typeof callback === "function") this._closeCallback = callback;
+    udpClose(this._id);
+  }
+
+  ref() {
+    udpRef(this._id, true);
+  }
+
+  unref() {
+    udpRef(this._id, false);
+  }
+
+  hasRef() {
+    return udpHasRef(this._id);
+  }
+}
+
+function address(result, out) {
+  if (typeof result === "number") return result;
+  out.address = result[0];
+  out.family = result[1];
+  out.port = result[2];
+  return 0;
+}

package/node/prelude/net.js

@@ -9,8 +9,9 @@
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   errnoMessage, errnoName, netAddress, netBind, netCallback, netChmod, netClose, netConnect, netGuessHandle, netKeepAlive, netListen,
-  netFd, netNoDelay, netOpen, netOpenFd, netReadStart, netReadStop, netRef, netReset, netShutdown, netWrite, timerUnref,
+  loopNow, netFd, netNoDelay, netOpen, netOpenFd, netReadStart, netReadStop, netRef, netReset, netShutdown, netWrite, timerUnref,
 } from "visaljs:host";
+import { channel, tracingChannel } from "./diagnostics_channel.js";
 import { ADDRCONFIG, lookup } from "./dns.js";
 import { EventEmitter } from "./events.js";
 import { bindContext } from "./internal/async_context.js";
@@ -30,11 +31,9 @@ const UV_EOF = -4095;
 const UV_EINVAL = -22;
 const TIMEOUT_MAX = 2 ** 31 - 1;
 
-/* a monotonic clock in ms */
-const now = () => {
-  const [seconds, nanoseconds] = process.hrtime();
-  return seconds * 1e3 + nanoseconds / 1e6;
-};
+const netClientSocketChannel = channel("net.client.socket");
+const netServerSocketChannel = channel("net.server.socket");
+const netServerListen = tracingChannel("net.server.listen");
 
 /* ---- Node's error shapes ------------------------------------------------------------------- */
 
@@ -210,7 +209,8 @@ class SocketClass extends Duplex {
     this._keepAlive = options.keepAlive === true ? [true, ~~((options.keepAliveInitialDelay ?? 0) / 1000)] : null;
     this._unref = false;
     this._timer = null;         /* the timeout: an unref'd timer, re-armed for the idle time left when it fires */
-    this._timeoutMs = 0;
+    this._timerDue = 0;         /* when _timer fires (loopNow's clock) */
+    this._timeoutMs = 0;        /* 0: off; a pending _timer then finds nothing to do */
     this._lastActive = 0;
     this._onread = null;
     if (options.typeOfService !== undefined) feature("validateTypeOfService")(options.typeOfService);
@@ -386,6 +386,7 @@ class SocketClass extends Duplex {
     if (!writableBuffer) return undefined;
     let bytes = this._bytesDispatched;
     for (const el of writableBuffer) bytes += typeof el.chunk === "string" ? Buffer.byteLength(el.chunk, el.encoding) : el.chunk.length;
+    if (this._httpWritten) bytes += this._httpWritten();  /* a server's responses, written through llhttp's connection */
     const data = this._pendingData;
     if (Array.isArray(data)) {
       for (const el of data) bytes += typeof el.chunk === "string" ? Buffer.byteLength(el.chunk, el.encoding) : el.chunk.length;
@@ -468,16 +469,19 @@ class SocketClass extends Duplex {
     if (typeof msecs !== "number") throw invalidArgType("msecs", "of type number", msecs);
     if (!(msecs >= 0 && msecs !== Infinity)) throw outOfRange("msecs", "a non-negative finite number", msecs);
     if (msecs > TIMEOUT_MAX) msecs = TIMEOUT_MAX;
-    this._clearTimeout();
+    /* the pending timer stays when it fires no later than the new deadline: _onTimer re-arms it
+     * for the rest, so a keep-alive socket, off for each request and on after it, sets no timer */
     if (msecs === 0) {
+      this._timeoutMs = 0;
       if (callback !== undefined) {
         validateFunction(callback, "callback");
         this.removeListener("timeout", callback);
       }
     } else {
       this._timeoutMs = msecs;
-      this._lastActive = now();
-      this._armTimeout(msecs);
+      this._lastActive = loopNow();
+      if (this._timer !== null && this._timerDue > this._lastActive + msecs) this._stopTimer();
+      if (this._timer === null) this._armTimeout(msecs);
       if (callback !== undefined) {
         validateFunction(callback, "callback");
         this.once("timeout", callback);
@@ -487,26 +491,32 @@ class SocketClass extends Duplex {
   }
 
   _armTimeout(ms) {
+    this._timerDue = loopNow() + ms;
     this._timer = timerUnref(() => this._onTimer(), ms);
   }
 
   _onTimer() {
     this._timer = null;
-    const idle = now() - this._lastActive;
+    if (this._timeoutMs === 0) return;
+    const idle = loopNow() - this._lastActive;
     if (idle < this._timeoutMs - 1) this._armTimeout(this._timeoutMs - idle);
     else this.emit("timeout");
   }
 
-  _clearTimeout() {
+  _stopTimer() {
     if (this._timer !== null) clearTimeout(this._timer);
     this._timer = null;
+  }
+
+  _clearTimeout() {
+    this._stopTimer();
     this._timeoutMs = 0;
   }
 
   /* activity: the timeout counts from now (Node's timer.refresh(), which re-arms a fired one) */
   _unrefTimer() {
     if (this._timeoutMs) {
-      this._lastActive = now();
+      this._lastActive = loopNow();
       if (this._timer === null) this._armTimeout(this._timeoutMs);
     }
   }
@@ -661,6 +671,7 @@ class SocketClass extends Duplex {
       this._perfConnect = null;
       this._undestroy();
     }
+    if (netClientSocketChannel.hasSubscribers) netClientSocketChannel.publish({ socket: this });
     const { path } = options;
     if (cb !== null) this.once("connect", cb);
     this._unrefTimer();
@@ -719,7 +730,7 @@ class SocketClass extends Duplex {
       });
       return;
     }
-    let family = options.family ?? 0;
+    let family = options.family;
     if (family === "IPv4") family = 4;
     else if (family === "IPv6") family = 6;
     const lookupFn = options.lookup ?? lookup;
@@ -950,6 +961,7 @@ class ServerClass extends EventEmitter {
     let [options, cb] = normalizeArgs(args);
     if (typeof options.callback === "function") cb = options.callback;
     if (this._handle !== null) throw codeError(Error, "ERR_SERVER_ALREADY_LISTEN", "Listen method has been called more than once without closing.");
+    if (netServerListen.hasSubscribers) netServerListen.asyncStart.publish({ server: this, options });
     if (cb !== null) this.once("listening", cb);
     this._listeningId++;
     const backlogFromArgs = toNumber(args.length > 1 && args[1]) || toNumber(args.length > 2 && args[2]);
@@ -1091,6 +1103,7 @@ class ServerClass extends EventEmitter {
       if (rval === null) rval = this._createHandle(address, port, addressType, fd, flags);
       if (rval < 0) {
         const error = uvExceptionWithHostPort(rval, "listen", address, port);
+        if (netServerListen.hasSubscribers) netServerListen.error.publish({ server: this, error });
         process.nextTick(() => this.emit("error", error));
         return;
       }
@@ -1102,9 +1115,11 @@ class ServerClass extends EventEmitter {
       const ex = uvExceptionWithHostPort(err, "listen", address, port);
       netClose(id);
       this._handle = null;
+      if (netServerListen.hasSubscribers) netServerListen.error.publish({ server: this, error: ex });
       process.nextTick(() => this.emit("error", ex));
       return;
     }
+    if (netServerListen.hasSubscribers) netServerListen.asyncEnd.publish({ server: this });
     this._connectionKey = addressType + ":" + address + ":" + port;
     if (this._unref) netRef(id, false);
     process.nextTick(() => {
@@ -1145,6 +1160,7 @@ class ServerClass extends EventEmitter {
     socket.server = this;
     socket._server = this;
     this.emit("connection", socket);
+    if (netServerSocketChannel.hasSubscribers) netServerSocketChannel.publish({ socket });
   }
 
   /* { address, family, port }, or a pipe's path */

package/node/prelude/os.js

@@ -3,7 +3,7 @@
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   errnoMessage, errnoName, osConstants, osCpus, osGetPriority, osHomedir, osHostname, osInterfaces, osLoadavg, osMemory, osParallelism,
-  osSetPriority, osTmpdir, osUname, osUptime, osUserInfo,
+  osSetPriority, osUname, osUptime, osUserInfo,
 } from "visaljs:host";
 import { codeError, invalidArgType } from "./internal/errors.js";
 
@@ -64,10 +64,18 @@ export function homedir() {
   return check(osHomedir(), "uv_os_homedir");
 }
 
+/* Node's: TEMP, TMP or %SystemRoot%\temp on Windows; elsewhere TMPDIR, TMP or TEMP (getTempDir), without a trailing separator */
 export function tmpdir() {
-  const dir = osTmpdir();
-  return typeof dir === "string" && dir !== "" ? dir : "/tmp";
+  const env = process.env;
+  if (process.platform === "win32") {
+    const path = env.TEMP || env.TMP || (env.SystemRoot || env.windir) + "\\temp";
+    return path.length > 1 && path.endsWith("\\") && path[path.length - 2] !== ":" ? path.slice(0, -1) : path;
+  }
+  const dir = env.TMPDIR || env.TMP || env.TEMP;
+  if (!dir) return "/tmp";
+  return dir.length > 1 && dir.endsWith("/") ? dir.slice(0, -1) : dir;
 }
+tmpdir[Symbol.toPrimitive] = () => tmpdir();
 
 export function totalmem() {
   return osMemory()[0];
@@ -200,7 +208,17 @@ export const constants = Object.freeze({
   }),
 });
 
-export default {
+/* as Node's: `${os.hostname}` and the like give their value */
+for (const f of [availableParallelism, freemem, hostname, version, type, release, machine, homedir, totalmem, uptime, arch, platform, endianness]) {
+  f[Symbol.toPrimitive] = () => f();
+}
+
+/* as Node's module object: EOL and devNull read-only (but configurable), constants fixed */
+export default Object.defineProperties({
   arch, availableParallelism, cpus, endianness, freemem, getPriority, homedir, hostname, loadavg, networkInterfaces, platform, release,
-  setPriority, tmpdir, totalmem, type, userInfo, uptime, version, machine, constants, EOL, devNull,
-};
+  setPriority, tmpdir, totalmem, type, userInfo, uptime, version, machine,
+}, {
+  constants: { configurable: false, enumerable: true, value: constants },
+  EOL: { configurable: true, enumerable: true, writable: false, value: EOL },
+  devNull: { configurable: true, enumerable: true, writable: false, value: devNull },
+});

package/node/prelude/perf_hooks.js

@@ -2,7 +2,7 @@
 // process.hrtime's, from when this module loads: timeOrigin is that time on the epoch clock.
 // PerformanceObserver and the histograms are modules of their own (internal/perf_observe.js,
 // internal/perf_histogram.js), linked when the program names them.
-import { codeError, invalidArgType } from "./internal/errors.js";
+import { codeError, invalidArgType, validateFunction } from "./internal/errors.js";
 import { features, lazyClass, lazyFunction } from "./internal/features.js";
 
 const hrMs = () => {
@@ -61,6 +61,39 @@ function markTime(mark) {
   throw new globalThis.DOMException('The "' + mark + '" performance mark has not been set', "SyntaxError");
 }
 
+function processComplete(name, start, args, histogram) {
+  const duration = now() - start;
+  if (histogram !== undefined) histogram.record(Math.ceil(duration * 1e6));
+  const entry = new PerformanceEntry(kConstruct, name, "function", start, duration, args);
+  for (let n = 0; n < args.length; n++) entry[n] = args[n];
+  features.perfObserve?.(entry);
+}
+
+/** fn, timed: each call is a 'function' entry for the observers, and its duration (ns) in the histogram. */
+export function timerify(fn, options = {}) {
+  validateFunction(fn, "fn");
+  if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+  const { histogram } = options;
+  if (histogram !== undefined && (!features.isHistogram?.(histogram) || typeof histogram.record !== "function")) {
+    throw invalidArgType("options.histogram", "an instance of RecordableHistogram", histogram);
+  }
+  function timerified(...args) {
+    const isConstructorCall = new.target !== undefined;
+    const start = now();
+    const result = isConstructorCall ? Reflect.construct(fn, args, fn) : Reflect.apply(fn, this, args);
+    if (!isConstructorCall && typeof result?.finally === "function") {
+      return result.finally(processComplete.bind(result, fn.name, start, args, histogram));
+    }
+    processComplete(fn.name, start, args, histogram);
+    return result;
+  }
+  Object.defineProperties(timerified, {
+    length: { configurable: false, enumerable: true, value: fn.length },
+    name: { configurable: false, enumerable: true, value: `timerified ${fn.name}` },
+  });
+  return timerified;
+}
+
 export class Performance {
   constructor(key) {
     if (key !== kConstruct) throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
@@ -130,6 +163,8 @@ function clear(type, name) {
   }
 }
 
+Object.defineProperty(Performance.prototype, "timerify", { configurable: true, enumerable: false, writable: true, value: timerify });
+
 export const performance = new Performance(kConstruct);
 
 export const constants = {
@@ -147,5 +182,5 @@ export const monitorEventLoopDelay = lazyFunction("monitorEventLoopDelay");
 
 export default {
   Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver, PerformanceObserverEntryList, PerformanceResourceTiming,
-  performance, constants, createHistogram, monitorEventLoopDelay,
+  performance, constants, createHistogram, monitorEventLoopDelay, timerify,
 };

package/node/prelude/punycode.js

@@ -2,30 +2,12 @@
 // punycode.js 2.1.0 Node bundles (deprecated in Node, still required by older packages).
 // Ported from punycode.js 2.1.0 (Copyright Mathias Bynens, MIT): node/third_party/punycode/LICENSE.
 
-const maxInt = 2147483647;
-const base = 36;
-const tMin = 1;
-const tMax = 26;
-const skew = 38;
-const damp = 700;
-const initialBias = 72;
-const initialN = 128;
-const delimiter = "-";
+import { decode, encode } from "./internal/punycode.ts";
 
 const regexPunycode = /^xn--/;
 const regexNonASCII = /[^\0-\x7F]/;
 const regexSeparators = /[\x2E。．｡]/g;  /* RFC 3490 separators */
 
-const errors = {
-  overflow: "Overflow: input needs wider integers to process",
-  "not-basic": "Illegal input >= 0x80 (not a basic code point)",
-  "invalid-input": "Invalid input",
-};
-
-function error(type) {
-  throw new RangeError(errors[type]);
-}
-
 /* a domain name's labels mapped, an email address's local part kept */
 function mapDomain(domain, fn) {
   const parts = domain.split("@");
@@ -61,117 +43,6 @@ function ucs2decode(string) {
 /** Code points as a string. */
 const ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
 
-/* a basic code point's digit value, or base for anything else */
-function basicToDigit(codePoint) {
-  if (codePoint >= 0x30 && codePoint < 0x3a) return 26 + (codePoint - 0x30);
-  if (codePoint >= 0x41 && codePoint < 0x5b) return codePoint - 0x41;
-  if (codePoint >= 0x61 && codePoint < 0x7b) return codePoint - 0x61;
-  return base;
-}
-
-/* a digit's code point, lowercase (0..25 a..z, 26..35 0..9) */
-const digitToBasic = (digit) => digit + 22 + 75 * (digit < 26);
-
-/* RFC 3492 3.4 */
-function adapt(delta, numPoints, firstTime) {
-  let k = 0;
-  delta = firstTime ? Math.floor(delta / damp) : delta >> 1;
-  delta += Math.floor(delta / numPoints);
-  for (; delta > ((base - tMin) * tMax) >> 1; k += base) delta = Math.floor(delta / (base - tMin));
-  return Math.floor(k + ((base - tMin + 1) * delta) / (delta + skew));
-}
-
-/** Punycode (ASCII only) to the Unicode string it encodes. */
-export function decode(input) {
-  const output = [];
-  const inputLength = input.length;
-  let i = 0;
-  let n = initialN;
-  let bias = initialBias;
-
-  /* the basic code points: everything before the last delimiter */
-  let basic = input.lastIndexOf(delimiter);
-  if (basic < 0) basic = 0;
-  for (let j = 0; j < basic; ++j) {
-    if (input.charCodeAt(j) >= 0x80) error("not-basic");
-    output.push(input.charCodeAt(j));
-  }
-
-  /* the deltas, each inserting a code point */
-  for (let index = basic > 0 ? basic + 1 : 0; index < inputLength;) {
-    const oldi = i;
-    for (let w = 1, k = base; ; k += base) {
-      if (index >= inputLength) error("invalid-input");
-      const digit = basicToDigit(input.charCodeAt(index++));
-      if (digit >= base) error("invalid-input");
-      if (digit > Math.floor((maxInt - i) / w)) error("overflow");
-      i += digit * w;
-      const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-      if (digit < t) break;
-      const baseMinusT = base - t;
-      if (w > Math.floor(maxInt / baseMinusT)) error("overflow");
-      w *= baseMinusT;
-    }
-    const out = output.length + 1;
-    bias = adapt(i - oldi, out, oldi === 0);
-    if (Math.floor(i / out) > maxInt - n) error("overflow");
-    n += Math.floor(i / out);
-    i %= out;
-    output.splice(i++, 0, n);
-  }
-  return String.fromCodePoint(...output);
-}
-
-/** A Unicode string as Punycode (ASCII only). */
-export function encode(input) {
-  const output = [];
-  input = ucs2decode(input);
-  const inputLength = input.length;
-  let n = initialN;
-  let delta = 0;
-  let bias = initialBias;
-
-  for (const currentValue of input) {
-    if (currentValue < 0x80) output.push(String.fromCharCode(currentValue));
-  }
-  const basicLength = output.length;
-  let handledCPCount = basicLength;
-  if (basicLength) output.push(delimiter);
-
-  while (handledCPCount < inputLength) {
-    /* the next code point to insert: the smallest not yet handled */
-    let m = maxInt;
-    for (const currentValue of input) {
-      if (currentValue >= n && currentValue < m) m = currentValue;
-    }
-    const handledCPCountPlusOne = handledCPCount + 1;
-    if (m - n > Math.floor((maxInt - delta) / handledCPCountPlusOne)) error("overflow");
-    delta += (m - n) * handledCPCountPlusOne;
-    n = m;
-    for (const currentValue of input) {
-      if (currentValue < n && ++delta > maxInt) error("overflow");
-      if (currentValue === n) {
-        let q = delta;
-        for (let k = base; ; k += base) {
-          const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-          if (q < t) break;
-          const qMinusT = q - t;
-          const baseMinusT = base - t;
-          output.push(String.fromCharCode(digitToBasic(t + (qMinusT % baseMinusT))));
-          q = Math.floor(qMinusT / baseMinusT);
-        }
-        output.push(String.fromCharCode(digitToBasic(q)));
-        bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
-        delta = 0;
-        ++handledCPCount;
-      }
-    }
-    ++delta;
-    ++n;
-  }
-  return output.join("");
-}
-
 /** A domain name (or email address) with its Punycode labels (xn--…) as Unicode. */
 export function toUnicode(input) {
   return mapDomain(input, (string) => (regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string));
@@ -182,6 +53,7 @@ export function toASCII(input) {
   return mapDomain(input, (string) => (regexNonASCII.test(string) ? "xn--" + encode(string) : string));
 }
 
+export { decode, encode };
 export const version = "2.1.0";
 export const ucs2 = { decode: ucs2decode, encode: ucs2encode };