tsetmc-client/dist/index.mjs

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/DayDetails/index.ts
var DayDetails_exports = {};
__export(DayDetails_exports, {
  getOrderBook: () => getOrderBook,
  getPriceData: () => getPriceData,
  getPriceOverview: () => getPriceOverviewData,
  getShareholders: () => getShareholders,
  getSupervisionDetail: () => getSupervisionDetail,
  getThresholds: () => getThresholds,
  getTradersType: () => getTradersType,
  getTrades: () => getTrades
});

// src/request.ts
import axios from "axios";
import deepmerge from "deepmerge";

// src/utils/index.ts
var utils_exports = {};
__export(utils_exports, {
  dEven2Date: () => dEven2Date,
  dEvenValidation: () => dEvenValidation,
  deepUpdate: () => deepUpdate,
  even2JDate: () => even2JDate,
  faToAr: () => faToAr,
  fakeBrowserHeaders: () => fakeBrowserHeaders,
  hEven2Time: () => hEven2Time,
  hEvenValidation: () => hEvenValidation,
  omitNulls: () => omitNulls
});

// src/utils/miscUtils.ts
function deepUpdate(d1, d2) {
  const ret = { ...d1 };
  for (const [key, value] of Object.entries(d2)) {
    if (!(key in d1)) {
      ret[key] = value;
    } else if (typeof value === "object") {
      ret[key] = deepUpdate(d1[key], value);
    } else {
      ret[key] = value;
    }
  }
  return ret;
}
function omitNulls(obj) {
  const ret = obj;
  for (const [key, value] of Object.entries(obj)) {
    if (value === null) {
      delete ret[key];
    }
  }
  return ret;
}

// src/utils/timeUtils.ts
function hEven2Time(heven) {
  const hevenStr = heven.toString();
  if (hevenStr.length === 6) {
    return `${hevenStr.slice(0, 2).padStart(2, "0")}:${hevenStr.slice(2, 4)}:${hevenStr.slice(4)}`;
  }
  return `${hevenStr.slice(0, 1).padStart(2, "0")}:${hevenStr.slice(1, 3)}:${hevenStr.slice(3)}`;
}
function dEven2Date(deven) {
  const devenStr = deven.toString();
  const year = devenStr.slice(0, 4);
  const month = devenStr.slice(4, 6);
  const day = devenStr.slice(6).padStart(2, "0");
  return `${year}-${month}-${day}`;
}
function even2JDate(dEven, hEven) {
  return /* @__PURE__ */ new Date(`${hEven2Time(dEven)} ${dEven2Date(hEven)}`);
}
function hEvenValidation(hEven) {
  const hEvenStr = hEven.toString();
  if (hEvenStr.length === 6) {
    const hour = parseInt(hEvenStr.slice(0, 2));
    const minute = parseInt(hEvenStr.slice(2, 4));
    const second = parseInt(hEvenStr.slice(4));
    return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
  }
  return false;
}
function dEvenValidation(dEven) {
  const dEvenStr = dEven.toString();
  const year = parseInt(dEvenStr.slice(0, 4));
  const month = parseInt(dEvenStr.slice(4, 6));
  const day = parseInt(dEvenStr.slice(6));
  return year >= 1300 && year <= 1500 && month >= 1 && month <= 12 && day >= 1 && day <= 31;
}

// src/utils/fetchUtils.ts
function fakeBrowserHeaders() {
  return {
    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Accept-Language": "en-US,en;q=0.9,fa;q=0.8",
    "Cache-Control": "max-age=0",
    "Sec-Ch-Ua": '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"',
    "Sec-Ch-Ua-Mobile": "?0",
    "Sec-Ch-Ua-Platform": '"Windows"',
    "Sec-Fetch-Dest": "document",
    "Sec-Fetch-Mode": "navigate",
    "Sec-Fetch-Site": "none",
    "Sec-Fetch-User": "?1",
    "Sec-GPC": "1",
    "Upgrade-Insecure-Requests": "1",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36"
  };
}

// src/utils/localeUtils.ts
var faToAr = (value) => {
  return value.replace(/ی/g, "\u064A").replace(/ک/g, "\u0643").replace(/۰/g, "\u0660").replace(/۱/g, "\u0661").replace(/۲/g, "\u0662").replace(/۳/g, "\u0663").replace(/۴/g, "\u0664").replace(/۵/g, "\u0665").replace(/۶/g, "\u0666").replace(/۷/g, "\u0667").replace(/۸/g, "\u0668").replace(/۹/g, "\u0669");
};

// src/request.ts
import { trySafe } from "p-safe";
async function request(url, options = {}) {
  return trySafe(async () => {
    const response = await axios.request(
      deepmerge(
        {
          url,
          method: "GET",
          headers: {
            ...fakeBrowserHeaders(),
            Accept: "ext/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
            "X-Requested-With": "XMLHttpRequest"
          },
          timeout: 1e4
        },
        options
      )
    );
    return { data: response };
  });
}

