@stocksharp/trading-controls 0.1.0

package/dist/sstradingcontrols.js

@@ -0,0 +1,1740 @@
+"use strict";
+var SSTradingControls = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    ActiveOrdersWidget: () => ActiveOrdersWidget,
+    ControlTypes: () => ControlTypes,
+    MarketDataLevels: () => MarketDataLevels,
+    OrderStates: () => OrderStates,
+    PRESENTATION_CLASSES: () => PRESENTATION_CLASSES,
+    PositionsWidget: () => PositionsWidget,
+    TradeHistoryWidget: () => TradeHistoryWidget,
+    WatchlistWidget: () => WatchlistWidget,
+    assertHost: () => assertHost,
+    cleanRejectReason: () => cleanRejectReason,
+    formatPnl: () => formatPnl,
+    formatPrice: () => formatPrice,
+    formatQty: () => formatQty,
+    formatTime: () => formatTime,
+    makeElement: () => makeElement,
+    makeIcon: () => makeIcon,
+    makeIconButton: () => makeIconButton,
+    makePanelId: () => makePanelId,
+    makePanelRoot: () => makePanelRoot
+  });
+
+  // src/trading-host.ts
+  var PRESENTATION_CLASSES = {
+    sideClass: ["side-buy", "side-sell"],
+    pnlClass: ["pnl-positive", "pnl-negative"]
+  };
+  var MarketDataLevels = {
+    /// Level 1 only: best bid/ask and last price.
+    Quotes: "l1only",
+    /// Level 1 plus every tick.
+    Tape: "tape",
+    /// Level 1, ticks and market depth.
+    Full: "full"
+  };
+  function assertHost(host, controlName) {
+    _required(host, "host", "object", controlName);
+    _required(host.isPrimary, "host.isPrimary", "boolean", controlName);
+    _required(host.t, "host.t", "function", controlName);
+    _required(host.presentation, "host.presentation", "object", controlName);
+    _required(host.presentation.sideText, "host.presentation.sideText", "function", controlName);
+    _required(host.presentation.typeText, "host.presentation.typeText", "function", controlName);
+    _required(host.presentation.statusText, "host.presentation.statusText", "function", controlName);
+    _required(host.presentation.sideClass, "host.presentation.sideClass", "function", controlName);
+    _required(host.presentation.pnlClass, "host.presentation.pnlClass", "function", controlName);
+    _required(host.preferences, "host.preferences", "object", controlName);
+    _required(host.preferences.get, "host.preferences.get", "function", controlName);
+    _required(host.preferences.set, "host.preferences.set", "function", controlName);
+    _required(host.cache, "host.cache", "object", controlName);
+    _required(host.cache.get, "host.cache.get", "function", controlName);
+    _required(host.cache.set, "host.cache.set", "function", controlName);
+    _required(host.trading, "host.trading", "object", controlName);
+    _required(host.trading.api, "host.trading.api", "object", controlName);
+    _required(host.trading.api.getExecutions, "host.trading.api.getExecutions", "function", controlName);
+    _required(host.trading.api.searchInstruments, "host.trading.api.searchInstruments", "function", controlName);
+    _required(host.trading.marketData, "host.trading.marketData", "object", controlName);
+    _required(host.trading.marketData.addSymbol, "host.trading.marketData.addSymbol", "function", controlName);
+    _required(host.trading.marketData.removeSymbol, "host.trading.marketData.removeSymbol", "function", controlName);
+    _required(host.trading.marketData.resubscribe, "host.trading.marketData.resubscribe", "function", controlName);
+    _required(host.trading.marketData.getOrders, "host.trading.marketData.getOrders", "function", controlName);
+    _required(host.trading.portfolioId, "host.trading.portfolioId", "function", controlName);
+    _required(host.trading.pickInstrument, "host.trading.pickInstrument", "function", controlName);
+    _required(host.ticker, "host.ticker", "object", controlName);
+    _required(host.ticker.publish, "host.ticker.publish", "function", controlName);
+    _required(host.allow, "host.allow", "function", controlName);
+    _required(host.log, "host.log", "function", controlName);
+    _required(host.close, "host.close", "function", controlName);
+    _required(host.spawn, "host.spawn", "function", controlName);
+    _required(host.persistState, "host.persistState", "function", controlName);
+    _required(host.saveLayout, "host.saveLayout", "function", controlName);
+    _required(host.register, "host.register", "function", controlName);
+    _required(host.unregister, "host.unregister", "function", controlName);
+    _required(host.broadcast, "host.broadcast", "function", controlName);
+    return host;
+  }
+  function _required(value, path, kind, controlName) {
+    if (value === null || value === void 0 || typeof value !== kind)
+      throw new Error(`${controlName}: ${path} is required`);
+  }
+
+  // src/control-types.ts
+  var ControlTypes = {
+    Watchlist: "watchlist",
+    ActiveOrders: "activeOrders",
+    TradeHistory: "tradeHistory",
+    Positions: "positions"
+  };
+
+  // src/formatters.ts
+  function formatPrice(price) {
+    if (price == null || isNaN(Number(price))) return "--";
+    const n = Number(price);
+    const a = Math.abs(n);
+    let prec = 2;
+    if (a < 1) prec = 4;
+    if (a < 0.1) prec = 5;
+    if (a < 1e-3) prec = 6;
+    if (a >= 1e3) prec = 1;
+    if (a >= 1e4) prec = 0;
+    return n.toFixed(prec);
+  }
+  function formatQty(qty) {
+    if (qty == null) return "--";
+    const n = Number(qty);
+    if (!isFinite(n)) return "--";
+    return n.toLocaleString(void 0, { maximumFractionDigits: 8 });
+  }
+  function formatTime(dateStr) {
+    const d = new Date(dateStr);
+    return d.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  }
+  function formatPnl(pnl) {
+    if (pnl == null) return "--";
+    const val = Number(pnl);
+    const sign = val >= 0 ? "+" : "";
+    return sign + val.toFixed(2);
+  }
+  function cleanRejectReason(reason) {
+    if (!reason) return "";
+    const i = reason.indexOf("{");
+    const j = reason.lastIndexOf("}");
+    if (i >= 0 && j > i) {
+      try {
+        const parsed = JSON.parse(reason.substring(i, j + 1));
+        if (parsed && typeof parsed.message === "string" && parsed.message.length > 0)
+          return parsed.message;
+      } catch {
+      }
+    }
+    return reason;
+  }
+
+  // src/dom.ts
+  function makeElement(tag, className, attrs, children) {
+    const element = document.createElement(tag);
+    if (className) element.className = className;
+    for (const [name, value] of Object.entries(attrs)) element.setAttribute(name, value);
+    for (const child of children)
+      element.appendChild(typeof child === "string" ? document.createTextNode(child) : child);
+    return element;
+  }
+  function makeIcon(iconClass) {
+    return makeElement("i", `bi ${iconClass}`, {}, []);
+  }
+  function makeIconButton(className, label, iconClass, attrs) {
+    return makeElement(
+      "button",
+      className,
+      { title: label, "aria-label": label, ...attrs },
+      [makeIcon(iconClass)]
+    );
+  }
+  function makePanelRoot(modifierClass, label, children) {
+    return makeElement("div", `terminal-panel ${modifierClass}`, { role: "region", "aria-label": label }, children);
+  }
+  function makePanelId(type) {
+    return `panel-${type}-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e3).toString(36)}`;
+  }
+
+  // node_modules/@stocksharp/grids/src/table-sort.ts
+  var SortDirections = {
+    Asc: "asc",
+    Desc: "desc"
+  };
+  function readByKey(row, key) {
+    return row === null || row === void 0 ? void 0 : row[key];
+  }
+  var TableSort = class _TableSort {
+    // `defaultSort` is the order applied when no header is explicitly selected — the table's
+    // resting sort. Pass null only for a table that genuinely has no meaningful default (raw row
+    // order); every real blotter should name one so its first paint is deterministic.
+    constructor(headerEl, accessors, onChange, defaultSort) {
+      __publicField(this, "col");
+      __publicField(this, "dir");
+      __publicField(this, "_headerEl");
+      __publicField(this, "_accessors");
+      __publicField(this, "_onChange");
+      __publicField(this, "_default");
+      this.col = null;
+      this.dir = SortDirections.Asc;
+      this._headerEl = headerEl;
+      this._accessors = accessors || {};
+      this._onChange = onChange;
+      this._default = defaultSort;
+      this._updateHeader();
+      headerEl?.addEventListener("click", (e) => {
+        const tgt = e.target;
+        const th = tgt?.closest("[data-sort]");
+        if (!th) return;
+        const col = th.dataset.sort;
+        if (this.col !== col) {
+          this.col = col;
+          this.dir = SortDirections.Asc;
+        } else if (this.dir === SortDirections.Asc) this.dir = SortDirections.Desc;
+        else {
+          this.col = null;
+          this.dir = SortDirections.Asc;
+        }
+        this._updateHeader();
+        this._onChange();
+      });
+    }
+    // The order actually in effect: the explicitly-picked column, else the table's default.
+    _effective() {
+      return this.col ? { col: this.col, dir: this.dir } : this._default;
+    }
+    /**
+     * Sorted copy of rows by the effective sort (explicit column or table default). Rows with no
+     * value for the sort column group at the end. Always a copy: a caller told its array is never
+     * reordered must be able to rely on that for one row and no sort as much as for a sorted many.
+     */
+    apply(rows) {
+      if (!Array.isArray(rows)) return rows;
+      const eff = this._effective();
+      if (!eff || rows.length < 2) return [...rows];
+      const col = eff.col;
+      const acc = this._accessors[col] || ((r) => readByKey(r, col));
+      const factor = eff.dir === SortDirections.Asc ? 1 : -1;
+      return [...rows].sort((a, b) => {
+        const av = acc(a);
+        const bv = acc(b);
+        const aEmpty = av === null || av === void 0 || av === "";
+        const bEmpty = bv === null || bv === void 0 || bv === "";
+        if (aEmpty && bEmpty) return 0;
+        if (aEmpty) return 1;
+        if (bEmpty) return -1;
+        return _TableSort._compare(av, bv) * factor;
+      });
+    }
+    static _compare(a, b) {
+      const an = typeof a === "number" ? a : Number(a);
+      const bn = typeof b === "number" ? b : Number(b);
+      if (isFinite(an) && isFinite(bn)) return an - bn;
+      return String(a).localeCompare(String(b));
+    }
+    _updateHeader() {
+      if (!this._headerEl) return;
+      const eff = this._effective();
+      this._headerEl.querySelectorAll("[data-sort]").forEach((el) => {
+        const th = el;
+        const active = !!eff && eff.col === th.dataset.sort;
+        th.classList.toggle("sort-asc", active && eff.dir === SortDirections.Asc);
+        th.classList.toggle("sort-desc", active && eff.dir === SortDirections.Desc);
+      });
+    }
+  };
+
+  // node_modules/@stocksharp/grids/src/table-export.ts
+  var XML_DECL = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r\n';
+  var CONTENT_TYPES = XML_DECL + '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/></Types>';
+  var ROOT_RELS = XML_DECL + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>';
+  var WORKBOOK_RELS = XML_DECL + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/></Relationships>';
+  function workbookXml(sheetName) {
+    return XML_DECL + `<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="${escapeXml(sheetName)}" sheetId="1" r:id="rId1"/></sheets></workbook>`;
+  }
+  function escapeXml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  function colRef(i) {
+    let ref = "";
+    for (let n = i; n >= 0; n = Math.floor(n / 26) - 1)
+      ref = String.fromCharCode(65 + n % 26) + ref;
+    return ref;
+  }
+  function cellXml(ref, value) {
+    if (value === null || value === void 0 || value === "") return "";
+    if (typeof value === "number" && isFinite(value))
+      return `<c r="${ref}"><v>${value}</v></c>`;
+    return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escapeXml(String(value))}</t></is></c>`;
+  }
+  function sheetXml(headers, rows) {
+    let xml = XML_DECL + '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData>';
+    const all = [headers, ...rows];
+    for (let r = 0; r < all.length; r++) {
+      xml += `<row r="${r + 1}">`;
+      for (let c = 0; c < all[r].length; c++)
+        xml += cellXml(colRef(c) + (r + 1), all[r][c]);
+      xml += "</row>";
+    }
+    return xml + "</sheetData></worksheet>";
+  }
+  var CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++)
+        c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      table[n] = c >>> 0;
+    }
+    return table;
+  })();
+  function crc32(data) {
+    let crc = 4294967295;
+    for (let i = 0; i < data.length; i++)
+      crc = CRC_TABLE[(crc ^ data[i]) & 255] ^ crc >>> 8;
+    return (crc ^ 4294967295) >>> 0;
+  }
+  function zip(entries) {
+    const encoder = new TextEncoder();
+    const parts = [];
+    const central = [];
+    let offset = 0;
+    for (const entry of entries) {
+      const name = encoder.encode(entry.name);
+      const data = encoder.encode(entry.text);
+      const crc = crc32(data);
+      const local = new Uint8Array(30 + name.length);
+      const lv = new DataView(local.buffer);
+      lv.setUint32(0, 67324752, true);
+      lv.setUint16(4, 20, true);
+      lv.setUint32(14, crc, true);
+      lv.setUint32(18, data.length, true);
+      lv.setUint32(22, data.length, true);
+      lv.setUint16(26, name.length, true);
+      local.set(name, 30);
+      parts.push(local, data);
+      const dir = new Uint8Array(46 + name.length);
+      const dv = new DataView(dir.buffer);
+      dv.setUint32(0, 33639248, true);
+      dv.setUint16(4, 20, true);
+      dv.setUint16(6, 20, true);
+      dv.setUint32(16, crc, true);
+      dv.setUint32(20, data.length, true);
+      dv.setUint32(24, data.length, true);
+      dv.setUint16(28, name.length, true);
+      dv.setUint32(42, offset, true);
+      dir.set(name, 46);
+      central.push(dir);
+      offset += local.length + data.length;
+    }
+    const dirSize = central.reduce((sum, d) => sum + d.length, 0);
+    const eocd = new Uint8Array(22);
+    const ev = new DataView(eocd.buffer);
+    ev.setUint32(0, 101010256, true);
+    ev.setUint16(8, entries.length, true);
+    ev.setUint16(10, entries.length, true);
+    ev.setUint32(12, dirSize, true);
+    ev.setUint32(16, offset, true);
+    return new Blob([...parts, ...central, eocd], {
+      type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    });
+  }
+  var TableExport = {
+    /**
+     * Build the workbook and trigger a browser download as
+     * `<baseName>-YYYYMMDD-HHMMSS.xlsx`. Rows are exported exactly as the
+     * caller passes them (i.e. in the currently rendered/sorted order).
+     */
+    download(baseName, sheetName, headers, rows) {
+      const safeSheet = (sheetName || "").replace(/[\[\]:*?/\\]/g, " ").slice(0, 31).trim() || "Sheet1";
+      const blob = zip([
+        { name: "[Content_Types].xml", text: CONTENT_TYPES },
+        { name: "_rels/.rels", text: ROOT_RELS },
+        { name: "xl/workbook.xml", text: workbookXml(safeSheet) },
+        { name: "xl/_rels/workbook.xml.rels", text: WORKBOOK_RELS },
+        { name: "xl/worksheets/sheet1.xml", text: sheetXml(headers, rows) }
+      ]);
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[-:]/g, "").replace("T", "-");
+      const a = document.createElement("a");
+      a.href = URL.createObjectURL(blob);
+      a.download = `${baseName}-${stamp}.xlsx`;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      setTimeout(() => URL.revokeObjectURL(a.href), 5e3);
+    }
+  };
+
+  // node_modules/@stocksharp/grids/src/data-grid.ts
+  var GridPinnedPlacements = {
+    Top: "top",
+    Bottom: "bottom"
+  };
+  var DataGrid = class _DataGrid {
+    constructor(options) {
+      __publicField(this, "options");
+      __publicField(this, "sort");
+      __publicField(this, "_rows");
+      __publicField(this, "_rowEls");
+      __publicField(this, "_cellEls");
+      for (const col of options.columns) {
+        if (col.exportable && !col.value && !col.exportValue)
+          throw new Error(`DataGrid: column "${col.key}" is exportable but declares no value to export`);
+      }
+      this.options = options;
+      this._rows = [];
+      this._rowEls = /* @__PURE__ */ new Map();
+      this._cellEls = /* @__PURE__ */ new Map();
+      const accessors = {};
+      for (const col of options.columns) {
+        if (col.value) accessors[col.key] = col.value;
+      }
+      this._renderHead();
+      this.sort = new TableSort(options.head, accessors, () => this.render(), options.defaultSort);
+      this._paint();
+    }
+    /**
+     * The rows the grid holds, in the order they were handed over. The grid keeps
+     * the caller's array by reference: a caller that merges a live delta into it
+     * and calls `render()` repaints from the current contents.
+     */
+    get rows() {
+      return this._rows;
+    }
+    /**
+     * Rows in the order currently in effect (the picked column, else the table
+     * default). A sorted copy — the held array is never reordered.
+     */
+    sortedRows() {
+      return this.sort.apply(this._rows);
+    }
+    setRows(rows) {
+      this._rows = rows || [];
+      this.render();
+    }
+    render() {
+      this._paint();
+      if (this.options.afterRender) this.options.afterRender();
+    }
+    _paint() {
+      this._rowEls.clear();
+      this._cellEls.clear();
+      const pinned = this.options.pinnedRows ? this.options.pinnedRows() : [];
+      const sorted = this.sortedRows();
+      const painted = this.options.renderLimit != null ? sorted.slice(0, this.options.renderLimit) : sorted;
+      const children = [];
+      for (const row of pinned) {
+        if (row.place === GridPinnedPlacements.Top) children.push(this._pinnedRow(row));
+      }
+      if (painted.length === 0 && pinned.length === 0) children.push(this._emptyRow());
+      for (const row of painted) children.push(this._bodyRow(row));
+      for (const row of pinned) {
+        if (row.place === GridPinnedPlacements.Bottom) children.push(this._pinnedRow(row));
+      }
+      this.options.body.replaceChildren(...children);
+    }
+    /**
+     * The rendered row with this key, or null when it is not on screen (filtered
+     * out, or past `renderLimit`).
+     */
+    rowElement(rowKey) {
+      return this._rowEls.get(rowKey) || null;
+    }
+    /**
+     * The rendered cell at (row, column) — how a caller patches one cell in place
+     * instead of repainting the table, and how it finds the cell to edit.
+     */
+    cellElement(rowKey, columnKey) {
+      return this._cellEls.get(rowKey)?.get(columnKey) || null;
+    }
+    /**
+     * Header captions and cell values of the exportable columns, over every held
+     * row in the order in effect. Pure — separate from `download` so the sheet
+     * content can be asserted without a browser.
+     */
+    exportData() {
+      const columns = this.options.columns.filter((col) => col.exportable);
+      return {
+        headers: columns.map((col) => col.header),
+        rows: this.sortedRows().map((row) => columns.map((col) => {
+          const accessor = col.exportValue || col.value;
+          return accessor ? accessor(row) : null;
+        }))
+      };
+    }
+    /** Export to `<baseName>-<timestamp>.xlsx` in the order on screen. */
+    download(baseName, sheetName) {
+      const data = this.exportData();
+      TableExport.download(baseName, sheetName, data.headers, data.rows);
+    }
+    _renderHead() {
+      const tr = document.createElement("tr");
+      for (const col of this.options.columns) {
+        const th = document.createElement("th");
+        th.setAttribute("scope", "col");
+        if (col.headerClass) th.className = col.headerClass;
+        if (col.value) th.dataset.sort = col.key;
+        if (col.headerHidden) {
+          const label = document.createElement("span");
+          label.className = "visually-hidden";
+          label.textContent = col.header;
+          th.appendChild(label);
+        } else {
+          th.textContent = col.header;
+        }
+        tr.appendChild(th);
+      }
+      this.options.head.replaceChildren(tr);
+    }
+    _bodyRow(row) {
+      const tr = document.createElement("tr");
+      const key = this.options.rowKey(row);
+      const rowClass = this.options.rowClass ? this.options.rowClass(row) : "";
+      if (rowClass) tr.className = rowClass;
+      tr.dataset.rowKey = key;
+      const cells = /* @__PURE__ */ new Map();
+      for (const col of this.options.columns) {
+        const td = document.createElement("td");
+        td.dataset.col = col.key;
+        const cellClass = col.cellClass ? col.cellClass(row) : "";
+        if (cellClass) td.className = cellClass;
+        const content = col.render ? col.render(row) : _DataGrid._text(col.value ? col.value(row) : null);
+        if (content !== null && typeof content === "object" && "nodeType" in content) td.appendChild(content);
+        else td.textContent = _DataGrid._text(content);
+        if (col.bindCell) col.bindCell(td, row);
+        tr.appendChild(td);
+        cells.set(col.key, td);
+      }
+      if (this.options.bindRow) this.options.bindRow(tr, row);
+      this._rowEls.set(key, tr);
+      this._cellEls.set(key, cells);
+      return tr;
+    }
+    _pinnedRow(pinned) {
+      if (pinned.cells.length > this.options.columns.length) {
+        throw new Error(`DataGrid: pinned row "${pinned.key}" declares ${pinned.cells.length} cells for ${this.options.columns.length} columns`);
+      }
+      const tr = document.createElement("tr");
+      if (pinned.className) tr.className = pinned.className;
+      tr.dataset.rowKey = pinned.key;
+      const cells = /* @__PURE__ */ new Map();
+      for (let i = 0; i < this.options.columns.length; i++) {
+        const col = this.options.columns[i];
+        const td = document.createElement("td");
+        td.dataset.col = col.key;
+        const cell = pinned.cells[i];
+        if (cell) {
+          if (cell.className) td.className = cell.className;
+          if (typeof cell.content === "string") td.textContent = cell.content;
+          else td.appendChild(cell.content);
+        }
+        tr.appendChild(td);
+        cells.set(col.key, td);
+      }
+      this._rowEls.set(pinned.key, tr);
+      this._cellEls.set(pinned.key, cells);
+      return tr;
+    }
+    _emptyRow() {
+      const tr = document.createElement("tr");
+      const td = document.createElement("td");
+      td.className = "grid-empty";
+      td.colSpan = this.options.columns.length;
+      td.textContent = this.options.emptyText;
+      tr.appendChild(td);
+      return tr;
+    }
+    static _text(value) {
+      return value === null || value === void 0 ? "" : String(value);
+    }
+  };
+
+  // src/active-orders-widget.ts
+  var OrderStates = {
+    PendingRisk: 1,
+    Sent: 2,
+    Active: 3,
+    PartiallyFilled: 4,
+    Filled: 5,
+    Rejected: 6,
+    Cancelled: 7
+  };
+  var _ActiveOrdersWidget = class _ActiveOrdersWidget {
+    static create(hostEl, state, deps) {
+      const host = assertHost(deps?.host, "ActiveOrdersWidget");
+      const root = _ActiveOrdersWidget._buildRoot(host);
+      root.id = makePanelId(_ActiveOrdersWidget.TYPE);
+      hostEl.appendChild(root);
+      return new _ActiveOrdersWidget(root, state || {}, deps);
+    }
+    // The panel's markup. The host stylesheet reads this structure, and a
+    // docking host lifts `.panel-header`'s children into its tab strip.
+    //
+    // The rail's first two buttons are the ones that could not come across
+    // unchanged from the terminal's Razor template: they were inline
+    // `onclick="terminalApp.cancelAll()"` / `refreshOrders()`, references to a
+    // global this control must not have. They carry `.panel-cancel-all-btn` and
+    // `.panel-refresh-btn` now — the latter the name the other blotters' rails
+    // already give the identical button — and are wired to deps. Cancel-all
+    // keeps a distinct accessible name from its tooltip, which is why it states
+    // `aria-label` rather than taking the tooltip for both.
+    static _buildRoot(host) {
+      return makePanelRoot("active-orders-panel", host.t("ActiveOrders"), [
+        makeElement("div", "panel-header", {}, [
+          makeElement("span", "", {}, [host.t("OpenOrders")]),
+          makeIconButton("bt-icon-btn bt-icon-cancel panel-close-btn", host.t("ClosePanel"), "bi-x", { type: "button" })
+        ]),
+        makeElement("div", "panel-body panel-body-with-rail", {}, [
+          makeElement("div", "panel-body-content", {}, [
+            makeElement("table", "terminal-table active-orders-table", { role: "table", "aria-label": host.t("ActiveOrdersList") }, [
+              makeElement("thead", "", {}, []),
+              makeElement("tbody", "active-orders-body", {}, [])
+            ])
+          ]),
+          makeElement("div", "panel-rail", { role: "toolbar", "aria-label": host.t("ActiveOrdersActions") }, [
+            makeIconButton(
+              "bt-icon-btn bt-icon-cancel-all panel-cancel-all-btn",
+              host.t("CancelAll"),
+              "bi-x-circle",
+              { "aria-label": host.t("CancelAllOrders") }
+            ),
+            makeIconButton("bt-icon-btn panel-refresh-btn", host.t("Refresh"), "bi-arrow-clockwise", {}),
+            makeIconButton("bt-icon-btn panel-export-btn", host.t("ExportToExcel"), "bi-file-earmark-spreadsheet", {})
+          ])
+        ])
+      ]);
+    }
+    constructor(rootEl, _state, deps) {
+      this._host = assertHost(deps?.host, "ActiveOrdersWidget");
+      for (const name of ["cancelOrder", "dismissOrder", "editOrderField", "replaceOrder", "cancelAllOrders", "refreshOrders"]) {
+        if (typeof deps?.[name] !== "function")
+          throw new Error(`ActiveOrdersWidget: dep "${name}" is required`);
+      }
+      this.rootEl = rootEl;
+      this._deps = deps;
+      this.el = this.rootEl.querySelector(".active-orders-body");
+      this._closeBtn = this.rootEl.querySelector(".panel-close-btn");
+      this._cancelAllBtn = this.rootEl.querySelector(".panel-cancel-all-btn");
+      this._refreshBtn = this.rootEl.querySelector(".panel-refresh-btn");
+      this._exportBtn = this.rootEl.querySelector(".panel-export-btn");
+      this._orders = [];
+      this._closeBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._host.close();
+      });
+      this._cancelAllBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._deps.cancelAllOrders();
+      });
+      this._refreshBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._deps.refreshOrders();
+      });
+      this._exportBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._export();
+      });
+      const head = this.rootEl.querySelector(".active-orders-table thead");
+      this._grid = head && this.el ? new DataGrid({
+        head,
+        body: this.el,
+        columns: this._columns(),
+        // Newest order on top by default (localId is monotonic) — the resting view puts the
+        // user's most recent actions where they look, instead of raw cache order. Natural
+        // array order is "newest first" too (deltas unshift), but only by accident; any
+        // header click re-renders the same array through the sorter.
+        defaultSort: { col: "id", dir: "desc" },
+        // The register tx, not the friendly localId shown in the ID column: it is what
+        // cancel / replace / inline edit address an order by.
+        rowKey: (o) => String(o.id),
+        emptyText: this._host.t("NoActiveOrders"),
+        // Terminal rows are greyed out so the live ones stay visually prominent.
+        rowClass: (o) => _ActiveOrdersWidget._rowClass(o)
+      }) : null;
+      this._host.register(this);
+    }
+    dispose() {
+      this._host.unregister(this);
+      try {
+        this.rootEl.remove();
+      } catch {
+      }
+    }
+    update(orders) {
+      this._orders = orders || [];
+      this._grid?.setRows(this._orders);
+    }
+    // Export the table to .xlsx in the currently rendered (sorted) order, with the
+    // same localized side/type/status texts the user sees on screen — the columns
+    // carry both forms, so the sheet cannot drift from the table.
+    _export() {
+      this._grid?.download("orders", this._host.t("OpenOrders"));
+    }
+    /// Apply a single order delta from the feed. Insert if new, merge if known.
+    /// Nothing drops out of the list: Filled and Cancelled rows stay so the user
+    /// can watch an order's transitions instead of having a row vanish, and a
+    /// Rejected row stays so its reason can be read on hover and dismissed
+    /// explicitly through the × button.
+    applyDelta(order) {
+      if (!order || order.id == null) return;
+      const idx = this._orders.findIndex((o) => o.id === order.id);
+      if (idx >= 0)
+        this._orders[idx] = { ...this._orders[idx], ...order };
+      else
+        this._orders.unshift(order);
+      this.update(this._orders);
+    }
+    /// Remove a row from the local view without touching the server. Used by the
+    /// × button on a terminal order (nothing left to cancel), and in any other
+    /// client-side dismiss path.
+    removeOrder(orderId) {
+      const idx = this._orders.findIndex((o) => o.id === orderId);
+      if (idx >= 0) {
+        this._orders.splice(idx, 1);
+        this.update(this._orders);
+      }
+    }
+    getOrder(orderId) {
+      return this._orders.find((o) => o.id === orderId);
+    }
+    startInlineEdit(orderId, field) {
+      const order = this.getOrder(orderId);
+      if (!order) return;
+      const cell = this._grid?.cellElement(String(orderId), field);
+      if (!cell || cell.querySelector("input")) return;
+      const currentValue = order[field];
+      const input = document.createElement("input");
+      input.type = "number";
+      input.className = "inline-edit-input";
+      input.value = String(currentValue ?? "");
+      input.step = field === "quantity" ? "1" : "0.01";
+      input.min = field === "quantity" ? "1" : "0.01";
+      cell.textContent = "";
+      cell.appendChild(input);
+      input.focus();
+      input.select();
+      const commit = () => {
+        const newVal = parseFloat(input.value);
+        if (isNaN(newVal) || newVal <= 0) {
+          this.update(this._orders);
+          return;
+        }
+        if (newVal === currentValue) {
+          this.update(this._orders);
+          return;
+        }
+        const updated = { quantity: order.quantity, limitPrice: order.limitPrice, stopPrice: order.stopPrice };
+        updated[field] = newVal;
+        this._deps.replaceOrder(orderId, updated.quantity, updated.limitPrice, updated.stopPrice);
+      };
+      input.addEventListener("blur", commit);
+      input.addEventListener("keydown", (e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          input.blur();
+        }
+        if (e.key === "Escape") {
+          this.update(this._orders);
+        }
+      });
+    }
+    // The blotter's single column declaration: what the header says, what the
+    // grid sorts on, what the cell shows, how it is coloured, and what reaches
+    // the exported sheet.
+    _columns() {
+      const label = (key) => this._host.t(key);
+      const presentation = this._host.presentation;
+      return [
+        {
+          key: "id",
+          header: label("ID"),
+          exportable: true,
+          // Per-user friendly counter (1, 2, 3, …) issued by the host. `o.id`
+          // keeps the register tx for cancel / replace routing; `o.localId` is
+          // just the badge the user wants to see. Rows cached from before the
+          // counter shipped have no localId — fall back to id so they don't go
+          // blank until the next snapshot replay reassigns one.
+          value: (o) => o.localId ?? o.id
+        },
+        {
+          key: "instrument",
+          header: label("Sym"),
+          exportable: true,
+          value: (o) => o.instrument
+        },
+        {
+          key: "side",
+          header: label("Side"),
+          exportable: true,
+          value: (o) => o.side,
+          render: (o) => presentation.sideText(o.side),
+          cellClass: (o) => presentation.sideClass(o.side),
+          exportValue: (o) => presentation.sideText(o.side)
+        },
+        {
+          key: "type",
+          header: label("Type"),
+          exportable: true,
+          value: (o) => o.type,
+          render: (o) => presentation.typeText(o.type, o.limitPrice, o.stopPrice),
+          exportValue: (o) => presentation.typeText(o.type, o.limitPrice, o.stopPrice)
+        },
+        {
+          key: "quantity",
+          header: label("Qty"),
+          exportable: true,
+          value: (o) => o.quantity,
+          render: (o) => formatQty(o.quantity),
+          cellClass: (o) => _ActiveOrdersWidget._editableClass(o, "quantity"),
+          bindCell: (td, o) => this._bindInlineEdit(td, o, "quantity")
+        },
+        {
+          key: "limitPrice",
+          header: label("Price"),
+          exportable: true,
+          value: (o) => o.limitPrice,
+          render: (o) => o.limitPrice ? formatPrice(o.limitPrice) : label("MKT"),
+          cellClass: (o) => _ActiveOrdersWidget._editableClass(o, "limitPrice"),
+          bindCell: (td, o) => this._bindInlineEdit(td, o, "limitPrice"),
+          exportValue: (o) => o.limitPrice ?? label("MKT")
+        },
+        {
+          key: "stopPrice",
+          header: label("Stop"),
+          exportable: true,
+          value: (o) => o.stopPrice,
+          render: (o) => o.stopPrice ? formatPrice(o.stopPrice) : "--",
+          cellClass: (o) => _ActiveOrdersWidget._editableClass(o, "stopPrice"),
+          bindCell: (td, o) => this._bindInlineEdit(td, o, "stopPrice"),
+          exportValue: (o) => o.stopPrice ?? ""
+        },
+        {
+          key: "status",
+          header: label("Status"),
+          exportable: true,
+          value: (o) => o.status,
+          render: (o) => this._statusCell(o),
+          exportValue: (o) => presentation.statusText(o.status)
+        },
+        {
+          key: "actions",
+          header: label("Actions"),
+          headerHidden: true,
+          exportable: false,
+          cellClass: () => "position-actions",
+          render: (o) => this._actionButton(o)
+        }
+      ];
+    }
+    static _rowClass(order) {
+      if (order.status === OrderStates.Filled) return "order-filled";
+      if (order.status === OrderStates.Rejected) return "order-rejected";
+      if (order.status === OrderStates.Cancelled) return "order-cancelled";
+      return "";
+    }
+    // An order can still be modified while the venue holds it. A market order has
+    // no limit price and an unconditional order no stop price, so those cells have
+    // nothing to edit even then.
+    static _canEdit(order, field) {
+      const modifiable = order.status === OrderStates.Active || order.status === OrderStates.Sent;
+      return modifiable && (field === "quantity" || !!order[field]);
+    }
+    static _editableClass(order, field) {
+      return _ActiveOrdersWidget._canEdit(order, field) ? "cell-editable" : "";
+    }
+    // Double-click to edit belongs to the whole cell rather than to a control
+    // inside it, which is why it is wired here instead of returned by render().
+    _bindInlineEdit(td, order, field) {
+      if (!_ActiveOrdersWidget._canEdit(order, field)) return;
+      td.addEventListener("dblclick", () => this._deps.editOrderField(order.id, field));
+    }
+    // Status text, plus a hoverable icon carrying the rejection reason. Some
+    // venues wrap the human-readable rejection inside a JSON blob;
+    // cleanRejectReason extracts `.message` and falls back to the raw string.
+    // The reason goes on the element's title property, so no quote escaping is
+    // involved the way it was when this row was built as markup.
+    _statusCell(order) {
+      const text = this._host.presentation.statusText(order.status);
+      const reason = order.status === OrderStates.Rejected ? cleanRejectReason(order.rejectReason) : "";
+      if (!reason) return text;
+      const cell = document.createDocumentFragment();
+      cell.appendChild(document.createTextNode(text + " "));
+      const icon = document.createElement("i");
+      icon.className = "bi bi-question-circle reject-reason-icon";
+      icon.title = reason;
+      cell.appendChild(icon);
+      return cell;
+    }
+    // The × button, wired to the controller through deps. Status decides what it
+    // means: Pending / Active is a real cancel over the wire, while Filled /
+    // Rejected / Cancelled have nothing left to cancel — the row is history kept
+    // around so the user can read its final state, so the button dismisses it
+    // locally.
+    _actionButton(order) {
+      const isTerminal = order.status === OrderStates.Filled || order.status === OrderStates.Rejected || order.status === OrderStates.Cancelled;
+      const title = isTerminal ? this._host.t("Dismiss") : this._host.t("Cancel order");
+      const button = document.createElement("button");
+      button.type = "button";
+      button.className = "bt-icon-btn bt-icon-cancel";
+      button.title = title;
+      button.setAttribute("aria-label", `${title} #${order.id}`);
+      const icon = document.createElement("i");
+      icon.className = "bi bi-x-circle";
+      button.appendChild(icon);
+      button.addEventListener("click", () => {
+        if (isTerminal) this._deps.dismissOrder(order.id);
+        else this._deps.cancelOrder(order.id);
+      });
+      return button;
+    }
+  };
+  _ActiveOrdersWidget.TYPE = ControlTypes.ActiveOrders;
+  var ActiveOrdersWidget = _ActiveOrdersWidget;
+
+  // src/positions-widget.ts
+  var _PositionsWidget = class _PositionsWidget {
+    static create(hostEl, state, deps) {
+      const host = assertHost(deps?.host, "PositionsWidget");
+      const root = _PositionsWidget._buildRoot(host);
+      root.id = makePanelId(_PositionsWidget.TYPE);
+      hostEl.appendChild(root);
+      return new _PositionsWidget(root, state || {}, deps);
+    }
+    // The panel's markup. The host stylesheet reads this structure, and a
+    // docking host lifts `.panel-header`'s children into its tab strip.
+    //
+    // The rail's refresh button is the one thing that could not come across
+    // unchanged from the terminal's Razor template: it used to be an inline
+    // `onclick="terminalApp.refreshPositions()"`, which is a reference to a
+    // global this control must not have. It carries `.panel-refresh-btn` now —
+    // the name the trade-history rail already gave the identical button — and
+    // is wired to the `refreshPositions` dep.
+    static _buildRoot(host) {
+      const title = host.t("OpenPositions");
+      return makePanelRoot("positions-panel", title, [
+        makeElement("div", "panel-header", {}, [
+          makeElement("span", "", {}, [host.t("Positions")]),
+          makeIconButton("bt-icon-btn bt-icon-cancel panel-close-btn", host.t("ClosePanel"), "bi-x", { type: "button" })
+        ]),
+        makeElement("div", "panel-body panel-body-with-rail", {}, [
+          makeElement("div", "panel-body-content", {}, [
+            makeElement("table", "terminal-table positions-table", { role: "table", "aria-label": title }, [
+              makeElement("thead", "", {}, []),
+              makeElement("tbody", "positions-body", {}, [])
+            ])
+          ]),
+          makeElement("div", "panel-rail", { role: "toolbar", "aria-label": host.t("PositionsActions") }, [
+            makeIconButton("bt-icon-btn panel-refresh-btn", host.t("Refresh"), "bi-arrow-clockwise", {}),
+            makeIconButton("bt-icon-btn panel-export-btn", host.t("ExportToExcel"), "bi-file-earmark-spreadsheet", {})
+          ])
+        ])
+      ]);
+    }
+    constructor(rootEl, _state, deps) {
+      this._host = assertHost(deps?.host, "PositionsWidget");
+      for (const name of ["closePosition", "reversePosition", "refreshPositions"]) {
+        if (typeof deps?.[name] !== "function")
+          throw new Error(`PositionsWidget: dep "${name}" is required`);
+      }
+      this.rootEl = rootEl;
+      this._deps = deps;
+      this.el = this.rootEl.querySelector(".positions-body");
+      this._closeBtn = this.rootEl.querySelector(".panel-close-btn");
+      this._refreshBtn = this.rootEl.querySelector(".panel-refresh-btn");
+      this._exportBtn = this.rootEl.querySelector(".panel-export-btn");
+      this._positions = [];
+      this._balance = null;
+      this._closeBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._host.close();
+      });
+      this._refreshBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._deps.refreshPositions();
+      });
+      this._exportBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._export();
+      });
+      const head = this.rootEl.querySelector(".positions-table thead");
+      this._grid = head && this.el ? new DataGrid({
+        head,
+        body: this.el,
+        columns: this._columns(),
+        // Alphabetical by instrument at rest — a stable, predictable order (positions have no
+        // natural "newest") the user can scan by symbol.
+        defaultSort: { col: "instrument", dir: "asc" },
+        // Same identity applyDelta matches on: id alone isn't unique (id=0 for
+        // unsaved snapshots), and a portfolio can hold one position per instrument.
+        rowKey: (p) => _PositionsWidget._key(p),
+        emptyText: this._host.t("No positions"),
+        // Re-read on every render, so the cash figures track the live balance
+        // without the widget having to repaint the position rows itself.
+        pinnedRows: () => this._pinnedRows()
+      }) : null;
+      this._host.register(this);
+    }
+    dispose() {
+      this._host.unregister(this);
+      try {
+        this.rootEl.remove();
+      } catch {
+      }
+    }
+    update(positions) {
+      this._positions = positions || [];
+      this._grid?.setRows(this._positions);
+    }
+    /// Null clears the pinned row — which is not the same as an all-zero
+    /// balance, and reads differently: no row at all versus a row of zeros.
+    updateBalance(balance) {
+      this._balance = balance;
+      this._grid?.render();
+    }
+    /// Apply a single position delta. Match by (portfolioId, instrumentId) — id
+    /// alone isn't unique (id=0 for unsaved snapshots). Quantity hitting zero
+    /// closes the row.
+    applyDelta(position) {
+      if (!position) return;
+      const idx = this._positions.findIndex((p) => p.portfolioId === position.portfolioId && (position.instrumentId != null && p.instrumentId === position.instrumentId || position.instrumentId == null && p.instrument === position.instrument));
+      const closed = (position.quantity || 0) === 0;
+      if (idx >= 0) {
+        if (closed) this._positions.splice(idx, 1);
+        else this._positions[idx] = { ...this._positions[idx], ...position };
+      } else if (!closed) {
+        this._positions.push(position);
+      }
+      this.update(this._positions);
+    }
+    // Export the table to .xlsx in the currently rendered (sorted) order. The
+    // balance summary is a pinned row — a different shape from a position — so
+    // the grid keeps it out of the sheet.
+    _export() {
+      this._grid?.download("positions", this._host.t("Positions"));
+    }
+    // The blotter's single column declaration: what the header says, what the
+    // grid sorts on, what the cell shows, how it is coloured, and what reaches
+    // the exported sheet. Prices are formatted on screen but exported raw, so
+    // the sheet stays numeric.
+    _columns() {
+      const label = (key) => this._host.t(key);
+      return [
+        {
+          key: "instrument",
+          header: label("Symbol"),
+          exportable: true,
+          value: (p) => p.instrument
+        },
+        {
+          key: "quantity",
+          header: label("Qty"),
+          exportable: true,
+          value: (p) => p.quantity,
+          cellClass: (p) => (p.quantity ?? 0) > 0 ? "side-buy" : "side-sell"
+        },
+        {
+          key: "avgPrice",
+          header: label("AvgPrice"),
+          exportable: true,
+          value: (p) => p.avgPrice,
+          render: (p) => formatPrice(p.avgPrice)
+        },
+        {
+          key: "currentPrice",
+          header: label("Current"),
+          exportable: true,
+          value: (p) => p.currentPrice,
+          render: (p) => formatPrice(p.currentPrice)
+        },
+        {
+          key: "pnl",
+          header: label("PnL"),
+          exportable: true,
+          value: (p) => _PositionsWidget._totalPnl(p),
+          render: (p) => formatPnl(_PositionsWidget._totalPnl(p)),
+          cellClass: (p) => this._host.presentation.pnlClass(_PositionsWidget._totalPnl(p))
+        },
+        {
+          key: "actions",
+          header: label("Actions"),
+          headerHidden: true,
+          exportable: false,
+          cellClass: () => "position-actions",
+          render: (p) => this._actionButtons(p)
+        }
+      ];
+    }
+    // The cash balance, pinned above the positions. It does not share the shape
+    // the position columns read, so it supplies its own cells; it is not a row
+    // of data, so it is neither sorted nor exported. Being content, it also
+    // suppresses the "no positions" row — a table showing a balance is not empty.
+    _pinnedRows() {
+      const balance = this._balance;
+      if (!balance) return [];
+      const fmt = (v) => (v || 0).toLocaleString(void 0, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+      return [{
+        key: "balance",
+        className: "balance-row",
+        place: GridPinnedPlacements.Top,
+        cells: [
+          { content: this._host.t("USD"), className: "balance-ccy" },
+          { content: "$" + fmt(balance.available), className: "balance-available" },
+          { content: this._host.t("Locked: ${0}", fmt(balance.locked)), className: "balance-locked" },
+          { content: "", className: "" },
+          { content: "$" + fmt(balance.total), className: "balance-total" }
+        ]
+      }];
+    }
+    // Realized and unrealized together — what the PnL column shows, sorts and
+    // exports, so the three cannot drift apart.
+    static _totalPnl(position) {
+      return (position.unrealizedPnl || 0) + (position.realizedPnl || 0);
+    }
+    static _key(position) {
+      return `${position.portfolioId}:${position.instrumentId ?? position.instrument}`;
+    }
+    // Close and reverse, wired to the controller through deps. Real buttons with
+    // their own listeners — the symbol used to be interpolated into an inline
+    // onclick attribute, which is why it needed quote-escaping first.
+    _actionButtons(position) {
+      const cell = document.createDocumentFragment();
+      cell.appendChild(this._actionButton(
+        "bt-icon-cancel",
+        "bi-x-circle",
+        this._host.t("Close position"),
+        this._host.t("Close position on {0}", position.instrument),
+        () => this._deps.closePosition(position.portfolioId, position.instrumentId, position.instrument)
+      ));
+      cell.appendChild(this._actionButton(
+        "bt-icon-reverse",
+        "bi-arrow-left-right",
+        this._host.t("Reverse position"),
+        this._host.t("Reverse position on {0}", position.instrument),
+        () => this._deps.reversePosition(position.portfolioId, position.instrumentId, position.instrument)
+      ));
+      return cell;
+    }
+    _actionButton(styleClass, iconClass, title, label, onClick) {
+      const button = document.createElement("button");
+      button.type = "button";
+      button.className = `bt-icon-btn ${styleClass}`;
+      button.title = title;
+      button.setAttribute("aria-label", label);
+      const icon = document.createElement("i");
+      icon.className = `bi ${iconClass}`;
+      button.appendChild(icon);
+      button.addEventListener("click", onClick);
+      return button;
+    }
+  };
+  _PositionsWidget.TYPE = ControlTypes.Positions;
+  var PositionsWidget = _PositionsWidget;
+
+  // src/trade-history-widget.ts
+  var _TradeHistoryWidget = class _TradeHistoryWidget {
+    static create(hostEl, state, deps) {
+      const host = assertHost(deps?.host, "TradeHistoryWidget");
+      const root = _TradeHistoryWidget._buildRoot(host);
+      root.id = makePanelId(_TradeHistoryWidget.TYPE);
+      hostEl.appendChild(root);
+      return new _TradeHistoryWidget(root, state || {}, deps);
+    }
+    // The panel's markup. The host stylesheet reads this structure, and a
+    // docking host lifts `.panel-header`'s children into its tab strip.
+    static _buildRoot(host) {
+      const title = host.t("TradeHistory");
+      return makePanelRoot("trade-history-panel", title, [
+        makeElement("div", "panel-header", {}, [
+          makeElement("span", "", {}, [title]),
+          makeIconButton("bt-icon-btn bt-icon-cancel panel-close-btn", host.t("ClosePanel"), "bi-x", { type: "button" })
+        ]),
+        makeElement("div", "panel-body panel-body-with-rail", {}, [
+          makeElement("div", "panel-body-content", {}, [
+            makeElement("table", "terminal-table trade-history-table", { role: "table", "aria-label": host.t("TradeHistoryList") }, [
+              makeElement("thead", "", {}, []),
+              makeElement("tbody", "trade-history-body", {}, [])
+            ])
+          ]),
+          makeElement("div", "panel-rail", { role: "toolbar", "aria-label": host.t("TradeHistoryActions") }, [
+            makeIconButton("bt-icon-btn panel-refresh-btn", host.t("Refresh"), "bi-arrow-clockwise", {}),
+            makeIconButton("bt-icon-btn panel-export-btn", host.t("ExportToExcel"), "bi-file-earmark-spreadsheet", {})
+          ])
+        ])
+      ]);
+    }
+    constructor(rootEl, _state, deps) {
+      this._host = assertHost(deps?.host, "TradeHistoryWidget");
+      this.rootEl = rootEl;
+      this.bodyEl = this.rootEl.querySelector(".trade-history-body");
+      this._closeBtn = this.rootEl.querySelector(".panel-close-btn");
+      this._refreshBtn = this.rootEl.querySelector(".panel-refresh-btn");
+      this._exportBtn = this.rootEl.querySelector(".panel-export-btn");
+      this._closeBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this.dispose();
+        this._host.close();
+      });
+      this._refreshBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        void this.refresh();
+      });
+      this._exportBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._export();
+      });
+      this._rows = [];
+      const head = this.rootEl.querySelector(".trade-history-table thead");
+      this._grid = head && this.bodyEl ? new DataGrid({
+        head,
+        body: this.bodyEl,
+        columns: this._columns(),
+        // Most recent fill on top by default — the natural way to read a trade blotter.
+        defaultSort: { col: "time", dir: "desc" },
+        rowKey: (t) => String(t.id),
+        emptyText: this._host.t("No trade history")
+      }) : null;
+      this._host.register(this);
+    }
+    dispose() {
+      this._host.unregister(this);
+      try {
+        this.rootEl.remove();
+      } catch {
+      }
+    }
+    /// Reload against whichever portfolio the host says is active right now.
+    ///
+    /// Two guards, and they are not the same one. No portfolio means there is
+    /// nothing to show — a guest session has none. A portfolio the host will
+    /// not `allow` reading means the session cannot make the call at all: this
+    /// is somebody's executed trades, so a page that has a portfolio id lying
+    /// around but no live credential must not fire the request and collect a
+    /// 401 for it. The panel asks the host rather than inspecting a token,
+    /// because what counts as a usable session is the host's to know.
+    ///
+    /// Order matters: the portfolio check runs first, so a session with no
+    /// portfolio is simply quiet — `allow` is the one that may put a sign-in
+    /// prompt on screen, and reaching it means the page did have an account to
+    /// load.
+    async refresh() {
+      const pf = this._host.trading.portfolioId();
+      if (!pf || !this._grid) return;
+      if (!this._host.allow("load trade history")) return;
+      try {
+        this._rows = await this._host.trading.api.getExecutions(pf, null, 200) || [];
+        this._grid.setRows(this._rows);
+      } catch (err) {
+        this._host.log(`TradeHistoryWidget: failed to load trade history: ${err}`);
+      }
+    }
+    // Export the table to .xlsx in the currently rendered (sorted) order.
+    _export() {
+      this._grid?.download("trades", this._host.t("TradeHistory"));
+    }
+    // The blotter's single column declaration. The two id columns read `#42` on
+    // screen and export the bare number, so the sheet stays sortable as a number.
+    _columns() {
+      const label = (key) => this._host.t(key);
+      const presentation = this._host.presentation;
+      return [
+        {
+          key: "id",
+          header: label("ID"),
+          exportable: true,
+          value: (t) => t.id,
+          render: (t) => "#" + t.id,
+          cellClass: () => "mono-id"
+        },
+        {
+          key: "time",
+          header: label("Time"),
+          exportable: true,
+          value: (t) => t.executedAt || t.time,
+          render: (t) => formatTime(t.executedAt || t.time),
+          exportValue: (t) => formatTime(t.executedAt || t.time)
+        },
+        {
+          key: "symbol",
+          header: label("Sym"),
+          exportable: true,
+          value: (t) => t.instrumentSymbol || t.symbol
+        },
+        {
+          key: "side",
+          header: label("Side"),
+          exportable: true,
+          value: (t) => t.side,
+          render: (t) => presentation.sideText(t.side),
+          cellClass: (t) => presentation.sideClass(t.side),
+          exportValue: (t) => presentation.sideText(t.side)
+        },
+        {
+          key: "quantity",
+          header: label("Qty"),
+          exportable: true,
+          value: (t) => t.quantity,
+          render: (t) => formatQty(t.quantity)
+        },
+        {
+          key: "price",
+          header: label("Price"),
+          exportable: true,
+          value: (t) => t.price,
+          render: (t) => formatPrice(t.price)
+        },
+        {
+          key: "order",
+          header: label("Order"),
+          exportable: true,
+          value: (t) => t.order || t.orderId,
+          render: (t) => "#" + (t.order || t.orderId || ""),
+          cellClass: () => "mono-id"
+        }
+      ];
+    }
+  };
+  _TradeHistoryWidget.TYPE = ControlTypes.TradeHistory;
+  var TradeHistoryWidget = _TradeHistoryWidget;
+
+  // src/watchlist-widget.ts
+  var _WatchlistWidget = class _WatchlistWidget {
+    static create(hostEl, state, deps) {
+      const host = assertHost(deps?.host, "WatchlistWidget");
+      const root = _WatchlistWidget._buildRoot(host);
+      root.id = makePanelId(_WatchlistWidget.TYPE);
+      hostEl.appendChild(root);
+      return new _WatchlistWidget(root, state || {}, deps);
+    }
+    // The panel's markup. The host stylesheet reads this structure, and a
+    // docking host lifts `.panel-header`'s children — and, for this panel,
+    // `.watchlist-search-row` as well — into its tab strip, which is why the
+    // search row is a sibling of the header rather than a child of it.
+    //
+    // "All" and "Favorites" are the built-in tabs. The rest are appended at
+    // runtime from the distinct categories of the loaded instruments, so the
+    // tab set is configured through whatever assigns those categories rather
+    // than being spelled out here — see _renderCategoryTabs.
+    static _buildRoot(host) {
+      const search = host.t("SearchInstruments");
+      const favorites = host.t("Favorites");
+      return makePanelRoot("watchlist-panel", host.t("Watchlist"), [
+        makeElement("div", "panel-header", {}, [
+          makeElement("span", "", {}, [host.t("Markets")]),
+          makeIconButton("bt-icon-btn panel-export-btn", host.t("ExportToExcel"), "bi-file-earmark-spreadsheet", { type: "button" }),
+          makeIconButton("bt-icon-btn bt-icon-cancel panel-close-btn", host.t("ClosePanel"), "bi-x", { type: "button" })
+        ]),
+        makeElement("div", "watchlist-search-row", {}, [
+          makeElement(
+            "input",
+            "form-control form-control-sm watchlist-search-input watchlist-search",
+            { type: "text", placeholder: search, autocomplete: "off", "aria-label": search },
+            []
+          )
+        ]),
+        makeElement("div", "watchlist-tabs", { role: "tablist", "aria-label": host.t("WatchlistFilter") }, [
+          makeElement("button", "wl-tab active", { "data-filter": "all", role: "tab", "aria-selected": "true" }, [host.t("All")]),
+          makeElement("button", "wl-tab", { "data-filter": "favorites", role: "tab", "aria-selected": "false", "aria-label": favorites, title: favorites }, ["\u2605"])
+        ]),
+        makeElement("div", "watchlist-pane", {}, [
+          makeElement("table", "watchlist-table", {}, [
+            makeElement("thead", "watchlist-headers", {}, []),
+            makeElement("tbody", "watchlist-body", {}, [])
+          ])
+        ])
+      ]);
+    }
+    constructor(rootEl, _state, deps) {
+      this._host = assertHost(deps?.host, "WatchlistWidget");
+      if (typeof deps?.onSelect !== "function")
+        throw new Error('WatchlistWidget: dep "onSelect" is required');
+      this.rootEl = rootEl;
+      this._deps = deps;
+      this.api = this._host.trading.api;
+      this.instruments = [];
+      this.stats = /* @__PURE__ */ new Map();
+      this.favorites = new Set(this._loadFavorites());
+      this.filter = "all";
+      this.search = "";
+      this.currentSymbol = null;
+      this._subscribedSyms = /* @__PURE__ */ new Set();
+      this.wsClient = this._host.trading.marketData;
+      this.bodyEl = this.rootEl.querySelector(".watchlist-body");
+      this.searchEl = this.rootEl.querySelector(".watchlist-search");
+      this.tabsEl = this.rootEl.querySelector(".watchlist-tabs");
+      this.sortHeaderEl = this.rootEl.querySelector(".watchlist-headers");
+      this._closeBtn = this.rootEl.querySelector(".panel-close-btn");
+      this._exportBtn = this.rootEl.querySelector(".panel-export-btn");
+      this._closeBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this.dispose();
+        this._host.close();
+      });
+      this._exportBtn?.addEventListener("click", (e) => {
+        e.preventDefault();
+        this._export();
+      });
+      this._grid = this.sortHeaderEl && this.bodyEl ? new DataGrid({
+        head: this.sortHeaderEl,
+        body: this.bodyEl,
+        columns: this._columns(),
+        // Symbol A→Z at rest — an instrument list has no natural "newest",
+        // and alphabetical is what the user scans by.
+        defaultSort: { col: "symbol", dir: "asc" },
+        rowKey: (i) => String(i.symbol),
+        emptyText: this._host.t("No instruments"),
+        rowClass: (i) => i.symbol === this.currentSymbol ? "wl-row wl-current" : "wl-row",
+        bindRow: (tr, i) => tr.addEventListener("click", () => this._deps.onSelect(i.symbol)),
+        // Paint a screenful, export and subscribe over the whole filtered set.
+        renderLimit: _WatchlistWidget.RENDER_CAP,
+        // A header click re-renders through the grid, so this is the only
+        // place that sees every change to the visible set — including a sort
+        // the widget was never told about.
+        afterRender: () => {
+          this._syncSubs();
+          this._publishVisible();
+        }
+      }) : null;
+      this._bind();
+      this._host.register(this);
+      void this.init();
+    }
+    dispose() {
+      for (const sym of this._subscribedSyms) {
+        try {
+          void this.wsClient?.removeSymbol(sym);
+        } catch {
+        }
+      }
+      this._subscribedSyms.clear();
+      this._host.unregister(this);
+      try {
+        this.rootEl.remove();
+      } catch {
+      }
+    }
+    async init() {
+      try {
+        this.instruments = await this.api.searchInstruments("");
+      } catch (err) {
+        this._host.log(`WatchlistWidget: failed to load instruments: ${err}`);
+        this.instruments = [];
+      }
+      this._renderCategoryTabs();
+      this._render();
+    }
+    // Build the filter tabs from the assigned instrument categories. "All" and
+    // "Favorites" are built into the markup; here we append one tab per distinct
+    // non-empty category found in the loaded instruments. Re-runnable: clears
+    // any category tabs a previous load added.
+    _renderCategoryTabs() {
+      if (!this.tabsEl) return;
+      this.tabsEl.querySelectorAll(".wl-tab[data-category]").forEach((el) => el.remove());
+      const cats = Array.from(new Set(
+        this.instruments.map((i) => (i.category || "").trim()).filter((c) => c.length > 0)
+      )).sort((a, b) => a.localeCompare(b));
+      for (const cat of cats) {
+        const btn = document.createElement("button");
+        btn.className = "wl-tab";
+        btn.setAttribute("role", "tab");
+        btn.setAttribute("aria-selected", "false");
+        btn.dataset.filter = cat;
+        btn.dataset.category = "1";
+        btn.textContent = cat;
+        this.tabsEl.appendChild(btn);
+      }
+    }
+    /// Highlight the instrument the rest of the page is showing. Patches the two
+    /// affected rows rather than repainting: a repaint here would restart any
+    /// flash animation currently running in a price cell.
+    setCurrentSymbol(symbol) {
+      const previous = this.currentSymbol;
+      this.currentSymbol = symbol;
+      if (!this._grid) return;
+      if (previous) this._grid.rowElement(String(previous))?.classList.remove("wl-current");
+      if (symbol) this._grid.rowElement(String(symbol))?.classList.add("wl-current");
+    }
+    onPriceUpdate(symbol, price) {
+      if (price == null || !isFinite(price)) return;
+      let full = symbol;
+      if (!full.includes("@")) {
+        const match = this.instruments.find((i) => String(i.symbol).split("@")[0] === symbol);
+        if (match?.symbol) full = match.symbol;
+      }
+      const cur = this.stats.get(full);
+      const prev = cur?.lastPrice;
+      const baselineKey = _WatchlistWidget._baselineKey(full);
+      let baseline = cur?.baseline;
+      if (baseline == null) {
+        const stored = this._host.cache.get(baselineKey, null);
+        baseline = stored ? Number(stored) : void 0;
+      }
+      if (baseline == null || !isFinite(baseline) || baseline === 0) {
+        baseline = price;
+        this._host.cache.set(baselineKey, String(price));
+      }
+      const chgPct = baseline ? (price - baseline) / baseline * 100 : 0;
+      this.stats.set(full, { ...cur || {}, lastPrice: price, baseline, chgPct });
+      this._updateRow(full, prev);
+    }
+    static _baselineKey(symbol) {
+      const day = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      return _WatchlistWidget.BASELINE_KEY_PREFIX + day + ":" + symbol;
+    }
+    _bind() {
+      if (this.searchEl) {
+        this.searchEl.addEventListener("input", () => {
+          this.search = (this.searchEl.value || "").trim().toLowerCase();
+          this._render();
+        });
+      }
+      if (this.tabsEl) {
+        this.tabsEl.addEventListener("click", (e) => {
+          const tgt = e.target;
+          const btn = tgt?.closest(".wl-tab");
+          if (!btn) return;
+          this.filter = btn.dataset.filter || "all";
+          this.tabsEl.querySelectorAll(".wl-tab").forEach((b) => b.classList.toggle("active", b === btn));
+          this._render();
+        });
+      }
+    }
+    // The instruments matching the search box and the active tab, unsorted —
+    // the grid owns the order.
+    _filtered() {
+      const q = this.search;
+      const rows = [];
+      for (const inst of this.instruments) {
+        const sym = (inst.symbol || "").toUpperCase();
+        const symL = sym.toLowerCase();
+        const shortSym = symL.split("@")[0];
+        const exch = (inst.exchange || "").toLowerCase();
+        const qualified = `${shortSym}/${exch}`;
+        const qualifiedAt = `${shortSym}@${exch}`;
+        if (q && !symL.includes(q) && !(inst.name || "").toLowerCase().includes(q) && !qualified.includes(q) && !qualifiedAt.includes(q)) continue;
+        if (this.filter === "favorites") {
+          if (!this.favorites.has(sym)) continue;
+        } else if (this.filter !== "all") {
+          if ((inst.category || "").toLowerCase() !== this.filter.toLowerCase()) continue;
+        }
+        rows.push(inst);
+      }
+      return rows;
+    }
+    _render() {
+      this._grid?.setRows(this._filtered());
+    }
+    // The blotter's single column declaration. Prices and percentages come off
+    // the live stats map rather than the instrument row, so a quote arriving
+    // between two renders is picked up by the next one.
+    _columns() {
+      const label = (key) => this._host.t(key);
+      return [
+        {
+          key: "symbol",
+          header: label("Symbol"),
+          exportable: true,
+          value: (i) => i.symbol,
+          cellClass: () => "wl-sym-cell",
+          render: (i) => this._symbolCell(i),
+          exportValue: (i) => String(i.symbol).split("@")[0]
+        },
+        {
+          key: "last",
+          header: label("Last"),
+          headerClass: "ta-right",
+          exportable: true,
+          value: (i) => this._statsOf(i).lastPrice,
+          cellClass: () => "wl-last",
+          render: (i) => _WatchlistWidget._priceText(this._statsOf(i).lastPrice),
+          exportValue: (i) => this._statsOf(i).lastPrice ?? ""
+        },
+        {
+          key: "chgPct",
+          header: label("Change24hPct"),
+          headerClass: "ta-right",
+          exportable: true,
+          value: (i) => this._statsOf(i).chgPct,
+          cellClass: (i) => ("wl-chg " + _WatchlistWidget._changeClass(this._statsOf(i).chgPct)).trim(),
+          render: (i) => _WatchlistWidget._changeText(this._statsOf(i).chgPct),
+          exportValue: (i) => this._statsOf(i).chgPct ?? ""
+        }
+      ];
+    }
+    _statsOf(instrument) {
+      return this.stats.get(String(instrument.symbol)) ?? {};
+    }
+    // The favourite star plus the short symbol. The star stops the click from
+    // reaching the row, whose own listener switches the host's instrument.
+    _symbolCell(instrument) {
+      const cell = document.createDocumentFragment();
+      const star = document.createElement("button");
+      star.type = "button";
+      star.className = this.favorites.has(instrument.symbol) ? "wl-fav active" : "wl-fav";
+      star.title = this._host.t("Favorite");
+      star.textContent = "\u2605";
+      star.addEventListener("click", (e) => {
+        e.stopPropagation();
+        this._toggleFavorite(instrument.symbol);
+      });
+      cell.appendChild(star);
+      const label = document.createElement("span");
+      label.className = "wl-sym";
+      label.textContent = String(instrument.symbol).split("@")[0];
+      cell.appendChild(label);
+      return cell;
+    }
+    // Export the current filtered+sorted view to .xlsx — every matching
+    // instrument, without the RENDER_CAP truncation applied to the DOM.
+    _export() {
+      this._grid?.download("watchlist", this._host.t("Markets"));
+    }
+    // Patch the price and change cells of one row in place. A full render would
+    // replace the cell element and so cancel the flash animation started here.
+    _updateRow(symbol, prevPrice) {
+      if (!this._grid) return;
+      const st = this.stats.get(symbol) || {};
+      const lastEl = this._grid.cellElement(String(symbol), "last");
+      const chgEl = this._grid.cellElement(String(symbol), "chgPct");
+      if (lastEl && st.lastPrice != null) {
+        lastEl.textContent = _WatchlistWidget._priceText(st.lastPrice);
+        if (prevPrice != null && st.lastPrice !== prevPrice) {
+          lastEl.classList.remove("flash-up", "flash-down");
+          void lastEl.offsetWidth;
+          lastEl.classList.add(st.lastPrice > prevPrice ? "flash-up" : "flash-down");
+        }
+      }
+      if (chgEl && st.chgPct != null && isFinite(Number(st.chgPct))) {
+        chgEl.textContent = _WatchlistWidget._changeText(st.chgPct);
+        chgEl.classList.remove("up", "down");
+        chgEl.classList.add(_WatchlistWidget._changeClass(st.chgPct));
+      }
+    }
+    _toggleFavorite(symbol) {
+      if (!this._host.allow("add to favorites")) return;
+      if (this.favorites.has(symbol)) this.favorites.delete(symbol);
+      else this.favorites.add(symbol);
+      this._saveFavorites();
+      this._host.broadcast((w) => {
+        if (w !== this) {
+          w.favorites = new Set(this.favorites);
+          w._render();
+        }
+      });
+      this._render();
+    }
+    _loadFavorites() {
+      try {
+        const raw = this._host.preferences.get(_WatchlistWidget.FAVORITES_KEY, null);
+        return raw ? JSON.parse(raw) : [];
+      } catch {
+        return [];
+      }
+    }
+    _saveFavorites() {
+      try {
+        this._host.preferences.set(_WatchlistWidget.FAVORITES_KEY, JSON.stringify(Array.from(this.favorites)));
+      } catch {
+      }
+    }
+    // The symbols at the top of the current order — the ones a user is actually
+    // looking at, and the set both the subscriptions and the host's ticker are
+    // sized to.
+    _visible() {
+      return this._grid ? this._grid.sortedRows().slice(0, _WatchlistWidget.VISIBLE_CAP) : [];
+    }
+    // Diff the desired set of visible symbols against currently-held live-price
+    // subscriptions, then add/remove to converge. Called after every render that
+    // may have changed the visible list (filter, sort, search). add/removeSymbol
+    // refcount internally, so another control's subscription on the same symbol
+    // is not affected.
+    _syncSubs() {
+      if (!this.wsClient) return;
+      const desired = new Set(this._visible().map((i2) => String(i2.symbol).split("@")[0]));
+      for (const sym of this._subscribedSyms) {
+        if (!desired.has(sym)) {
+          try {
+            void this.wsClient.removeSymbol(sym);
+          } catch {
+          }
+          this._subscribedSyms.delete(sym);
+        }
+      }
+      let i = 0;
+      for (const sym of desired) {
+        if (this._subscribedSyms.has(sym)) continue;
+        this._subscribedSyms.add(sym);
+        setTimeout(() => {
+          try {
+            void this.wsClient.addSymbol(sym, MarketDataLevels.Quotes);
+          } catch {
+          }
+        }, i * 80);
+        i++;
+      }
+    }
+    // Tell the host which symbols are on screen. Only the primary instance
+    // speaks for the page: duplicated watchlist panels have their own filters,
+    // and the page has one ticker for them to fight over.
+    _publishVisible() {
+      if (!this._host.isPrimary) return;
+      this._host.ticker.publish(this._visible().map((i) => String(i.symbol)), this.stats);
+    }
+    static _priceText(price) {
+      const n = Number(price);
+      if (price == null || !isFinite(n) || n === 0) return "--";
+      if (n >= 1) return n.toFixed(2);
+      if (n >= 0.01) return n.toFixed(4);
+      return n.toFixed(6);
+    }
+    static _changeText(chgPct) {
+      const pct = Number(chgPct);
+      if (chgPct == null || !isFinite(pct)) return "--";
+      return `${pct >= 0 ? "+" : ""}${pct.toFixed(2)}%`;
+    }
+    static _changeClass(chgPct) {
+      const pct = Number(chgPct);
+      if (chgPct == null || !isFinite(pct)) return "";
+      return pct >= 0 ? "up" : "down";
+    }
+  };
+  _WatchlistWidget.FAVORITES_KEY = "terminal_watchlist_favorites";
+  // Cache-key prefix for the per-session baseline price used to compute the
+  // change %. Day-scoped so the baseline resets every UTC day and the
+  // percent matches "since today open" intuitively. (Without a REST bars
+  // endpoint there is no broker-side day-open available, and the watchlist
+  // deliberately avoids REST — the live stream is its only source.) It goes
+  // in the host's cache rather than its preferences: one key per symbol per
+  // day is scratch, not a setting worth syncing.
+  _WatchlistWidget.BASELINE_KEY_PREFIX = "wlBaseline:";
+  _WatchlistWidget.VISIBLE_CAP = 30;
+  _WatchlistWidget.RENDER_CAP = 300;
+  _WatchlistWidget.TYPE = ControlTypes.Watchlist;
+  var WatchlistWidget = _WatchlistWidget;
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=sstradingcontrols.js.map