ringcentral-softphone 1.3.2 → 1.3.4

package/dist/index.js

@@ -0,0 +1,242 @@
+import EventEmitter from "node:events";
+import tls from "node:tls";
+import waitFor from "wait-for-async";
+import InboundCallSession from "./call-session/inbound.js";
+import OutboundCallSession from "./call-session/outbound.js";
+import Codec from "./codec.js";
+import {
+  InboundMessage,
+  OutboundMessage,
+  RequestMessage,
+  ResponseMessage
+} from "./sip-message/index.js";
+import {
+  branch,
+  generateAuthorization,
+  localKey,
+  randomInt,
+  uuid
+} from "./utils.js";
+class Softphone extends EventEmitter {
+  sipInfo;
+  client;
+  codec;
+  fakeDomain = `${uuid()}.invalid`;
+  fakeEmail = `${uuid()}@${this.fakeDomain}`;
+  intervalHandle;
+  connected = false;
+  constructor(sipInfo) {
+    super();
+    if (sipInfo.codec === void 0) {
+      sipInfo.codec = "OPUS/16000";
+    }
+    this.codec = new Codec(sipInfo.codec);
+    this.sipInfo = sipInfo;
+    if (this.sipInfo.domain === void 0) {
+      this.sipInfo.domain = "sip.ringcentral.com";
+    }
+    if (this.sipInfo.outboundProxy === void 0) {
+      this.sipInfo.outboundProxy = "sip10.ringcentral.com:5096";
+    }
+    const tokens = this.sipInfo.outboundProxy.split(":");
+    this.client = tls.connect(
+      {
+        host: tokens[0],
+        port: parseInt(tokens[1], 10),
+        rejectUnauthorized: !this.sipInfo.ignoreTlsCertErrors
+      },
+      () => {
+        this.connected = true;
+      }
+    );
+    let cache = "";
+    this.client.on("data", (data) => {
+      cache += data.toString("utf-8");
+      if (!cache.endsWith("\r\n")) {
+        return;
+      }
+      const tempMessages = cache.split("\r\nContent-Length: 0\r\n\r\n").filter((message) => message.trim() !== "");
+      cache = "";
+      for (let i = 0; i < tempMessages.length; i++) {
+        if (!tempMessages[i].includes("Content-Length: ")) {
+          tempMessages[i] = `${tempMessages[i]}\r
+Content-Length: 0`;
+        }
+      }
+      for (const message of tempMessages) {
+        this.emit("message", InboundMessage.fromString(message));
+      }
+    });
+  }
+  instanceId = uuid();
+  registerCallId = uuid();
+  async register() {
+    if (!this.connected) {
+      await waitFor({
+        interval: 100,
+        times: 100,
+        condition: () => this.connected
+      });
+      if (!this.connected) {
+        throw new Error("Failed to register: connect to TLS timeout");
+      }
+    }
+    const sipRegister = async () => {
+      const fromTag = uuid();
+      const requestMessage = new RequestMessage(
+        `REGISTER sip:${this.sipInfo.domain} SIP/2.0`,
+        {
+          Via: `SIP/2.0/TLS ${this.client.localAddress}:${this.client.localPort};rport;branch=${branch()};alias`,
+          "Max-Forwards": "70",
+          From: `<sip:${this.sipInfo.username}@${this.sipInfo.domain}>;tag=${fromTag}`,
+          To: `<sip:${this.sipInfo.username}@${this.sipInfo.domain}>`,
+          "Call-ID": this.registerCallId,
+          Contact: `<sip:${this.sipInfo.username}@${this.client.localAddress}:${this.client.localPort};transport=TLS;ob>;reg-id=1;+sip.instance="<urn:uuid:${this.instanceId}>"`,
+          Expires: 3600,
+          Allow: "PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS"
+        }
+      );
+      const inboundMessage = await this.send(requestMessage, true);
+      if (inboundMessage.subject.startsWith("SIP/2.0 200 ")) {
+        return;
+      }
+      const wwwAuth = inboundMessage.getHeader("Www-Authenticate");
+      const nonce = wwwAuth.match(/, nonce="(.+?)"/)[1];
+      const newMessage = requestMessage.fork();
+      newMessage.headers.Authorization = generateAuthorization(
+        this.sipInfo,
+        nonce,
+        "REGISTER"
+      );
+      const message = await this.send(newMessage, true);
+      if (!message.subject.startsWith("SIP/2.0 200 ")) {
+        throw new Error(`Failed to register: ${message.subject}`);
+      }
+    };
+    await sipRegister();
+    this.intervalHandle = setInterval(
+      () => {
+        sipRegister().catch((error) => {
+          this.emit("registrationError", error);
+        });
+      },
+      30 * 1e3
+      // refresh registration every 30 seconds
+    );
+    this.on("message", (inboundMessage) => {
+      if (!inboundMessage.subject.startsWith("INVITE sip:")) {
+        return;
+      }
+      const outboundMessage = new OutboundMessage("SIP/2.0 100 Trying", {
+        Via: inboundMessage.headers.Via,
+        "Call-ID": inboundMessage.getHeader("Call-ID"),
+        From: inboundMessage.headers.From,
+        To: inboundMessage.headers.To,
+        CSeq: inboundMessage.headers.CSeq,
+        "Content-Length": "0"
+      });
+      this.send(outboundMessage);
+      this.emit("invite", inboundMessage);
+    });
+  }
+  enableDebugMode() {
+    this.on(
+      "message",
+      (message) => console.log(`Receiving...(${/* @__PURE__ */ new Date()})
+${message.toString()}`)
+    );
+    const tlsWrite = this.client.write.bind(this.client);
+    this.client.write = (message) => {
+      console.log(`Sending...(${/* @__PURE__ */ new Date()})
+${message}`);
+      return tlsWrite(message);
+    };
+  }
+  revoke() {
+    clearInterval(this.intervalHandle);
+    this.removeAllListeners();
+    this.client.removeAllListeners();
+    this.client.destroy();
+  }
+  send(message, waitForReply = false) {
+    this.client.write(message.toString());
+    if (!waitForReply) {
+      return new Promise((resolve) => {
+        resolve(void 0);
+      });
+    }
+    return new Promise((resolve) => {
+      const messageListerner = (inboundMessage) => {
+        if (inboundMessage.headers.CSeq.trim().split(/\s+/)[0] !== message.headers.CSeq.trim().split(/\s+/)[0]) {
+          return;
+        }
+        if (inboundMessage.subject.startsWith("SIP/2.0 100 ")) {
+          return;
+        }
+        this.off("message", messageListerner);
+        resolve(inboundMessage);
+      };
+      this.on("message", messageListerner);
+    });
+  }
+  async answer(inviteMessage) {
+    const inboundCallSession = new InboundCallSession(this, inviteMessage);
+    await inboundCallSession.answer();
+    return inboundCallSession;
+  }
+  // decline an inbound call
+  async decline(inviteMessage) {
+    const newMessage = new ResponseMessage(inviteMessage, 603);
+    await this.send(newMessage);
+  }
+  async call(callee) {
+    const offerSDP = `
+v=0
+o=- ${Date.now()} 0 IN IP4 ${this.client.localAddress}
+s=rc-softphone-ts
+c=IN IP4 ${this.client.localAddress}
+t=0 0
+m=audio ${randomInt()} RTP/SAVP ${this.codec.id} 101
+a=rtpmap:${this.codec.id} ${this.codec.name}
+a=rtpmap:101 telephone-event/8000
+a=fmtp:101 0-15
+a=sendrecv
+a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:${localKey}
+  `.trim();
+    const inviteMessage = new RequestMessage(
+      `INVITE sip:${callee}@${this.sipInfo.domain} SIP/2.0`,
+      {
+        Via: `SIP/2.0/TLS ${this.client.localAddress}:${this.client.localPort};rport;branch=${branch()};alias`,
+        "Max-Forwards": 70,
+        From: `<sip:${this.sipInfo.username}@${this.sipInfo.domain}>;tag=${uuid()}`,
+        To: `<sip:${callee}@sip.ringcentral.com>`,
+        Contact: ` <sip:${this.sipInfo.username}@${this.client.localAddress}:${this.client.localPort};transport=TLS;ob>`,
+        "Call-ID": uuid(),
+        Route: `<sip:${this.sipInfo.outboundProxy};transport=tls;lr>`,
+        Allow: `PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS`,
+        Supported: `replaces, 100rel, timer, norefersub`,
+        "Session-Expires": 1800,
+        "Min-SE": 90,
+        "Content-Type": "application/sdp"
+      },
+      offerSDP
+    );
+    const inboundMessage = await this.send(inviteMessage, true);
+    const proxyAuthenticate = inboundMessage.getHeader("Proxy-Authenticate");
+    const nonce = proxyAuthenticate.match(/, nonce="(.+?)"/)[1];
+    const newMessage = inviteMessage.fork();
+    newMessage.headers["Proxy-Authorization"] = generateAuthorization(
+      this.sipInfo,
+      nonce,
+      "INVITE"
+    );
+    const progressMessage = await this.send(newMessage, true);
+    const outboundCallSession = new OutboundCallSession(this, progressMessage);
+    outboundCallSession.sdp = offerSDP;
+    return outboundCallSession;
+  }
+}
+var index_default = Softphone;
+export {
+  index_default as default
+};