// src/DayDetails/getPriceOverview.ts
import { trySafe as trySafe2 } from "p-safe";
async function getPriceOverviewData(params, options = {}) {
  return trySafe2(async () => {
    const { insId, dEven } = params;
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/ClosingPrice/GetClosingPriceDaily/${insId}/${dEven}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    const data = response.data["closingPriceDaily"];
    return {
      data: {
        priceChange: data["priceChange"],
        low: data["priceMin"],
        high: data["priceMax"],
        yesterday: data["priceYesterday"],
        open: data["priceFirst"],
        close: data["pClosing"],
        last: data["pDrCotVal"],
        count: data["zTotTran"],
        volume: data["qTotTran5J"],
        value: data["qTotCap"]
      }
    };
  });
}

// src/DayDetails/getOrderBook.ts
import { trySafe as trySafe3 } from "p-safe";
async function getOrderBook(params, options = {}) {
  return trySafe3(async () => {
    const { insId, dEven } = params;
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/BestLimits/${insId}/${dEven}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    const data = response.data["bestLimitsHistory"];
    data.sort((a, b) => {
      if (a["hEven"] === b["hEven"]) {
        return a["number"] - b["number"];
      }
      return a["hEven"] - b["hEven"];
    });
    let prevData = { buyRows: [], sellRows: [] };
    const hevenMap = {};
    for (const row of data) {
      const heven = row["hEven"];
      const t = even2JDate(dEven, heven);
      const buyRow = {
        time: t,
        count: row["zOrdMeDem"],
        price: row["pMeDem"],
        volume: row["qTitMeDem"]
      };
      const sellRow = {
        time: t,
        count: row["zOrdMeOf"],
        price: row["pMeOf"],
        volume: row["qTitMeOf"]
      };
      const index = row["number"] - 1;
      if (!(heven in hevenMap)) {
        hevenMap[heven] = { ...prevData };
      }
      while (hevenMap[heven].buyRows.length < index + 1) {
        hevenMap[heven].buyRows.push(null);
      }
      while (hevenMap[heven].sellRows.length < index + 1) {
        hevenMap[heven].sellRows.push(null);
      }
      hevenMap[heven].buyRows[index] = buyRow;
      hevenMap[heven].sellRows[index] = sellRow;
      prevData = hevenMap[heven];
    }
    return {
      data: Object.keys(hevenMap).map((key) => ({
        time: even2JDate(dEven, parseInt(key)),
        ...hevenMap[key]
      }))
    };
  });
}

// src/DayDetails/getPriceData.ts
import { trySafe as trySafe4 } from "p-safe";
async function getPriceData(params, options = {}) {
  return trySafe4(async () => {
    const { insId, dEven } = params;
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/ClosingPrice/GetClosingPriceHistory/${insId}/${dEven}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    const data = response.data["closingPriceHistory"];
    return {
      data: data.map((row) => ({
        time: even2JDate(dEven, row["hEven"]),
        close: row["pClosing"],
        last: row["pDrCotVal"],
        value: row["qTotCap"],
        volume: row["qTotTran5J"],
        count: row["zTotTran"]
      }))
    };
  });
}

// src/DayDetails/getTrades.ts
import { trySafe as trySafe5 } from "p-safe";
async function getTrades(params, options = {}) {
  return trySafe5(async () => {
    const { insId, dEven, summarize } = params;
    const summarizeStr = summarize ? "true" : "false";
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/Trade/GetTradeHistory/${insId}/${dEven}/${summarizeStr}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    const data = response.data["tradeHistory"];
    return {
      data: data.map((row) => ({
        time: even2JDate(dEven, Number(row["hEven"])),
        price: row["pTran"],
        volume: row["qTitTran"]
      }))
    };
  });
}

// src/DayDetails/getTradersType.ts
import { trySafe as trySafe6 } from "p-safe";
async function getTradersType(params, options = {}) {
  return trySafe6(async () => {
    const { insId, dEven } = params;
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/ClientType/GetClientTypeHistory/${insId}/${dEven}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("No Data") };
    const data = response.data["clientType"];
    return {
      data: {
        legal: {
          buy: {
            volume: data["buy_N_Volume"],
            value: data["buy_N_Value"],
            count: data["buy_N_Count"]
          },
          sell: {
            volume: data["sell_N_Volume"],
            value: data["sell_N_Value"],
            count: data["sell_N_Count"]
          }
        },
        real: {
          buy: {
            volume: data["buy_I_Volume"],
            value: data["buy_I_Value"],
            count: data["buy_I_Count"]
          },
          sell: {
            volume: data["sell_I_Volume"],
            value: data["sell_I_Value"],
            count: data["sell_I_Count"]
          }
        }
      }
    };
  });
}

// src/DayDetails/getSupervisionDetail.ts
import { trySafe as trySafe7 } from "p-safe";
import deepmerge2 from "deepmerge";
async function getSupervisionDetail(insId, options = {}) {
  return trySafe7(async () => {
    const { data: response, error } = await request(
      "http://old.tsetmc.com/tsev2/data/Supervision.aspx",
      deepmerge2(
        {
          params: {
            i: insId
          }
        },
        options
      )
    );
    if (error) {
      return { error };
    }
    if (!response || !response.data) {
      return { error: new Error("NoData") };
    }
    const [status, reason, description, date] = response.data.split("#");
    return {
      data: {
        status: UnderSupervision(status),
        reason,
        description,
        date: new Date(date)
      }
    };
  });
}
function UnderSupervision(status) {
  switch (status) {
    default:
    case "0":
      return "";
    case "1":
      return "\u0645\u0634\u0645\u0648\u0644 \u0641\u0631\u0622\u06CC\u0646\u062F \u062A\u0639\u0644\u06CC\u0642";
    case "2":
      return "\u0645\u0639\u0627\u0645\u0644\u0647 \u062A\u062D\u062A \u0627\u062D\u062A\u06CC\u0627\u0637";
    case "3":
      return "\u062A\u0639\u0644\u06CC\u0642 \u0634\u062F\u0647";
  }
}