package/dist/sip-message/inbound/index.cjs

@@ -0,0 +1,51 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inbound_exports = {};
+__export(inbound_exports, {
+  default: () => inbound_default
+});
+module.exports = __toCommonJS(inbound_exports);
+var import_utils = require("../../utils.js");
+var import_sip_message = __toESM(require("../sip-message.js"), 1);
+class InboundMessage extends import_sip_message.default {
+  static fromString(str) {
+    const sipMessage = new import_sip_message.default();
+    const [init, ...body] = str.split("\r\n\r\n");
+    sipMessage.body = body.join("\r\n\r\n");
+    const [subject, ...headers] = init.split("\r\n");
+    sipMessage.subject = subject;
+    sipMessage.headers = Object.fromEntries(
+      headers.map((line) => line.split(": "))
+    );
+    if (sipMessage.headers.To && !sipMessage.headers.To.includes(";tag=")) {
+      sipMessage.headers.To += `;tag=${(0, import_utils.uuid)()}`;
+    }
+    return sipMessage;
+  }
+}
+var inbound_default = InboundMessage;

package/dist/sip-message/inbound/index.js

@@ -0,0 +1,22 @@
+import { uuid } from "../../utils.js";
+import SipMessage from "../sip-message.js";
+class InboundMessage extends SipMessage {
+  static fromString(str) {
+    const sipMessage = new SipMessage();
+    const [init, ...body] = str.split("\r\n\r\n");
+    sipMessage.body = body.join("\r\n\r\n");
+    const [subject, ...headers] = init.split("\r\n");
+    sipMessage.subject = subject;
+    sipMessage.headers = Object.fromEntries(
+      headers.map((line) => line.split(": "))
+    );
+    if (sipMessage.headers.To && !sipMessage.headers.To.includes(";tag=")) {
+      sipMessage.headers.To += `;tag=${uuid()}`;
+    }
+    return sipMessage;
+  }
+}
+var inbound_default = InboundMessage;
+export {
+  inbound_default as default
+};

package/dist/sip-message/index.cjs

@@ -0,0 +1,49 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sip_message_exports = {};
+__export(sip_message_exports, {
+  InboundMessage: () => import_inbound.default,
+  OutboundMessage: () => import_outbound.default,
+  RequestMessage: () => import_request.default,
+  ResponseMessage: () => import_response.default,
+  SipMessage: () => import_sip_message.default
+});
+module.exports = __toCommonJS(sip_message_exports);
+var import_inbound = __toESM(require("./inbound/index.js"), 1);
+var import_outbound = __toESM(require("./outbound/index.js"), 1);
+var import_request = __toESM(require("./outbound/request.js"), 1);
+var import_response = __toESM(require("./outbound/response.js"), 1);
+var import_sip_message = __toESM(require("./sip-message.js"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InboundMessage,
+  OutboundMessage,
+  RequestMessage,
+  ResponseMessage,
+  SipMessage
+});

package/dist/sip-message/index.js

@@ -0,0 +1,12 @@
+import { default as default2 } from "./inbound/index.js";
+import { default as default3 } from "./outbound/index.js";
+import { default as default4 } from "./outbound/request.js";
+import { default as default5 } from "./outbound/response.js";
+import { default as default6 } from "./sip-message.js";
+export {
+  default2 as InboundMessage,
+  default3 as OutboundMessage,
+  default4 as RequestMessage,
+  default5 as ResponseMessage,
+  default6 as SipMessage
+};

package/dist/sip-message/outbound/index.cjs

@@ -0,0 +1,41 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var outbound_exports = {};
+__export(outbound_exports, {
+  default: () => outbound_default
+});
+module.exports = __toCommonJS(outbound_exports);
+var import_sip_message = __toESM(require("../sip-message.js"), 1);
+class OutboundMessage extends import_sip_message.default {
+  constructor(subject = "", headers = {}, body = "") {
+    super(subject, headers, body);
+    this.headers["Content-Length"] = this.body.length.toString();
+    this.headers["User-Agent"] = "ringcentral-softphone-ts";
+  }
+}
+var outbound_default = OutboundMessage;

package/dist/sip-message/outbound/index.js

@@ -0,0 +1,12 @@
+import SipMessage from "../sip-message.js";
+class OutboundMessage extends SipMessage {
+  constructor(subject = "", headers = {}, body = "") {
+    super(subject, headers, body);
+    this.headers["Content-Length"] = this.body.length.toString();
+    this.headers["User-Agent"] = "ringcentral-softphone-ts";
+  }
+}
+var outbound_default = OutboundMessage;
+export {
+  outbound_default as default
+};