// src/DayDetails/getShareholders.ts
import { trySafe as trySafe8 } from "p-safe";
async function getShareholders(params, options = {}) {
  return trySafe8(async () => {
    const { insId, dEven } = params;
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/Shareholder/${insId}/${dEven}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    const data = response.data["shareShareholder"];
    return {
      data: data.map((row) => ({
        date: even2JDate(dEven, row["dEven"]),
        shareholder: {
          id: row["shareHolderId"].toString(),
          name: row["shareHolderName"]
        },
        count: row["numberOfShares"],
        percentage: row["perOfShares"]
      }))
    };
  });
}

// src/DayDetails/getThresholds.ts
import { trySafe as trySafe9 } from "p-safe";
async function getThresholds(params, options = {}) {
  return trySafe9(async () => {
    const { insId, dEven } = params;
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/MarketData/GetStaticThreshold/${insId}/${dEven}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    const data = response.data["staticThreshold"];
    return {
      data: {
        rangeMax: Number(data[1].psGelStaMax),
        rangeMin: Number(data[1]?.psGelStaMin)
      }
    };
  });
}

// src/Group/index.ts
var Group_exports = {};
__export(Group_exports, {
  getAllGroups: () => getAllGroups
});

// src/Group/getAllGroups.ts
import { trySafe as trySafe10 } from "p-safe";
async function getAllGroups(options = {}) {
  return trySafe10(async () => {
    const { data: response, error } = await request(
      "http://cdn.tsetmc.com/api/StaticData/GetStaticData",
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    return {
      data: response.data["staticData"]
    };
  });
}
var GroupType = /* @__PURE__ */ ((GroupType2) => {
  GroupType2["PAPER"] = "PAPER";
  GroupType2["INDUSTRY"] = "INDUSTRIAL";
  return GroupType2;
})(GroupType || {});

// src/MarketMap/index.ts
var MarketMap_exports = {};
__export(MarketMap_exports, {
  getMarketMap: () => getMarketMap
});

// src/MarketMap/getMarketMap.ts
import { trySafe as trySafe11 } from "p-safe";
import deepmerge3 from "deepmerge";
async function getMarketMap(params, options = {}) {
  return trySafe11(async () => {
    const {
      mapType = 1 /* MarketValue */,
      hEven = 0,
      market = 0,
      sector = 0,
      size = 1920
    } = params;
    if (hEven !== 0 && !hEvenValidation(hEven)) {
      return { error: new Error("Invalid hEven") };
    }
    const { data: response, error } = await request(
      "http://cdn.tsetmc.com/api/ClosingPrice/GetMarketMap",
      deepmerge3(
        {
          params: {
            market,
            sector,
            size,
            typeSelected: mapType,
            hEven
          }
        },
        options
      )
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    return {
      data: response.data.map((row) => ({
        id: row["insCode"],
        shortName: row["lVal18AFC"],
        longName: row["lVal30"],
        close: row["pClosing"],
        last: row["pDrCotVal"],
        volume: row["qTotTran5J"],
        value: row["qTotCap"],
        count: row["zTotTran"],
        groupName: row["lSecVal"],
        color: row["color"],
        priceChangePercent: row["priceChangePercent"],
        percent: row["percent"]
      }))
    };
  });
}
var MapType = /* @__PURE__ */ ((MapType2) => {
  MapType2[MapType2["MarketValue"] = 1] = "MarketValue";
  MapType2[MapType2["MarketVolume"] = 2] = "MarketVolume";
  return MapType2;
})(MapType || {});

// src/MarketWatch/index.ts
var MarketWatch_exports = {};
__export(MarketWatch_exports, {
  getClientTypeAll: () => getClientTypeAll,
  getPriceData: () => getWatchPrice,
  getWatchStats: () => getWatchStats
});

// src/MarketWatch/getClientTypeAll.ts
import { trySafe as trySafe12 } from "p-safe";
async function getClientTypeAll() {
  return trySafe12(async () => {
    const response = await fetch("http://old.tsetmc.com/tsev2/data/ClientTypeAll.aspx");
    const text = await response.text();
    const watchData = {};
    const rows = text.split(";");
    for (const row of rows) {
      if (!row) {
        continue;
      }
      const [symbolId, r_buy_c, l_buy_c, r_buy_v, l_buy_v, r_sell_c, l_sell_c, r_sell_v, l_sell_v] = row.split(",");
      watchData[symbolId] = {
        legal: {
          buy: {
            volume: parseInt(l_buy_v),
            count: parseInt(l_buy_c)
          },
          sell: {
            volume: parseInt(l_sell_v),
            count: parseInt(l_sell_c)
          }
        },
        real: {
          buy: {
            volume: parseInt(r_buy_v),
            count: parseInt(r_buy_c)
          },
          sell: {
            volume: parseInt(r_sell_v),
            count: parseInt(r_sell_c)
          }
        }
      };
    }
    return { data: watchData };
  });
}

// src/MarketWatch/getPriceData.ts
import { trySafe as trySafe13 } from "p-safe";
import deepmerge4 from "deepmerge";
async function getWatchPrice(params, options = {}) {
  return trySafe13(async () => {
    const { refId = 0, hEven = 0 } = params || {};
    const { data: response, error } = await request(
      "http://old.tsetmc.com/tsev2/data/MarketWatchPlus.aspx",
      deepmerge4(
        {
          params: {
            h: hEven,
            r: refId
          }
        },
        options
      )
    );
    if (error)
      return { error };
    if (!response || !response.data)
      return { error: new Error("NoData") };
    const data = response.data;
    const sections = data.split("@");
    let maxHeven = 0;
    const watchData = {};
    const rows = sections[2].split(";");
    for (const row of rows) {
      if (!row)
        continue;
      const cols = row.split(",");
      if (cols.length === 0 || cols.length === 10)
        continue;
      const symbolId = cols[0];
      const heven = parseInt(cols[4]);
      watchData[symbolId] = {
        symbolId: cols[0],
        isin: cols[1],
        shortName: cols[2],
        fullName: cols[3],
        heven: parseInt(cols[4]),
        open: parseInt(cols[5]),
        close: parseInt(cols[6]),
        last: parseInt(cols[7]),
        count: parseInt(cols[8]),
        volume: parseInt(cols[9]),
        value: parseInt(cols[10]),
        low: parseInt(cols[11]),
        high: parseInt(cols[12]),
        yesterday: parseInt(cols[13]),
        eps: parseInt(cols[14]) || null,
        baseVolume: parseInt(cols[15]),
        visitCount: parseInt(cols[16]),
        flow: parseInt(cols[17]),
        group: parseInt(cols[18]),
        rangeMax: parseInt(cols[19]),
        rangeMin: parseInt(cols[20]),
        z: parseInt(cols[21]),
        yval: parseInt(cols[22]),
        orderbook: {
          buyRows: [],
          sellRows: []
        }
      };
      if (heven > maxHeven) {
        maxHeven = heven;
      }
    }
    const orderbookRows = sections[3].split(";");
    for (const row of orderbookRows) {
      if (!row) {
        continue;
      }
      const [symbolId, rank, sCount, bCount, bPrice, sPrice, bVolume, sVolume] = row.split(",");
      const orderbook = watchData[symbolId].orderbook || {
        buyRows: [],
        sellRows: []
      };
      orderbook.buyRows[rank] = {
        count: parseInt(bCount),
        price: parseInt(bPrice),
        volume: parseInt(bVolume)
      };
      orderbook.sellRows[rank] = {
        count: parseInt(sCount),
        price: parseInt(sPrice),
        volume: parseInt(sVolume)
      };
      watchData[symbolId].orderbook = orderbook;
    }
    const result = [];
    for (const key in watchData) {
      const dataRow = watchData[key];
      if (!dataRow.symbolId) {
        continue;
      }
      const orderbook = watchData[key].orderbook || {
        buyRows: [],
        sellRows: []
      };
      result.push({
        symbolId: watchData[key].symbolId,
        isin: watchData[key].isin,
        shortName: watchData[key].shortName,
        fullName: watchData[key].fullName,
        heven: watchData[key].heven,
        open: watchData[key].open,
        close: watchData[key].close,
        last: watchData[key].last,
        count: watchData[key].count,
        volume: watchData[key].volume,
        value: watchData[key].value,
        low: watchData[key].low,
        high: watchData[key].high,
        yesterday: watchData[key].yesterday,
        eps: watchData[key].eps,
        baseVolume: watchData[key].baseVolume,
        visitCount: watchData[key].visitCount,
        flow: watchData[key].flow,
        group: watchData[key].group,
        rangeMax: watchData[key].rangeMax,
        rangeMin: watchData[key].rangeMin,
        z: watchData[key].z,
        yval: watchData[key].yval,
        orderbook: {
          buyRows: Object.values(orderbook.buyRows),
          sellRows: Object.values(orderbook.sellRows)
        }
      });
    }
    return { data: result };
  });
}

// src/MarketWatch/getWatchStats.ts
import { trySafe as trySafe14 } from "p-safe";
var STATS_TRADES_INDICES = /* @__PURE__ */ ((STATS_TRADES_INDICES2) => {
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_value_3_month"] = 0] = "average_value_3_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_value_12_month"] = 1] = "average_value_12_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_value_rank_3_month"] = 2] = "average_value_rank_3_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_value_rank_12_month"] = 3] = "average_value_rank_12_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_volume_3_month"] = 4] = "average_volume_3_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_volume_12_month"] = 5] = "average_volume_12_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_volume_rank_3_month"] = 6] = "average_volume_rank_3_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_volume_rank_12_month"] = 7] = "average_volume_rank_12_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_count_3_month"] = 8] = "average_count_3_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_count_12_month"] = 9] = "average_count_12_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_count_rank_3_month"] = 10] = "average_count_rank_3_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_count_rank_12_month"] = 11] = "average_count_rank_12_month";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_price_no_base_last_day"] = 12] = "average_price_no_base_last_day";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["average_price_with_base_last_day"] = 13] = "average_price_with_base_last_day";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["value_last_day"] = 14] = "value_last_day";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["volume_last_day"] = 15] = "volume_last_day";
  STATS_TRADES_INDICES2[STATS_TRADES_INDICES2["count_last_day"] = 16] = "count_last_day";
  return STATS_TRADES_INDICES2;
})(STATS_TRADES_INDICES || {});
var STATS_NEGATIVE_DAYS_INDICES = /* @__PURE__ */ ((STATS_NEGATIVE_DAYS_INDICES2) => {
  STATS_NEGATIVE_DAYS_INDICES2[STATS_NEGATIVE_DAYS_INDICES2["days_count_3_month"] = 18] = "days_count_3_month";
  STATS_NEGATIVE_DAYS_INDICES2[STATS_NEGATIVE_DAYS_INDICES2["days_count_12_month"] = 19] = "days_count_12_month";
  STATS_NEGATIVE_DAYS_INDICES2[STATS_NEGATIVE_DAYS_INDICES2["days_percent_3_month"] = 20] = "days_percent_3_month";
  STATS_NEGATIVE_DAYS_INDICES2[STATS_NEGATIVE_DAYS_INDICES2["days_percent_12_month"] = 21] = "days_percent_12_month";
  STATS_NEGATIVE_DAYS_INDICES2[STATS_NEGATIVE_DAYS_INDICES2["days_rank_3_month"] = 22] = "days_rank_3_month";
  STATS_NEGATIVE_DAYS_INDICES2[STATS_NEGATIVE_DAYS_INDICES2["days_rank_12_month"] = 23] = "days_rank_12_month";
  return STATS_NEGATIVE_DAYS_INDICES2;
})(STATS_NEGATIVE_DAYS_INDICES || {});
var STATS_NO_TRADE_DAYS_INDICES = /* @__PURE__ */ ((STATS_NO_TRADE_DAYS_INDICES2) => {
  STATS_NO_TRADE_DAYS_INDICES2[STATS_NO_TRADE_DAYS_INDICES2["days_count_3_month"] = 24] = "days_count_3_month";
  STATS_NO_TRADE_DAYS_INDICES2[STATS_NO_TRADE_DAYS_INDICES2["days_count_12_month"] = 25] = "days_count_12_month";
  return STATS_NO_TRADE_DAYS_INDICES2;
})(STATS_NO_TRADE_DAYS_INDICES || {});
var STATS_POSITIVE_DAYS_INDICES = /* @__PURE__ */ ((STATS_POSITIVE_DAYS_INDICES2) => {
  STATS_POSITIVE_DAYS_INDICES2[STATS_POSITIVE_DAYS_INDICES2["days_count_3_month"] = 26] = "days_count_3_month";
  STATS_POSITIVE_DAYS_INDICES2[STATS_POSITIVE_DAYS_INDICES2["days_count_12_month"] = 27] = "days_count_12_month";
  STATS_POSITIVE_DAYS_INDICES2[STATS_POSITIVE_DAYS_INDICES2["days_percent_3_month"] = 28] = "days_percent_3_month";
  STATS_POSITIVE_DAYS_INDICES2[STATS_POSITIVE_DAYS_INDICES2["days_percent_12_month"] = 29] = "days_percent_12_month";
  STATS_POSITIVE_DAYS_INDICES2[STATS_POSITIVE_DAYS_INDICES2["days_rank_3_month"] = 30] = "days_rank_3_month";
  STATS_POSITIVE_DAYS_INDICES2[STATS_POSITIVE_DAYS_INDICES2["days_rank_12_month"] = 31] = "days_rank_12_month";
  return STATS_POSITIVE_DAYS_INDICES2;
})(STATS_POSITIVE_DAYS_INDICES || {});
var STATS_WITH_TRADE_DAYS_INDICES = /* @__PURE__ */ ((STATS_WITH_TRADE_DAYS_INDICES2) => {
  STATS_WITH_TRADE_DAYS_INDICES2[STATS_WITH_TRADE_DAYS_INDICES2["days_count_3_month"] = 32] = "days_count_3_month";
  STATS_WITH_TRADE_DAYS_INDICES2[STATS_WITH_TRADE_DAYS_INDICES2["days_count_12_month"] = 33] = "days_count_12_month";
  STATS_WITH_TRADE_DAYS_INDICES2[STATS_WITH_TRADE_DAYS_INDICES2["days_rank_3_month"] = 34] = "days_rank_3_month";
  STATS_WITH_TRADE_DAYS_INDICES2[STATS_WITH_TRADE_DAYS_INDICES2["days_rank_12_month"] = 35] = "days_rank_12_month";
  return STATS_WITH_TRADE_DAYS_INDICES2;
})(STATS_WITH_TRADE_DAYS_INDICES || {});
var STATS_COMPANY_VALUE_INDICES = /* @__PURE__ */ ((STATS_COMPANY_VALUE_INDICES2) => {
  STATS_COMPANY_VALUE_INDICES2[STATS_COMPANY_VALUE_INDICES2["total_value"] = 36] = "total_value";
  STATS_COMPANY_VALUE_INDICES2[STATS_COMPANY_VALUE_INDICES2["total_value_rank"] = 37] = "total_value_rank";
  return STATS_COMPANY_VALUE_INDICES2;
})(STATS_COMPANY_VALUE_INDICES || {});
var STATS_OPEN_DAYS_INDICES = /* @__PURE__ */ ((STATS_OPEN_DAYS_INDICES2) => {
  STATS_OPEN_DAYS_INDICES2[STATS_OPEN_DAYS_INDICES2["days_count_3_month"] = 38] = "days_count_3_month";
  STATS_OPEN_DAYS_INDICES2[STATS_OPEN_DAYS_INDICES2["days_count_12_month"] = 39] = "days_count_12_month";
  STATS_OPEN_DAYS_INDICES2[STATS_OPEN_DAYS_INDICES2["days_percent_3_month"] = 40] = "days_percent_3_month";
  STATS_OPEN_DAYS_INDICES2[STATS_OPEN_DAYS_INDICES2["days_percent_12_month"] = 41] = "days_percent_12_month";
  STATS_OPEN_DAYS_INDICES2[STATS_OPEN_DAYS_INDICES2["days_rank_3_month"] = 42] = "days_rank_3_month";
  STATS_OPEN_DAYS_INDICES2[STATS_OPEN_DAYS_INDICES2["days_rank_12_month"] = 43] = "days_rank_12_month";
  return STATS_OPEN_DAYS_INDICES2;
})(STATS_OPEN_DAYS_INDICES || {});
var STATS_CLOSED_DAYS_INDICES = /* @__PURE__ */ ((STATS_CLOSED_DAYS_INDICES2) => {
  STATS_CLOSED_DAYS_INDICES2[STATS_CLOSED_DAYS_INDICES2["days_count_3_month"] = 38] = "days_count_3_month";
  STATS_CLOSED_DAYS_INDICES2[STATS_CLOSED_DAYS_INDICES2["days_count_12_month"] = 39] = "days_count_12_month";
  STATS_CLOSED_DAYS_INDICES2[STATS_CLOSED_DAYS_INDICES2["days_percent_3_month"] = 40] = "days_percent_3_month";
  STATS_CLOSED_DAYS_INDICES2[STATS_CLOSED_DAYS_INDICES2["days_percent_12_month"] = 41] = "days_percent_12_month";
  STATS_CLOSED_DAYS_INDICES2[STATS_CLOSED_DAYS_INDICES2["days_rank_3_month"] = 42] = "days_rank_3_month";
  STATS_CLOSED_DAYS_INDICES2[STATS_CLOSED_DAYS_INDICES2["days_rank_12_month"] = 43] = "days_rank_12_month";
  return STATS_CLOSED_DAYS_INDICES2;
})(STATS_CLOSED_DAYS_INDICES || {});
var STATS_CLIENT_TYPE_INDICES = /* @__PURE__ */ ((STATS_CLIENT_TYPE_INDICES2) => {
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["days_count_3_month"] = 44] = "days_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["days_count_12_month"] = 45] = "days_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["days_percent_3_month"] = 46] = "days_percent_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["days_percent_12_month"] = 47] = "days_percent_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["days_rank_3_month"] = 48] = "days_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["days_rank_12_month"] = 49] = "days_rank_12_month";
  return STATS_CLIENT_TYPE_INDICES2;
})(STATS_CLIENT_TYPE_INDICES || {});
var STATS_CLIENT_TYPE_INDICES = /* @__PURE__ */ ((STATS_CLIENT_TYPE_INDICES2) => {
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_volume_3_month"] = 50] = "individual_buy_average_volume_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_volume_12_month"] = 51] = "individual_buy_average_volume_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_volume_rank_3_month"] = 52] = "individual_buy_average_volume_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_volume_rank_12_month"] = 53] = "individual_buy_average_volume_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_volume_3_month"] = 54] = "legal_buy_average_volume_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_volume_12_month"] = 55] = "legal_buy_average_volume_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_volume_rank_3_month"] = 56] = "legal_buy_average_volume_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_volume_rank_12_month"] = 57] = "legal_buy_average_volume_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_count_3_month"] = 58] = "individual_buy_average_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_count_12_month"] = 59] = "individual_buy_average_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_count_rank_3_month"] = 60] = "individual_buy_average_count_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_buy_average_count_rank_12_month"] = 61] = "individual_buy_average_count_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_count_3_month"] = 62] = "legal_buy_average_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_count_12_month"] = 63] = "legal_buy_average_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_count_rank_3_month"] = 64] = "legal_buy_average_count_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_buy_average_count_rank_12_month"] = 65] = "legal_buy_average_count_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_buy_average_count_3_month"] = 66] = "total_buy_average_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_buy_average_count_12_month"] = 67] = "total_buy_average_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_buy_average_count_rank_3_month"] = 68] = "total_buy_average_count_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_buy_average_count_rank_12_month"] = 69] = "total_buy_average_count_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_volume_3_month"] = 70] = "individual_sell_average_volume_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_volume_12_month"] = 71] = "individual_sell_average_volume_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_volume_rank_3_month"] = 72] = "individual_sell_average_volume_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_volume_rank_12_month"] = 73] = "individual_sell_average_volume_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_volume_3_month"] = 74] = "legal_sell_average_volume_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_volume_12_month"] = 75] = "legal_sell_average_volume_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_volume_rank_3_month"] = 76] = "legal_sell_average_volume_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_volume_rank_12_month"] = 77] = "legal_sell_average_volume_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_count_3_month"] = 78] = "individual_sell_average_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_count_12_month"] = 79] = "individual_sell_average_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_count_rank_3_month"] = 80] = "individual_sell_average_count_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["individual_sell_average_count_rank_12_month"] = 81] = "individual_sell_average_count_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_count_3_month"] = 82] = "legal_sell_average_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_count_12_month"] = 83] = "legal_sell_average_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_count_rank_3_month"] = 84] = "legal_sell_average_count_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["legal_sell_average_count_rank_12_month"] = 85] = "legal_sell_average_count_rank_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_sell_average_count_3_month"] = 86] = "total_sell_average_count_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_sell_average_count_12_month"] = 87] = "total_sell_average_count_12_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_sell_average_count_rank_3_month"] = 88] = "total_sell_average_count_rank_3_month";
  STATS_CLIENT_TYPE_INDICES2[STATS_CLIENT_TYPE_INDICES2["total_sell_average_count_rank_12_month"] = 89] = "total_sell_average_count_rank_12_month";
  return STATS_CLIENT_TYPE_INDICES2;
})(STATS_CLIENT_TYPE_INDICES || {});
async function getWatchStatsRaw(options = {}) {
  return trySafe14(async () => {
    const { data: response, error } = await request(
      "http://old.tsetmc.com/tsev2/data/InstValue.aspx?t=a",
      options
    );
    if (error)
      return { error };
    if (!response || !response.data)
      return { error: new Error("No data") };
    const watchData = {};
    const sections = response.data.split(";");
    let symbolId = "NaN";
    sections.forEach((section) => {
      let row = section.split(",");
      if (row.length === 3) {
        symbolId = row[0];
        watchData[symbolId] = {};
        row = row.slice(1);
      }
      if (symbolId === "NaN" || !row[1]) {
        return;
      }
      const dataKey = parseInt(row[0]);
      watchData[symbolId][dataKey] = row[1].includes(".") ? parseFloat(row[1]) : parseInt(row[1]);
    });
    return { data: watchData };
  });
}
async function getWatchStats(options = {}) {
  return trySafe14(async () => {
    const { data, error } = await getWatchStatsRaw(options);
    if (error)
      return { error };
    if (!data)
      return { error: new Error("No data") };
    const watchData = {};
    Object.keys(data).forEach((symbolId) => {
      const symbolData = data[symbolId];
      const symbolStats = {
        trades: null,
        negative_days: null,
        no_trade_days: null,
        positive_days: null,
        with_trade_days: null,
        company_value: null,
        open_days: null,
        closed_days: null,
        client_type: null
      };
      Object.keys(symbolData).forEach((dataKey) => {
        const numKey = parseInt(dataKey);
        if (numKey in STATS_TRADES_INDICES) {
          if (!symbolStats.trades)
            symbolStats.trades = {};
          symbolStats.trades[STATS_TRADES_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_NEGATIVE_DAYS_INDICES) {
          if (!symbolStats.negative_days)
            symbolStats.negative_days = {};
          symbolStats.negative_days[STATS_NEGATIVE_DAYS_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_NO_TRADE_DAYS_INDICES) {
          if (!symbolStats.no_trade_days)
            symbolStats.no_trade_days = {};
          symbolStats.no_trade_days[STATS_NO_TRADE_DAYS_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_POSITIVE_DAYS_INDICES) {
          if (!symbolStats.positive_days)
            symbolStats.positive_days = {};
          symbolStats.positive_days[STATS_POSITIVE_DAYS_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_WITH_TRADE_DAYS_INDICES) {
          if (!symbolStats.with_trade_days)
            symbolStats.with_trade_days = {};
          symbolStats.with_trade_days[STATS_WITH_TRADE_DAYS_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_COMPANY_VALUE_INDICES) {
          if (!symbolStats.company_value)
            symbolStats.company_value = {};
          symbolStats.company_value[STATS_COMPANY_VALUE_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_OPEN_DAYS_INDICES) {
          if (!symbolStats.open_days)
            symbolStats.open_days = {};
          symbolStats.open_days[STATS_OPEN_DAYS_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_CLOSED_DAYS_INDICES) {
          if (!symbolStats.closed_days)
            symbolStats.closed_days = {};
          symbolStats.closed_days[STATS_CLOSED_DAYS_INDICES[numKey]] = symbolData[numKey];
        }
        if (numKey in STATS_CLIENT_TYPE_INDICES) {
          if (!symbolStats.client_type)
            symbolStats.client_type = {};
          symbolStats.client_type[STATS_CLIENT_TYPE_INDICES[numKey]] = symbolData[numKey];
        }
      });
      watchData[symbolId] = symbolStats;
    });
    return { data: watchData };
  });
}

// src/Instrument/index.ts
var Instrument_exports = {};
__export(Instrument_exports, {
  getBoardMembersHistory: () => getBoardMembersHistory,
  getDPSData: () => getDPSData,
  getInstrumentInfo: () => getInstrumentInfo,
  getIntraDayPriceChart: () => getIntraDayPriceChart,
  getSupervisorMsg: () => getSupervisorMsg
});

// src/Instrument/getBoardMembersHistory.ts
import { trySafe as trySafe15 } from "p-safe";
import deepmerge5 from "deepmerge";
async function getBoardMembersHistory(params, options = {}) {
  return trySafe15(async () => {
    const { data: response, error } = await request(
      "http://old.tsetmc.com/tsev2/data/CodalContent.aspx",
      deepmerge5(
        {
          params: {
            s: faToAr(params.symbol),
            r: "12"
          }
        },
        options
      )
    );
    if (error) {
      return { error };
    }
    if (!response || !response.data) {
      return { error: new Error("NoData") };
    }
    const data = String(response.data).replace(/([^\\])?'/gm, '$1"');
    const ds = JSON.parse(data);
    const result = [];
    for (const item of ds) {
      if (item[4].Root.AssemblyDate) {
        result.push({
          type: "BoardMembers",
          AssemblyDate: item[4].Root.AssemblyDate,
          SessionDate: item[4].Root.BoardMembersSessionDate,
          BoardMembers: item[4].Root.BoardMembers.BoardMember.map((member) => ({
            ...member,
            Charged: member.Charged === "\u0645\u0648\u0638\u0641" || member.Charged === "True"
          }))
        });
      }
      if (item[4].Root.DirectorManager) {
        result.push({
          type: "DirectorManager",
          MeetingDate: item[1],
          SessionDate: item[2],
          DirectorManager: {
            Name: item[4].Root.DirectorManager.DirectorManagerName,
            NationalCode: item[4].Root.DirectorManager.DirectorManagerNationalCode,
            EducationDegree: item[4].Root.DirectorManager.DirectorManagerEducationDegree
          }
        });
      }
    }
    return { data: result };
  });
}

// src/Instrument/getDPSData.ts
import { trySafe as trySafe16 } from "p-safe";
import deepmerge6 from "deepmerge";
async function getDPSData(params, options = {}) {
  return trySafe16(async () => {
    const { data: response, error } = await request(
      "http://old.tsetmc.com/tsev2/data/DPSData.aspx",
      deepmerge6(
        {
          params: {
            s: faToAr(params.symbol)
          }
        },
        options
      )
    );
    if (error) {
      return { error };
    }
    if (!response || !response.data) {
      return { error: new Error("NoData") };
    }
    const rows = response.data.split(";");
    const result = [];
    for (const row of rows) {
      const [
        publishDate,
        meetingDate,
        fiscalYear,
        profitAfterTax,
        profitToAllocate,
        profitAccumulated,
        cashProfitPerShare
      ] = row.split("@");
      result.push({
        publishDate,
        meetingDate,
        fiscalYear,
        profitAfterTax,
        profitToAllocate,
        profitAccumulated,
        cashProfitPerShare
      });
    }
    return { data: result };
  });
}

// src/Instrument/getInstrumentInfo.ts
import { trySafe as trySafe17 } from "p-safe";
async function getInstrumentInfo(params, options = {}) {
  return trySafe17(async () => {
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/Instrument/GetInstrumentInfo/${params.insId}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    return { data: response.data["instrumentInfo"] };
  });
}

// src/Instrument/getSupervisorMsg.ts
import { trySafe as trySafe18 } from "p-safe";
async function getSupervisorMsg(params, options = {}) {
  return trySafe18(async () => {
    const { data: response, error } = await request(
      `http://cdn.tsetmc.com/api/Msg/GetMsgByInsCode/${params.insId}`,
      options
    );
    if (error)
      return { error };
    if (!response)
      return { error: new Error("NoData") };
    return {
      data: response.data["msg"].map((row) => ({
        id: row["tseMsgIdn"],
        dEven: row["dEven"],
        hEven: row["hEven"],
        title: row["tseTitle"],
        description: row["tseDesc"],
        flow: row["flow"]
      }))
    };
  });
}

// src/Instrument/getIntraDayPriceChart.ts
import { trySafe as trySafe19 } from "p-safe";
import deepmerge7 from "deepmerge";
async function getIntraDayPriceChart(params, options = {}) {
  return trySafe19(async () => {
    const { data: response, error } = await request(
      "http://old.tsetmc.com/tsev2/chart/data/IntraDayPrice.aspx",
      deepmerge7(
        {
          params: {
            i: params.insId
          }
        },
        options
      )
    );
    if (error) {
      return { error };
    }
    if (!response || !response.data) {
      return { error: new Error("NoData") };
    }
    const ticks = response.data.split(";");
    if (!Array.isArray(ticks) || ticks.length === 0) {
      return { error: new Error("MalformedData") };
    }
    const result = [];
    for (const tick of ticks) {
      const [time, high, low, open, close, volume] = tick.split(",");
      const [hour, minute] = time.split(":");
      result.push({
        time: new Date(Date.UTC(2010, 1, 1, parseInt(hour), parseInt(minute))),
        high: parseInt(high),
        low: parseInt(low),
        open: parseInt(open),
        close: parseInt(close),
        volume: parseInt(volume)
      });
    }
    return { data: result };
  });
}

// src/index.ts
var TseTmc = { DayDetails: DayDetails_exports, Group: Group_exports, MarketMap: MarketMap_exports, MarketWatch: MarketWatch_exports, Instrument: Instrument_exports };
var src_default = TseTmc;
export {
  DayDetails_exports as DayDetails,
  Group_exports as Group,
  GroupType,
  Instrument_exports as Instrument,
  MapType,
  MarketMap_exports as MarketMap,
  MarketWatch_exports as MarketWatch,
  TseTmc,
  src_default as default,
  utils_exports as utils
};