package/dist/sip-message/outbound/request.cjs

@@ -0,0 +1,62 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_exports = {};
+__export(request_exports, {
+  default: () => request_default
+});
+module.exports = __toCommonJS(request_exports);
+var import_utils = require("../../utils.js");
+var import_index = __toESM(require("./index.js"), 1);
+let cseq = Math.floor(Math.random() * 1e4);
+class RequestMessage extends import_index.default {
+  constructor(subject = "", headers = {}, body = "") {
+    super(subject, headers, body);
+    if (this.headers.CSeq === void 0) {
+      this.newCseq();
+    }
+  }
+  newCseq() {
+    this.headers.CSeq = `${++cseq} ${this.subject.split(" ")[0]}`;
+  }
+  fork() {
+    const newMessage = new RequestMessage(
+      this.subject,
+      { ...this.headers },
+      this.body
+    );
+    newMessage.newCseq();
+    if (newMessage.headers.Via) {
+      newMessage.headers.Via = newMessage.headers.Via.replace(
+        /;branch=.+?$/,
+        `;branch=${(0, import_utils.branch)()}`
+      );
+    }
+    return newMessage;
+  }
+}
+var request_default = RequestMessage;

package/dist/sip-message/outbound/request.js

@@ -0,0 +1,33 @@
+import { branch } from "../../utils.js";
+import OutboundMessage from "./index.js";
+let cseq = Math.floor(Math.random() * 1e4);
+class RequestMessage extends OutboundMessage {
+  constructor(subject = "", headers = {}, body = "") {
+    super(subject, headers, body);
+    if (this.headers.CSeq === void 0) {
+      this.newCseq();
+    }
+  }
+  newCseq() {
+    this.headers.CSeq = `${++cseq} ${this.subject.split(" ")[0]}`;
+  }
+  fork() {
+    const newMessage = new RequestMessage(
+      this.subject,
+      { ...this.headers },
+      this.body
+    );
+    newMessage.newCseq();
+    if (newMessage.headers.Via) {
+      newMessage.headers.Via = newMessage.headers.Via.replace(
+        /;branch=.+?$/,
+        `;branch=${branch()}`
+      );
+    }
+    return newMessage;
+  }
+}
+var request_default = RequestMessage;
+export {
+  request_default as default
+};

package/dist/sip-message/outbound/response.cjs

@@ -0,0 +1,55 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+__export(response_exports, {
+  default: () => response_default
+});
+module.exports = __toCommonJS(response_exports);
+var import_response_codes = __toESM(require("../response-codes.js"), 1);
+var import_index = __toESM(require("./index.js"), 1);
+class ResponseMessage extends import_index.default {
+  constructor(inboundMessage, responseCode, headers = {}, body = "") {
+    super(void 0, { ...headers }, body);
+    this.subject = `SIP/2.0 ${responseCode} ${import_response_codes.default[responseCode]}`;
+    const requiredKeys = /* @__PURE__ */ new Set(["via", "from", "to", "call-id", "cseq"]);
+    const allKeys = Object.keys(inboundMessage.headers).reduce(
+      (acc, key) => {
+        acc[key.toLowerCase()] = key;
+        return acc;
+      },
+      {}
+    );
+    for (const key of requiredKeys) {
+      if (allKeys[key]) {
+        const originalKey = allKeys[key];
+        this.headers[originalKey] = inboundMessage.headers[originalKey];
+      }
+    }
+  }
+}
+var response_default = ResponseMessage;

package/dist/sip-message/outbound/response.js

@@ -0,0 +1,26 @@
+import responseCodes from "../response-codes.js";
+import OutboundMessage from "./index.js";
+class ResponseMessage extends OutboundMessage {
+  constructor(inboundMessage, responseCode, headers = {}, body = "") {
+    super(void 0, { ...headers }, body);
+    this.subject = `SIP/2.0 ${responseCode} ${responseCodes[responseCode]}`;
+    const requiredKeys = /* @__PURE__ */ new Set(["via", "from", "to", "call-id", "cseq"]);
+    const allKeys = Object.keys(inboundMessage.headers).reduce(
+      (acc, key) => {
+        acc[key.toLowerCase()] = key;
+        return acc;
+      },
+      {}
+    );
+    for (const key of requiredKeys) {
+      if (allKeys[key]) {
+        const originalKey = allKeys[key];
+        this.headers[originalKey] = inboundMessage.headers[originalKey];
+      }
+    }
+  }
+}
+var response_default = ResponseMessage;
+export {
+  response_default as default
+};