@luxalgo/vela 0.8.5 → 0.9.1

package/dist/plugin.cjs

@@ -1,6 +1,913 @@
 'use strict';
 
+// src/core/i18n/message.ts
+function msg(id, defaultMessage) {
+  return Object.freeze({ id, defaultMessage });
+}
+function withValues(message, values) {
+  return Object.freeze({ id: message.id, defaultMessage: message.defaultMessage, values: { ...message.values, ...values } });
+}
+
+// src/core/format/numbers.ts
+var BIDI_MARKS = /[‎‏؜]/g;
+function stripBidiMarks(text) {
+  return text.replace(BIDI_MARKS, "");
+}
+var numberFormats = /* @__PURE__ */ new Map();
+function numberFormat(settings, options) {
+  const key = `${settings.locale}|${settings.numberingSystem}|${JSON.stringify(options)}`;
+  let nf = numberFormats.get(key);
+  if (!nf) {
+    try {
+      nf = new Intl.NumberFormat(settings.locale, { ...options, numberingSystem: settings.numberingSystem });
+    } catch {
+      nf = new Intl.NumberFormat("en", options);
+    }
+    numberFormats.set(key, nf);
+  }
+  return nf;
+}
+var symbolCache = /* @__PURE__ */ new Map();
+function numberSymbols(settings) {
+  const key = `${settings.locale}|${settings.numberingSystem}`;
+  let sym = symbolCache.get(key);
+  if (sym) return sym;
+  const parts = numberFormat(settings, { useGrouping: false, minimumFractionDigits: 1, maximumFractionDigits: 1 }).formatToParts(-1.5);
+  const decimal = stripBidiMarks(parts.find((p) => p.type === "decimal")?.value ?? ".") || ".";
+  const minus = stripBidiMarks(parts.find((p) => p.type === "minusSign")?.value ?? "-") || "-";
+  const plain = numberFormat(settings, { useGrouping: false, maximumFractionDigits: 0 });
+  const digits = Array.from({ length: 10 }, (_, d) => stripBidiMarks(plain.format(d)));
+  const ascii = decimal === "." && minus === "-" && digits.every((d, i) => d === String(i));
+  sym = { ascii, decimal, minus, digits };
+  symbolCache.set(key, sym);
+  return sym;
+}
+function localizeAscii(text, settings) {
+  const sym = numberSymbols(settings);
+  if (sym.ascii) return text;
+  let out = "";
+  for (const ch of text) {
+    const code = ch.charCodeAt(0);
+    if (code >= 48 && code <= 57) out += sym.digits[code - 48];
+    else if (ch === ".") out += sym.decimal;
+    else if (ch === "-") out += sym.minus;
+    else out += ch;
+  }
+  return out;
+}
+function localizeDigits(text, settings) {
+  const sym = numberSymbols(settings);
+  if (sym.digits.every((d, i) => d === String(i))) return text;
+  return text.replace(/[0-9]/g, (d) => sym.digits[Number(d)]);
+}
+var clampDecimals = (d) => Number.isFinite(d) ? Math.max(0, Math.min(20, Math.trunc(d))) : 2;
+function formatFixed(value, decimals, settings) {
+  return localizeAscii(value.toFixed(clampDecimals(decimals)), settings);
+}
+function formatGrouped(value, decimals, settings) {
+  const d = clampDecimals(decimals);
+  return stripBidiMarks(numberFormat(settings, { minimumFractionDigits: d, maximumFractionDigits: d }).format(value));
+}
+function formatMessageNumber(value, settings, style) {
+  if (style === "integer") return stripBidiMarks(numberFormat(settings, { maximumFractionDigits: 0 }).format(value));
+  if (style === "percent") return stripBidiMarks(numberFormat(settings, { style: "percent" }).format(value));
+  return stripBidiMarks(numberFormat(settings, {}).format(value));
+}
+function formatPercent(value, options, settings) {
+  const d = clampDecimals(options?.decimals ?? 2);
+  const signed2 = options?.signed ?? true;
+  if (settings.english) {
+    const text = signed2 ? `${value >= 0 ? "+" : "-"}${Math.abs(value).toFixed(d)}%` : `${value.toFixed(d)}%`;
+    return localizeAscii(text, settings);
+  }
+  const nf = numberFormat(settings, { style: "percent", minimumFractionDigits: d, maximumFractionDigits: d, signDisplay: signed2 ? "always" : "auto" });
+  return stripBidiMarks(nf.format(value / 100));
+}
+function formatPrice(value, options, settings) {
+  const mode = options.mode ?? "price";
+  if (mode === "percent") return formatPercent(value, { decimals: options.decimals, signed: true }, settings);
+  if (mode === "indexed" || !options.grouping) return formatFixed(value, options.decimals, settings);
+  return formatGrouped(value, options.decimals, settings);
+}
+var COMPACT_STEPS = [
+  [1e9, "B"],
+  [1e6, "M"],
+  [1e3, "K"]
+];
+function formatCompact(value, options, settings) {
+  const d = clampDecimals(options?.decimals ?? 2);
+  const trim = options?.trimZeros ?? true;
+  if (settings.english) {
+    const a = Math.abs(value);
+    let div = 1;
+    let suffix = "";
+    for (const [step, s] of COMPACT_STEPS) {
+      if (a >= step) {
+        div = step;
+        suffix = s;
+        break;
+      }
+    }
+    const scaled = value / div;
+    const text = trim ? Number(scaled.toFixed(d)).toString() : scaled.toFixed(d);
+    return localizeAscii(text, settings) + suffix;
+  }
+  const nf = numberFormat(settings, { notation: "compact", compactDisplay: "short", maximumFractionDigits: d, minimumFractionDigits: trim ? 0 : d });
+  return stripBidiMarks(nf.format(value));
+}
+
+// src/core/format/dates.ts
+var EN_MONTHS_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var EN_WEEKDAYS_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var pad2 = (n) => n < 10 ? `0${n}` : String(n);
+var DAY_MS = 864e5;
+var zoneParsers = /* @__PURE__ */ new Map();
+function zoneOffsetMs(ms, timeZone) {
+  if (!timeZone || timeZone === "UTC") return 0;
+  let dtf = zoneParsers.get(timeZone);
+  if (dtf === void 0) {
+    try {
+      dtf = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+    } catch {
+      dtf = null;
+    }
+    zoneParsers.set(timeZone, dtf);
+  }
+  if (!dtf) return 0;
+  try {
+    const parts = dtf.formatToParts(new Date(ms));
+    const get = (t) => Number(parts.find((p) => p.type === t)?.value);
+    const asUTC = Date.UTC(get("year"), get("month") - 1, get("day"), get("hour") % 24, get("minute"), get("second"));
+    return asUTC - ms;
+  } catch {
+    return 0;
+  }
+}
+var dateFormats = /* @__PURE__ */ new Map();
+function dateFormat(settings, options) {
+  const key = `${settings.locale}|${settings.numberingSystem}|${JSON.stringify(options)}`;
+  let dtf = dateFormats.get(key);
+  if (!dtf) {
+    const full = { ...options, timeZone: "UTC", calendar: "gregory", numberingSystem: settings.numberingSystem };
+    try {
+      dtf = new Intl.DateTimeFormat(settings.locale, full);
+    } catch {
+      dtf = new Intl.DateTimeFormat("en", { ...options, timeZone: "UTC", calendar: "gregory" });
+    }
+    dateFormats.set(key, dtf);
+  }
+  return dtf;
+}
+function clockOptions(settings) {
+  if (settings.hourCycle === "h23") return { hour: "2-digit", minute: "2-digit", hourCycle: "h23" };
+  if (settings.hourCycle === "h12") return { hour: "numeric", minute: "2-digit", hourCycle: "h12" };
+  return { hour: "numeric", minute: "2-digit" };
+}
+function englishClock(wall, settings) {
+  if (settings.hourCycle === "h23") return localizeAscii(`${pad2(wall.getUTCHours())}:${pad2(wall.getUTCMinutes())}`, settings);
+  return stripBidiMarks(dateFormat(settings, clockOptions(settings)).format(wall));
+}
+var TICK_OPTIONS = {
+  year: { year: "numeric" },
+  month: { month: "short" },
+  day: { month: "short", day: "numeric" }
+};
+var isClockUnit = (unit) => unit === "hour" || unit === "minute" || unit === "second";
+function formatTimeTick(ms, options, settings) {
+  const wall = new Date(ms + (options.offsetMs ?? 0));
+  const unit = options.unit;
+  if (settings.english) {
+    if (isClockUnit(unit)) return englishClock(wall, settings);
+    const month = EN_MONTHS_SHORT[wall.getUTCMonth()];
+    if (unit === "year") return localizeAscii(String(wall.getUTCFullYear()), settings);
+    if (unit === "month") return month;
+    return localizeAscii(`${month} ${wall.getUTCDate()}`, settings);
+  }
+  const opts = isClockUnit(unit) ? clockOptions(settings) : TICK_OPTIONS[unit];
+  return stripBidiMarks(dateFormat(settings, opts).format(wall));
+}
+function formatTimeStamp(ms, options, settings) {
+  const wall = new Date(ms + zoneOffsetMs(ms, options?.timeZone ?? "UTC"));
+  const withTime = options?.withTime ?? true;
+  if (settings.english) {
+    const date = localizeAscii(
+      `${EN_WEEKDAYS_SHORT[wall.getUTCDay()]} ${wall.getUTCDate()} ${EN_MONTHS_SHORT[wall.getUTCMonth()]} '${pad2(wall.getUTCFullYear() % 100)}`,
+      settings
+    );
+    return withTime ? `${date} ${englishClock(wall, settings)}` : date;
+  }
+  const opts = { weekday: "short", day: "numeric", month: "short", year: "2-digit", ...withTime ? clockOptions(settings) : {} };
+  return stripBidiMarks(dateFormat(settings, opts).format(wall));
+}
+function countdownText(ms) {
+  const total = Math.max(0, Math.ceil(ms / 1e3));
+  const s = total % 60;
+  const m = Math.floor(total / 60) % 60;
+  const h = Math.floor(total / 3600);
+  const pad = (v) => String(v).padStart(2, "0");
+  return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${pad(m)}:${pad(s)}`;
+}
+function spanParts(ms) {
+  const m = Math.abs(ms);
+  const HR = 36e5;
+  const MIN2 = 6e4;
+  if (m >= DAY_MS) {
+    const d = Math.floor(m / DAY_MS);
+    const h = Math.round(m % DAY_MS / HR);
+    return h ? [[d, "day"], [h, "hour"]] : [[d, "day"]];
+  }
+  if (m >= HR) {
+    const h = Math.floor(m / HR);
+    const mn = Math.round(m % HR / MIN2);
+    return mn ? [[h, "hour"], [mn, "minute"]] : [[h, "hour"]];
+  }
+  if (m >= MIN2) return [[Math.round(m / MIN2), "minute"]];
+  return [[Math.round(m / 1e3), "second"]];
+}
+var EN_UNIT = { day: "d", hour: "h", minute: "m", second: "s" };
+function formatDuration(ms, options, settings) {
+  if ((options?.style ?? "countdown") === "countdown") return localizeDigits(countdownText(ms), settings);
+  const parts = spanParts(ms);
+  if (settings.english) return localizeDigits(parts.map(([n, u]) => `${n}${EN_UNIT[u]}`).join(" "), settings);
+  return parts.map(([n, unit]) => stripBidiMarks(numberFormat(settings, { style: "unit", unit, unitDisplay: "narrow" }).format(n))).join(" ");
+}
+var clockFormats = /* @__PURE__ */ new Map();
+function formatClock(ms, options, settings) {
+  const timeZone = options?.timeZone ?? "UTC";
+  const seconds = options?.seconds ?? true;
+  const english2 = settings.english && settings.hourCycle === "h23";
+  const key = `${english2 ? "en-GB" : settings.locale}|${settings.numberingSystem}|${settings.hourCycle}|${timeZone}|${seconds}`;
+  let dtf = clockFormats.get(key);
+  if (dtf === void 0) {
+    const base = { hour: "2-digit", minute: "2-digit", ...seconds ? { second: "2-digit" } : {}, timeZone };
+    try {
+      dtf = english2 ? new Intl.DateTimeFormat("en-GB", { ...base, hour12: false }) : new Intl.DateTimeFormat(settings.locale, {
+        ...base,
+        calendar: "gregory",
+        numberingSystem: settings.numberingSystem,
+        ...settings.hourCycle === "locale" ? {} : { hourCycle: settings.hourCycle }
+      });
+    } catch {
+      dtf = null;
+    }
+    clockFormats.set(key, dtf);
+  }
+  if (!dtf) return "";
+  try {
+    return stripBidiMarks(dtf.format(new Date(ms)));
+  } catch {
+    return "";
+  }
+}
+
+// src/core/format/formatters.ts
+function builtinFormatters(settings) {
+  return {
+    price: (value, options) => formatPrice(value, options, settings),
+    percent: (value, options) => formatPercent(value, options, settings),
+    compact: (value, options) => formatCompact(value, options, settings),
+    timeTick: (ms, options) => formatTimeTick(ms, options, settings),
+    timeStamp: (ms, options) => formatTimeStamp(ms, options, settings),
+    duration: (ms, options) => formatDuration(ms, options, settings),
+    clock: (ms, options) => formatClock(ms, options, settings)
+  };
+}
+var ENGLISH_SETTINGS = Object.freeze({ locale: "en", numberingSystem: "latn", hourCycle: "h23", english: true });
+var warned = false;
+function viaHost(host, value, ctx, fallback) {
+  try {
+    const out = host(value, ctx);
+    if (typeof out === "string") return out;
+  } catch (err) {
+    if (!warned) {
+      warned = true;
+      console.warn("[vela] a host formatter threw; the built-in formatting is used instead.", err);
+    }
+  }
+  return fallback();
+}
+function resolveFormatters(settings, overrides) {
+  const base = builtinFormatters(settings);
+  if (!overrides) return base;
+  const ctx = (surface, defaultSurface, timeZone, fallback) => ({
+    locale: settings.locale,
+    timeZone: timeZone ?? "UTC",
+    surface: surface ?? defaultSurface,
+    fallback
+  });
+  const o = overrides;
+  return {
+    price(value, options) {
+      const fallback = () => base.price(value, options);
+      if (typeof o.price !== "function") return fallback();
+      return viaHost(o.price, value, { ...ctx(options.surface, "priceAxis", void 0, fallback), decimals: options.decimals, mintick: options.mintick, mode: options.mode ?? "price", paneId: options.paneId, grouping: options.grouping ?? false }, fallback);
+    },
+    percent(value, options) {
+      const fallback = () => base.percent(value, options);
+      if (typeof o.percent !== "function") return fallback();
+      return viaHost(o.percent, value, { ...ctx(options?.surface, "statusLine", void 0, fallback), decimals: options?.decimals ?? 2, signed: options?.signed ?? true }, fallback);
+    },
+    compact(value, options) {
+      const fallback = () => base.compact(value, options);
+      if (typeof o.compact !== "function") return fallback();
+      return viaHost(o.compact, value, { ...ctx(options?.surface, "priceAxis", void 0, fallback), decimals: options?.decimals ?? 2, trimZeros: options?.trimZeros ?? true }, fallback);
+    },
+    timeTick(ms, options) {
+      const fallback = () => base.timeTick(ms, options);
+      if (typeof o.timeTick !== "function") return fallback();
+      return viaHost(o.timeTick, ms, { ...ctx(options.surface, "timeAxis", options.timeZone, fallback), unit: options.unit, major: options.major, offsetMs: options.offsetMs ?? 0 }, fallback);
+    },
+    timeStamp(ms, options) {
+      const fallback = () => base.timeStamp(ms, options);
+      if (typeof o.timeStamp !== "function") return fallback();
+      return viaHost(o.timeStamp, ms, { ...ctx(options?.surface, "crosshair", options?.timeZone, fallback), withTime: options?.withTime ?? true }, fallback);
+    },
+    duration(ms, options) {
+      const fallback = () => base.duration(ms, options);
+      if (typeof o.duration !== "function") return fallback();
+      return viaHost(o.duration, ms, { ...ctx(options?.surface, "lastPrice", void 0, fallback), style: options?.style ?? "countdown" }, fallback);
+    },
+    clock(ms, options) {
+      const fallback = () => base.clock(ms, options);
+      if (typeof o.clock !== "function") return fallback();
+      return viaHost(o.clock, ms, { ...ctx(options?.surface, "clock", options?.timeZone, fallback), seconds: options?.seconds ?? true }, fallback);
+    }
+  };
+}
+
+// src/core/i18n/icu.ts
+var Parser = class {
+  constructor(src) {
+    this.src = src;
+    this.i = 0;
+  }
+  parse() {
+    const nodes = this.message(false, 0);
+    if (this.i < this.src.length) throw this.error("unmatched }");
+    return nodes;
+  }
+  error(what) {
+    return new SyntaxError(`[vela] message syntax: ${what} at ${this.i} in "${this.src}"`);
+  }
+  /** Text and arguments up to an unmatched `}` (left unread) or the end. */
+  message(inPlural, depth) {
+    if (depth > 8) throw this.error("nesting too deep");
+    const src = this.src;
+    const out = [];
+    let text = "";
+    const flush = () => {
+      if (text) out.push(text);
+      text = "";
+    };
+    while (this.i < src.length) {
+      const ch = src[this.i];
+      if (ch === "'") {
+        const next = src[this.i + 1];
+        if (next === "'") {
+          text += "'";
+          this.i += 2;
+        } else if (next === "{" || next === "}" || inPlural && next === "#") {
+          this.i += 1;
+          while (this.i < src.length) {
+            const c = src[this.i];
+            if (c === "'") {
+              if (src[this.i + 1] === "'") {
+                text += "'";
+                this.i += 2;
+                continue;
+              }
+              this.i += 1;
+              break;
+            }
+            text += c;
+            this.i += 1;
+          }
+        } else {
+          text += "'";
+          this.i += 1;
+        }
+      } else if (ch === "{") {
+        flush();
+        this.i += 1;
+        out.push(this.argument(depth));
+      } else if (ch === "}") {
+        break;
+      } else if (ch === "#" && inPlural) {
+        flush();
+        out.push({ kind: "pound" });
+        this.i += 1;
+      } else {
+        text += ch;
+        this.i += 1;
+      }
+    }
+    flush();
+    return out;
+  }
+  skipSpace() {
+    while (this.i < this.src.length && /\s/.test(this.src[this.i])) this.i += 1;
+  }
+  word() {
+    this.skipSpace();
+    const start = this.i;
+    while (this.i < this.src.length && !/[\s,{}]/.test(this.src[this.i])) this.i += 1;
+    return this.src.slice(start, this.i);
+  }
+  expect(ch) {
+    this.skipSpace();
+    if (this.src[this.i] !== ch) throw this.error(`expected "${ch}"`);
+    this.i += 1;
+  }
+  /** After a `{`: the argument through its closing `}`. */
+  argument(depth) {
+    const name = this.word();
+    if (!name) throw this.error("empty argument name");
+    this.skipSpace();
+    if (this.src[this.i] === "}") {
+      this.i += 1;
+      return { kind: "arg", name };
+    }
+    this.expect(",");
+    const type = this.word();
+    this.skipSpace();
+    if (type === "number") {
+      let style;
+      if (this.src[this.i] === ",") {
+        this.i += 1;
+        style = this.word() || void 0;
+      }
+      this.expect("}");
+      return { kind: "arg", name, format: "number", style };
+    }
+    if (type === "plural" || type === "selectordinal" || type === "select") {
+      this.expect(",");
+      let offset = 0;
+      this.skipSpace();
+      if (type !== "select" && this.src.startsWith("offset:", this.i)) {
+        this.i += "offset:".length;
+        offset = Number(this.word());
+        if (!Number.isFinite(offset)) throw this.error("bad offset");
+      }
+      const options = {};
+      for (; ; ) {
+        this.skipSpace();
+        if (this.src[this.i] === "}") {
+          this.i += 1;
+          break;
+        }
+        const key = this.word();
+        if (!key) throw this.error("expected a selector");
+        this.expect("{");
+        options[key] = this.message(type !== "select", depth + 1);
+        this.expect("}");
+      }
+      if (!options.other) throw this.error(`"${name}" has no "other" option`);
+      return type === "select" ? { kind: "select", name, options } : { kind: "plural", name, ordinal: type === "selectordinal", offset, options };
+    }
+    throw this.error(`unknown argument type "${type}"`);
+  }
+};
+var parsed = /* @__PURE__ */ new Map();
+var PARSE_CACHE_CAP = 2e3;
+function parseMessage(source) {
+  let nodes = parsed.get(source);
+  if (!nodes) {
+    nodes = new Parser(source).parse();
+    if (parsed.size >= PARSE_CACHE_CAP) parsed.clear();
+    parsed.set(source, nodes);
+  }
+  return nodes;
+}
+var pluralRules = /* @__PURE__ */ new Map();
+function rulesFor(locale, ordinal) {
+  const key = `${locale}|${ordinal ? "o" : "c"}`;
+  let pr = pluralRules.get(key);
+  if (!pr) {
+    try {
+      pr = new Intl.PluralRules(locale, { type: ordinal ? "ordinal" : "cardinal" });
+    } catch {
+      pr = new Intl.PluralRules("en", { type: ordinal ? "ordinal" : "cardinal" });
+    }
+    pluralRules.set(key, pr);
+  }
+  return pr;
+}
+function render(nodes, values, rt, pound) {
+  let out = "";
+  for (const node of nodes) {
+    if (typeof node === "string") {
+      out += node;
+      continue;
+    }
+    if (node.kind === "pound") {
+      out += pound == null ? "#" : rt.formatNumber(pound);
+      continue;
+    }
+    const raw = values?.[node.name];
+    if (node.kind === "arg") {
+      if (raw === void 0) out += `{${node.name}}`;
+      else if (typeof raw === "number") out += rt.formatNumber(raw, node.format === "number" ? node.style : void 0);
+      else if (node.format === "number" && raw.trim() !== "" && Number.isFinite(Number(raw))) out += rt.formatNumber(Number(raw), node.style);
+      else out += raw;
+      continue;
+    }
+    if (node.kind === "select") {
+      const branch2 = node.options[String(raw)] ?? node.options.other;
+      out += render(branch2, values, rt, pound);
+      continue;
+    }
+    const n = typeof raw === "number" ? raw : Number(raw);
+    let branch;
+    if (Number.isFinite(n)) {
+      branch = node.options[`=${n}`] ?? node.options[rulesFor(rt.locale, node.ordinal).select(n - node.offset)];
+    }
+    out += render(branch ?? node.options.other, values, rt, Number.isFinite(n) ? n - node.offset : null);
+  }
+  return out;
+}
+function formatMessage(source, values, rt) {
+  if (source.indexOf("{") < 0 && source.indexOf("'") < 0) return source;
+  return render(parseMessage(source), values, rt, null);
+}
+
+// src/core/format/calendar.ts
+var SUNDAY_REGIONS = /* @__PURE__ */ new Set([
+  "AG",
+  "AS",
+  "BD",
+  "BR",
+  "BS",
+  "BT",
+  "BW",
+  "BZ",
+  "CA",
+  "CN",
+  "CO",
+  "DM",
+  "DO",
+  "ET",
+  "GT",
+  "GU",
+  "HK",
+  "HN",
+  "ID",
+  "IL",
+  "IN",
+  "JM",
+  "JP",
+  "KE",
+  "KH",
+  "KR",
+  "LA",
+  "MH",
+  "MM",
+  "MO",
+  "MT",
+  "MX",
+  "MZ",
+  "NI",
+  "NP",
+  "PA",
+  "PE",
+  "PH",
+  "PK",
+  "PR",
+  "PT",
+  "PY",
+  "SA",
+  "SG",
+  "SV",
+  "TH",
+  "TT",
+  "TW",
+  "UM",
+  "US",
+  "VE",
+  "VI",
+  "WS",
+  "YE",
+  "ZA",
+  "ZW"
+]);
+var SATURDAY_REGIONS = /* @__PURE__ */ new Set(["AE", "AF", "BH", "DJ", "DZ", "EG", "IQ", "IR", "JO", "KW", "LY", "OM", "QA", "SD", "SY"]);
+function localeWeekStart(locale) {
+  let loc;
+  try {
+    loc = new Intl.Locale(locale);
+  } catch {
+    return 1;
+  }
+  try {
+    const wl = loc;
+    const info = typeof wl.getWeekInfo === "function" ? wl.getWeekInfo() : wl.weekInfo;
+    const firstDay = info?.firstDay;
+    if (typeof firstDay === "number") return firstDay === 7 ? 0 : firstDay === 6 ? 6 : 1;
+  } catch {
+  }
+  let region = loc.region;
+  if (!region) {
+    try {
+      region = loc.maximize().region;
+    } catch {
+      region = void 0;
+    }
+  }
+  if (region && SUNDAY_REGIONS.has(region)) return 0;
+  if (region && SATURDAY_REGIONS.has(region)) return 6;
+  return 1;
+}
+
+// src/core/i18n/locale.ts
+function canonicalLocale(tag) {
+  const raw = typeof tag === "string" ? tag.trim() : "";
+  if (!raw) return "en";
+  try {
+    return Intl.getCanonicalLocales(raw)[0] ?? raw;
+  } catch {
+    return raw;
+  }
+}
+function parseLocale(tag) {
+  try {
+    return new Intl.Locale(tag);
+  } catch {
+    return null;
+  }
+}
+function languageOf(tag) {
+  return (parseLocale(tag)?.language ?? tag.split(/[-_]/)[0] ?? tag).toLowerCase();
+}
+function fallbackChain(tag) {
+  const out = [];
+  const add = (t) => {
+    if (t && !out.includes(t)) out.push(t);
+  };
+  add(tag);
+  const loc = parseLocale(tag);
+  if (loc) {
+    const base = loc.baseName;
+    add(base);
+    const parts = base.split("-");
+    let impliedScript;
+    if (!loc.script) {
+      try {
+        impliedScript = loc.maximize().script;
+      } catch {
+        impliedScript = void 0;
+      }
+    }
+    for (let i = parts.length - 1; i >= 1; i -= 1) {
+      if (i === 1 && impliedScript && loc.region) add(`${loc.language}-${impliedScript}`);
+      add(parts.slice(0, i).join("-"));
+    }
+    if (impliedScript && !loc.region) add(`${loc.language}-${impliedScript}`);
+    try {
+      const usual = new Intl.Locale(loc.language).maximize();
+      if (usual.region && usual.script === (loc.script ?? impliedScript)) add(`${loc.language}-${usual.region}`);
+    } catch {
+    }
+  }
+  add("en");
+  return out;
+}
+var RTL_SCRIPTS = /* @__PURE__ */ new Set(["Arab", "Hebr", "Thaa", "Syrc", "Nkoo", "Adlm", "Rohg", "Mand", "Samr", "Yezi"]);
+var RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "he", "iw", "fa", "ur", "ps", "sd", "ug", "yi", "dv", "ckb", "ks"]);
+function localeDirection(tag) {
+  const loc = parseLocale(tag);
+  if (loc) {
+    try {
+      const tl = loc;
+      const info = typeof tl.getTextInfo === "function" ? tl.getTextInfo() : tl.textInfo;
+      if (info?.direction === "rtl" || info?.direction === "ltr") return info.direction;
+    } catch {
+    }
+    try {
+      const script = loc.script ?? loc.maximize().script;
+      if (script) return RTL_SCRIPTS.has(script) ? "rtl" : "ltr";
+    } catch {
+    }
+  }
+  return RTL_LANGUAGES.has(languageOf(tag)) ? "rtl" : "ltr";
+}
+var numberingCache = /* @__PURE__ */ new Map();
+function resolveNumberingSystem(tag, requested) {
+  const key = `${tag}|${requested ?? ""}`;
+  const cached = numberingCache.get(key);
+  if (cached) return cached;
+  let nu = "latn";
+  try {
+    if (requested === "locale") nu = new Intl.NumberFormat(tag).resolvedOptions().numberingSystem;
+    else if (requested) nu = new Intl.NumberFormat(tag, { numberingSystem: requested }).resolvedOptions().numberingSystem;
+    else {
+      const ext = parseLocale(tag)?.numberingSystem;
+      if (ext) nu = new Intl.NumberFormat(tag).resolvedOptions().numberingSystem;
+    }
+  } catch {
+    nu = "latn";
+  }
+  numberingCache.set(key, nu);
+  return nu;
+}
+
+// src/core/i18n/registry.ts
+var entries = [];
+var version = 0;
+var merged = /* @__PURE__ */ new Map();
+function registerLocale(pack) {
+  if (!pack || typeof pack.locale !== "string" || !pack.messages || typeof pack.messages !== "object") {
+    throw new TypeError("[vela] registerLocale expects { locale: string, messages: Record<string, string> }");
+  }
+  const entry = { tag: canonicalLocale(pack.locale), messages: pack.messages };
+  entries.push(entry);
+  version += 1;
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    const i = entries.indexOf(entry);
+    if (i >= 0) {
+      entries.splice(i, 1);
+      version += 1;
+    }
+  };
+}
+function registeredLocales() {
+  return [...new Set(entries.map((e) => e.tag))];
+}
+function messagesFor(chain) {
+  const key = chain.join("|");
+  const hit = merged.get(key);
+  if (hit && hit.version === version) return hit.map;
+  const map = /* @__PURE__ */ new Map();
+  for (let c = chain.length - 1; c >= 0; c -= 1) {
+    const tag = chain[c];
+    for (const e of entries) {
+      if (e.tag !== tag) continue;
+      for (const [id, text] of Object.entries(e.messages)) {
+        if (typeof text === "string") map.set(id, text);
+      }
+    }
+  }
+  merged.set(key, { version, map });
+  return map;
+}
+
+// src/core/i18n/translator.ts
+function isMessageDescriptor(m) {
+  return typeof m === "object" && m !== null && typeof m.id === "string" && typeof m.defaultMessage === "string";
+}
+var warnedSyntax = false;
+function resolveArgs(args, resolve) {
+  if (!args) return void 0;
+  let out = null;
+  for (const key of Object.keys(args)) {
+    const v = args[key];
+    if (typeof v === "object" && v !== null) {
+      out ?? (out = { ...args });
+      out[key] = resolve(v);
+    }
+  }
+  return out ?? args;
+}
+var LocaleState = class {
+  constructor(options = {}) {
+    this.runtime = {
+      locale: "en",
+      formatNumber: (value, style) => formatMessageNumber(value, this.settings, style)
+    };
+    this.opts = { ...options };
+    this.resolve();
+  }
+  /** The options as last set (unresolved). */
+  get options() {
+    return this.opts;
+  }
+  /** Whether the host chose a locale; Vela stamps `lang` only then. */
+  get localeExplicit() {
+    return this.opts.locale !== void 0;
+  }
+  /** Whether the host chose a direction; Vela stamps `dir` only then. */
+  get directionExplicit() {
+    return this.opts.direction !== void 0;
+  }
+  /** Apply a change: fields present in `next` replace (an explicit `undefined` restores
+   *  the default), absent fields keep their current value. */
+  update(next) {
+    const patch = typeof next === "string" ? { locale: next } : next;
+    this.opts = { ...this.opts, ...patch };
+    for (const key of Object.keys(this.opts)) {
+      if (this.opts[key] === void 0) delete this.opts[key];
+    }
+    this.resolve();
+  }
+  resolve() {
+    const o = this.opts;
+    const locale = canonicalLocale(o.locale);
+    const numberingSystem = resolveNumberingSystem(locale, o.numberingSystem);
+    const hourCycle = o.hourCycle === "h12" || o.hourCycle === "locale" ? o.hourCycle : "h23";
+    this.settings = { locale, numberingSystem, hourCycle, english: languageOf(locale) === "en" };
+    this.chain = fallbackChain(locale);
+    this.resolvedDirection = o.direction === "rtl" || o.direction === "ltr" ? o.direction : o.direction === "auto" ? localeDirection(locale) : "ltr";
+    this.resolvedWeekStart = o.weekStart === 0 || o.weekStart === 1 || o.weekStart === 6 ? o.weekStart : localeWeekStart(locale);
+    this.runtime.locale = locale;
+    this.formatters = resolveFormatters(this.settings, o.formatters);
+  }
+  get locale() {
+    return this.settings.locale;
+  }
+  get direction() {
+    return this.resolvedDirection;
+  }
+  get numberingSystem() {
+    return this.settings.numberingSystem;
+  }
+  get hourCycle() {
+    return this.settings.hourCycle;
+  }
+  get weekStart() {
+    return this.resolvedWeekStart;
+  }
+  get format() {
+    return this.formatters;
+  }
+  /** The resolved settings the built-in formatters and calendar helpers read. */
+  get formatSettings() {
+    return this.settings;
+  }
+  t(message, args) {
+    if (typeof message === "string") return message;
+    if (!isMessageDescriptor(message)) return message == null ? "" : String(message);
+    const { id, defaultMessage } = message;
+    const bound = message.values;
+    const values = resolveArgs(bound ? args ? { ...bound, ...args } : bound : args, (m) => this.t(m));
+    const override = this.opts.messages?.[id];
+    const source = typeof override === "string" ? override : messagesFor(this.chain).get(id) ?? defaultMessage;
+    try {
+      return formatMessage(source, values, this.runtime);
+    } catch (err) {
+      if (!warnedSyntax) {
+        warnedSyntax = true;
+        console.warn(`[vela] message "${id}" could not be formatted; the English text is used instead.`, err);
+      }
+      if (source === defaultMessage) return defaultMessage;
+      try {
+        return formatMessage(defaultMessage, values, this.runtime);
+      } catch {
+        return defaultMessage;
+      }
+    }
+  }
+};
+function createTranslator(options) {
+  return new LocaleState(options);
+}
+var english = null;
+function englishTranslator() {
+  english ?? (english = new LocaleState());
+  return english;
+}
+function formatSettingsOf(i18n) {
+  if (i18n instanceof LocaleState) return i18n.formatSettings;
+  if (!i18n) return englishTranslator().formatSettings;
+  return { locale: i18n.locale, numberingSystem: i18n.numberingSystem, hourCycle: i18n.hourCycle, english: languageOf(i18n.locale) === "en" };
+}
+
+// src/core/i18n/text.ts
+var ENGLISH_RUNTIME = {
+  locale: "en",
+  formatNumber: (value, style) => formatMessageNumber(value, ENGLISH_SETTINGS, style)
+};
+function sourceText(message, values) {
+  if (message == null) return "";
+  if (typeof message === "string") return message;
+  if (!isMessageDescriptor(message)) return String(message);
+  const bound = message.values;
+  const all = resolveArgs(bound ? bound : values, (m) => sourceText(m));
+  try {
+    return formatMessage(message.defaultMessage, all, ENGLISH_RUNTIME);
+  } catch {
+    return message.defaultMessage;
+  }
+}
+function textOf(i18n, message, values) {
+  return (i18n ?? englishTranslator()).t(message, values);
+}
+function localizeNumberText(text, i18n) {
+  return localizeAscii(text, formatSettingsOf(i18n));
+}
+
 // src/chart-types/registry.ts
+var RANGE_MIN = msg("chart.settings.rangeMin", "{label} — min");
+var RANGE_MAX = msg("chart.settings.rangeMax", "{label} — max");
 function normalizeSettingsRow(r) {
   switch (r.kind) {
     case "row":
@@ -22,9 +929,9 @@ function normalizeSettingsRow(r) {
       return {
         label: r.label,
         controls: [
-          { kind: "number", key: r.minKey, label: `${r.label} \u2014 min`, defval: r.defval, min: r.min, max: r.max, step: r.step, placeholder: r.placeholder },
-          { kind: "hint", text: "\u2013" },
-          { kind: "number", key: r.maxKey, label: `${r.label} \u2014 max`, defval: r.defval, min: r.min, max: r.max, step: r.step, placeholder: r.placeholder }
+          { kind: "number", key: r.minKey, label: withValues(RANGE_MIN, { label: r.label }), defval: r.defval, min: r.min, max: r.max, step: r.step, placeholder: r.placeholder },
+          { kind: "hint", text: "–" },
+          { kind: "number", key: r.maxKey, label: withValues(RANGE_MAX, { label: r.label }), defval: r.defval, min: r.min, max: r.max, step: r.step, placeholder: r.placeholder }
         ],
         when: r.when
       };
@@ -84,8 +991,15 @@ function registerNativeIndicator(descriptor) {
 function unregisterNativeIndicator(type) {
   REGISTRY.delete(type);
 }
-function getNativeIndicator(type) {
-  return REGISTRY.get(type);
+function resolved(d, i18n) {
+  if (typeof d.title === "string" && (d.shortTitle === void 0 || typeof d.shortTitle === "string")) return d;
+  const names = { title: textOf(i18n, d.title) };
+  if (d.shortTitle !== void 0) names.shortTitle = textOf(i18n, d.shortTitle);
+  return Object.assign(Object.create(d), names);
+}
+function getNativeIndicator(type, i18n) {
+  const d = REGISTRY.get(type);
+  return d ? resolved(d, i18n) : void 0;
 }
 function nativeIndicatorTypes() {
   return [...REGISTRY.keys()];
@@ -144,7 +1058,7 @@ function topbarActionOverride(id) {
 }
 function registerWidgetAction(desc) {
   if (builtinTopbarSet.has(desc.id) && !overridableSet.has(desc.id)) {
-    console.warn(`[vela] widget action "${desc.id}": this built-in topbar slot is a stateful control and cannot be overridden \u2014 ignored. Overridable slots: ${OVERRIDABLE_TOPBAR_IDS.join(", ")}.`);
+    console.warn(`[vela] widget action "${desc.id}": this built-in topbar slot is a stateful control and cannot be overridden — ignored. Overridable slots: ${OVERRIDABLE_TOPBAR_IDS.join(", ")}.`);
     return () => void 0;
   }
   registry3.set(desc.id, desc);
@@ -222,12 +1136,11 @@ function unregisterDefaultEngine(language) {
 function resolveEngines(overrides) {
   return { ...Object.fromEntries(defaultEngines), ...overrides };
 }
-
-// src/widget/context-menu-model.ts
 var CONTEXT_MENU_BUILTIN_ORDER = {
   body: { "reset-view": -30, "remove-drawings": -20, "remove-indicators": -10, settings: 1e3 },
   "price-axis": {
     auto: -80,
+    "price-only": -75,
     invert: -70,
     "scale:regular": -60,
     "scale:percent": -50,
@@ -397,13 +1310,11 @@ registerIcon(
   "send-back",
   svg24('<rect x="8.5" y="8.5" width="7" height="7" rx="1.5" fill="currentColor" stroke="none" opacity="0.35"/><path d="M4.5 10.5V6a1.5 1.5 0 0 1 1.5-1.5h4.5"/><path d="M19.5 13.5V18a1.5 1.5 0 0 1-1.5 1.5h-4.5"/><rect x="8.5" y="8.5" width="7" height="7" rx="1.5"/>')
 );
-registerIcon("r-squared", '<svg viewBox="0 0 24 24" width="1em" height="1em" fill="currentColor" stroke="none"><text x="2.5" y="17.5" font-size="14" font-family="serif">R\xB2</text></svg>');
+registerIcon("r-squared", '<svg viewBox="0 0 24 24" width="1em" height="1em" fill="currentColor" stroke="none"><text x="2.5" y="17.5" font-size="14" font-family="serif">R²</text></svg>');
 registerIcon("bands", svg24('<path d="M3 6h18"/><path d="M3 18h18"/><path d="M3 12h18" stroke-dasharray="3 3"/>'));
 registerIcon("dedekind", svg24('<path d="M2 20h20"/><path d="M4 20a8 8 0 0 1 16 0"/><path d="M8 20a4 4 0 0 1 8 0"/><path d="M12 4v16"/>'));
 registerIcon("sonic", svg24('<circle cx="15" cy="12" r="4"/><circle cx="12" cy="12" r="2.5"/><path d="M8 5v14"/>'));
 registerIcon("supersonic", svg24('<circle cx="16" cy="12" r="3.5"/><path d="M6 12 15 6M6 12 15 18"/>'));
-
-// src/widget/side-panel.ts
 var DEFAULT_PANEL_WIDTH = 280;
 var DEFAULT_PANEL_MIN_WIDTH = 200;
 var DEFAULT_PANEL_MAX_WIDTH = 640;
@@ -458,15 +1369,15 @@ var MIN = 6e4;
 var HOUR = 60 * MIN;
 var DAY = 24 * HOUR;
 var TIMEFRAME_BANDS = [
-  { key: "s", label: "Sec", fromMs: 0 },
-  { key: "1", label: "1m", fromMs: MIN },
-  { key: "5", label: "5m", fromMs: 5 * MIN },
-  { key: "15", label: "15m", fromMs: 15 * MIN },
-  { key: "60", label: "1H", fromMs: HOUR },
-  { key: "240", label: "4H", fromMs: 4 * HOUR },
-  { key: "D", label: "D", fromMs: DAY },
-  { key: "W", label: "W", fromMs: 7 * DAY },
-  { key: "M", label: "M", fromMs: 28 * DAY }
+  { key: "s", label: msg("drawing.showOn.seconds", "Sec"), fromMs: 0 },
+  { key: "1", label: msg("drawing.showOn.minute1", "1m"), fromMs: MIN },
+  { key: "5", label: msg("drawing.showOn.minute5", "5m"), fromMs: 5 * MIN },
+  { key: "15", label: msg("drawing.showOn.minute15", "15m"), fromMs: 15 * MIN },
+  { key: "60", label: msg("drawing.showOn.hour1", "1H"), fromMs: HOUR },
+  { key: "240", label: msg("drawing.showOn.hour4", "4H"), fromMs: 4 * HOUR },
+  { key: "D", label: msg("drawing.showOn.day", "D"), fromMs: DAY },
+  { key: "W", label: msg("drawing.showOn.week", "W"), fromMs: 7 * DAY },
+  { key: "M", label: msg("drawing.showOn.month", "M"), fromMs: 28 * DAY }
 ];
 var BAND_KEYS = new Set(TIMEFRAME_BANDS.map((b) => b.key));
 function sanitizeShowOn(v) {
@@ -546,6 +1457,12 @@ var _Drawing = class _Drawing {
     }
     return { min: lo, max: hi };
   }
+  /** The text a fresh drawing of this type starts with ("Note", "Callout"), as a message,
+   *  or null for a type that seeds none. A new drawing stores its English source; the chart
+   *  that places one interactively writes it in its own language instead. */
+  placeholderText() {
+    return null;
+  }
   /**
    * Editable per-level config for a rich "gear" settings panel (Fibonacci levels):
    * each entry's `color` / `enabled` / `label` is mutated via a `levels.<i>.<field>`
@@ -612,28 +1529,33 @@ function setByPath(obj, path, value) {
 
 // src/core/drawings/schema.ts
 var LINE_STYLE_OPTIONS = [
-  { value: "solid", label: "Solid" },
-  { value: "dashed", label: "Dashed" },
-  { value: "dotted", label: "Dotted" }
+  { value: "solid", label: msg("drawing.option.solid", "Solid") },
+  { value: "dashed", label: msg("drawing.option.dashed", "Dashed") },
+  { value: "dotted", label: msg("drawing.option.dotted", "Dotted") }
 ];
 var LINE_FIELDS = [
-  { path: "style.lineColor", label: "Line color", kind: "color", group: "line" },
-  { path: "style.lineWidth", label: "Line width", kind: "number", min: 1, max: 10, step: 1, group: "line" },
-  { path: "style.lineStyle", label: "Line style", kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" }
+  { path: "style.lineColor", label: msg("drawing.field.lineColor", "Line color"), kind: "color", group: "line" },
+  { path: "style.lineWidth", label: msg("drawing.field.lineWidth", "Line width"), kind: "number", min: 1, max: 10, step: 1, group: "line" },
+  { path: "style.lineStyle", label: msg("drawing.field.lineStyle", "Line style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" }
+];
+var BORDER_FIELDS = [
+  { path: "style.lineColor", label: msg("drawing.field.borderColor", "Border color"), kind: "color", group: "line" },
+  { path: "style.lineWidth", label: msg("drawing.field.borderWidth", "Border width"), kind: "number", min: 1, max: 10, step: 1, group: "line" },
+  { path: "style.lineStyle", label: msg("drawing.field.borderStyle", "Border style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" }
 ];
-var FILL_FIELDS = [{ path: "style.fillColor", label: "Fill color", kind: "color", group: "fill" }];
+var FILL_FIELDS = [{ path: "style.fillColor", label: msg("drawing.field.fillColor", "Fill color"), kind: "color", group: "fill" }];
 var TEXT_SIZE_OPTIONS = [
-  { value: "small", label: "Small" },
-  { value: "normal", label: "Normal" },
-  { value: "large", label: "Large" },
-  { value: "huge", label: "Huge" }
+  { value: "small", label: msg("drawing.option.small", "Small") },
+  { value: "normal", label: msg("drawing.option.normal", "Normal") },
+  { value: "large", label: msg("drawing.option.large", "Large") },
+  { value: "huge", label: msg("drawing.option.huge", "Huge") }
 ];
 var TEXT_FIELDS = [
-  { path: "text.value", label: "Text", kind: "text", group: "text" },
-  { path: "text.color", label: "Text color", kind: "color", group: "text" },
-  { path: "text.size", label: "Text size", kind: "select", options: TEXT_SIZE_OPTIONS, group: "text" },
-  { path: "text.bold", label: "Bold", kind: "boolean", group: "text" },
-  { path: "text.italic", label: "Italic", kind: "boolean", group: "text" }
+  { path: "text.value", label: msg("drawing.field.text", "Text"), kind: "text", group: "text" },
+  { path: "text.color", label: msg("drawing.field.textColor", "Text color"), kind: "color", group: "text" },
+  { path: "text.size", label: msg("drawing.field.textSize", "Text size"), kind: "select", options: TEXT_SIZE_OPTIONS, group: "text" },
+  { path: "text.bold", label: msg("drawing.field.bold", "Bold"), kind: "boolean", group: "text" },
+  { path: "text.italic", label: msg("drawing.field.italic", "Italic"), kind: "boolean", group: "text" }
 ];
 
 // src/core/drawings/hittest.ts
@@ -751,9 +1673,9 @@ var TrendLine = class extends Drawing {
     return {
       fields: [
         ...LINE_FIELDS,
-        { path: "style.arrowRight", label: "Arrow", kind: "boolean", group: "line" },
-        { path: "style.extendLeft", label: "Extend left", kind: "boolean", group: "line" },
-        { path: "style.extendRight", label: "Extend right", kind: "boolean", group: "line" },
+        { path: "style.arrowRight", label: msg("drawing.trendline.arrowRight", "Arrow"), kind: "boolean", group: "line" },
+        { path: "style.extendLeft", label: msg("drawing.trendline.extendLeft", "Extend left"), kind: "boolean", group: "line" },
+        { path: "style.extendRight", label: msg("drawing.trendline.extendRight", "Extend right"), kind: "boolean", group: "line" },
         ...TEXT_FIELDS
       ]
     };
@@ -1102,8 +2024,8 @@ var Box = class extends Drawing {
   schema() {
     return {
       fields: [
-        ...LINE_FIELDS.map((f) => ({ ...f, label: f.label.replace("Line", "Border") })),
-        { path: "style.fillColor", label: "Fill color", kind: "color", group: "fill" },
+        ...BORDER_FIELDS,
+        { path: "style.fillColor", label: msg("drawing.box.fillColor", "Fill color"), kind: "color", group: "fill" },
         ...TEXT_FIELDS
       ]
     };
@@ -1113,13 +2035,16 @@ var Box = class extends Drawing {
 // src/core/drawings/types/PinnedLabel.ts
 var SIZE_PX = { tiny: 10, small: 12, normal: 14, large: 18, huge: 24, auto: 14 };
 var PinnedLabel = class extends Drawing {
-  /** The placeholder string when no text has been entered yet. */
+  /** The placeholder text when no text has been entered yet. */
   defaultLabel() {
-    return "Text";
+    return msg("drawing.text.placeholder", "Text");
+  }
+  placeholderText() {
+    return this.defaultLabel();
   }
   /** The string used to size the approximate hit box (subclasses with computed text override it). */
   labelText() {
-    return this.text?.value ?? this.defaultLabel();
+    return this.text?.value ?? sourceText(this.defaultLabel());
   }
   anchorSchema() {
     return { min: 1, max: 1, slots: [{ role: "p", free: "both" }] };
@@ -1173,10 +2098,10 @@ var Note = class extends PinnedLabel {
   constructor(init) {
     super(init);
     this.type = "note";
-    if (!this.text) this.text = defaultText("Note");
+    if (!this.text) this.text = defaultText(sourceText(this.defaultLabel()));
   }
   defaultLabel() {
-    return "Note";
+    return msg("drawing.note.placeholder", "Note");
   }
   schema() {
     return { fields: [...LINE_FIELDS, ...FILL_FIELDS, ...TEXT_FIELDS], textIsContent: true };
@@ -1205,15 +2130,19 @@ var SIZE_PX2 = { tiny: 10, small: 12, normal: 14, large: 18, huge: 24, auto: 14
 var CalloutBase = class extends Drawing {
   constructor(init) {
     super(init);
-    if (!this.text) this.text = defaultText(this.defaultLabel());
+    if (!this.text) this.text = defaultText(sourceText(this.defaultLabel()));
   }
   /** The placeholder text seeded for a fresh annotation. */
   defaultLabel() {
-    return "Callout";
+    return msg("drawing.callout.placeholder", "Callout");
+  }
+  placeholderText() {
+    const label = this.defaultLabel();
+    return sourceText(label) === "" ? null : label;
   }
   /** The string used to size the approximate hit box (auto-text subclasses override it). */
   labelText() {
-    return this.text?.value ?? this.defaultLabel();
+    return this.text?.value ?? sourceText(this.defaultLabel());
   }
   anchorSchema() {
     return { min: 2, max: 2, slots: [{ role: "target", free: "both" }, { role: "box", free: "both" }] };
@@ -1318,7 +2247,7 @@ var Comment = class extends CalloutBase {
     this.type = "comment";
   }
   defaultLabel() {
-    return "Comment";
+    return msg("drawing.comment.placeholder", "Comment");
   }
 };
 
@@ -1329,7 +2258,7 @@ var Signpost = class extends CalloutBase {
     this.type = "signpost";
   }
   defaultLabel() {
-    return "Signpost";
+    return msg("drawing.signpost.placeholder", "Signpost");
   }
 };
 
@@ -1758,15 +2687,15 @@ var RegressionChannel = class extends Drawing {
   schema() {
     return {
       fields: [
-        { path: "reg.midColor", label: "Midline color", kind: "color", group: "line" },
-        { path: "reg.midStyle", label: "Midline style", kind: "lineStyle", group: "line" },
-        { path: "reg.upperColor", label: "Upper line color", kind: "color", group: "line" },
-        { path: "reg.upperStyle", label: "Upper line style", kind: "lineStyle", group: "line" },
-        { path: "reg.lowerColor", label: "Lower line color", kind: "color", group: "line" },
-        { path: "reg.lowerStyle", label: "Lower line style", kind: "lineStyle", group: "line" },
-        { path: "reg.upperFill", label: "Upper fill", kind: "color", group: "fill" },
-        { path: "reg.lowerFill", label: "Lower fill", kind: "color", group: "fill" },
-        { path: "reg.showR2", label: "Show R\xB2", kind: "boolean", group: "behavior" }
+        { path: "reg.midColor", label: msg("drawing.regressionchannel.regMidColor", "Midline color"), kind: "color", group: "line" },
+        { path: "reg.midStyle", label: msg("drawing.regressionchannel.regMidStyle", "Midline style"), kind: "lineStyle", group: "line" },
+        { path: "reg.upperColor", label: msg("drawing.regressionchannel.regUpperColor", "Upper line color"), kind: "color", group: "line" },
+        { path: "reg.upperStyle", label: msg("drawing.regressionchannel.regUpperStyle", "Upper line style"), kind: "lineStyle", group: "line" },
+        { path: "reg.lowerColor", label: msg("drawing.regressionchannel.regLowerColor", "Lower line color"), kind: "color", group: "line" },
+        { path: "reg.lowerStyle", label: msg("drawing.regressionchannel.regLowerStyle", "Lower line style"), kind: "lineStyle", group: "line" },
+        { path: "reg.upperFill", label: msg("drawing.regressionchannel.regUpperFill", "Upper fill"), kind: "color", group: "fill" },
+        { path: "reg.lowerFill", label: msg("drawing.regressionchannel.regLowerFill", "Lower fill"), kind: "color", group: "fill" },
+        { path: "reg.showR2", label: msg("drawing.regressionchannel.regShowR2", "Show R²"), kind: "boolean", group: "behavior" }
       ]
     };
   }
@@ -1916,12 +2845,12 @@ var AnchoredVwap = class extends Drawing {
   schema() {
     return {
       fields: [
-        { path: "vwap.midColor", label: "VWAP color", kind: "color", group: "line" },
-        { path: "vwap.midStyle", label: "VWAP style", kind: "lineStyle", group: "line" },
-        { path: "vwap.multiplier", label: "Band multiplier", kind: "number", min: 0.5, max: 5, step: 0.5, group: "behavior" },
-        { path: "vwap.upperColor", label: "Upper band color", kind: "color", group: "line" },
-        { path: "vwap.lowerColor", label: "Lower band color", kind: "color", group: "line" },
-        { path: "vwap.bandFill", label: "Band fill", kind: "color", group: "fill" }
+        { path: "vwap.midColor", label: msg("drawing.anchoredvwap.vwapMidColor", "VWAP color"), kind: "color", group: "line" },
+        { path: "vwap.midStyle", label: msg("drawing.anchoredvwap.vwapMidStyle", "VWAP style"), kind: "lineStyle", group: "line" },
+        { path: "vwap.multiplier", label: msg("drawing.anchoredvwap.vwapMultiplier", "Band multiplier"), kind: "number", min: 0.5, max: 5, step: 0.5, group: "behavior" },
+        { path: "vwap.upperColor", label: msg("drawing.anchoredvwap.vwapUpperColor", "Upper band color"), kind: "color", group: "line" },
+        { path: "vwap.lowerColor", label: msg("drawing.anchoredvwap.vwapLowerColor", "Lower band color"), kind: "color", group: "line" },
+        { path: "vwap.bandFill", label: msg("drawing.anchoredvwap.vwapBandFill", "Band fill"), kind: "color", group: "fill" }
       ]
     };
   }
@@ -2224,38 +3153,38 @@ var FixedRangeVolumeProfile = class extends Drawing {
   schema() {
     return {
       fields: [
-        { path: "frvp.rows", label: "Rows", kind: "number", min: 1, max: 500, step: 1, group: "behavior" },
-        { path: "frvp.valueAreaPct", label: "Value Area", kind: "number", min: 0, max: 100, step: 1, group: "behavior" },
-        { path: "frvp.widthPct", label: "Width %", kind: "number", min: 0, max: 100, step: 1, group: "behavior" },
+        { path: "frvp.rows", label: msg("drawing.fixedrangevp.frvpRows", "Rows"), kind: "number", min: 1, max: 500, step: 1, group: "behavior" },
+        { path: "frvp.valueAreaPct", label: msg("drawing.fixedrangevp.frvpValueAreaPct", "Value Area"), kind: "number", min: 0, max: 100, step: 1, group: "behavior" },
+        { path: "frvp.widthPct", label: msg("drawing.fixedrangevp.frvpWidthPct", "Width %"), kind: "number", min: 0, max: 100, step: 1, group: "behavior" },
         {
           path: "frvp.anchor",
-          label: "Anchor",
+          label: msg("drawing.fixedrangevp.frvpAnchor", "Anchor"),
           kind: "select",
           options: [
-            { value: "right", label: "Right" },
-            { value: "left", label: "Left" }
+            { value: "right", label: msg("drawing.fixedrangevp.option.right", "Right") },
+            { value: "left", label: msg("drawing.fixedrangevp.option.left", "Left") }
           ],
           group: "behavior"
         },
-        { path: "frvp.upColor", label: "Up Volume", kind: "color", group: "fill" },
-        { path: "frvp.downColor", label: "Down Volume", kind: "color", group: "fill" },
-        { path: "frvp.vaUpColor", label: "Value Area Up", kind: "color", group: "fill" },
-        { path: "frvp.vaDownColor", label: "Value Area Down", kind: "color", group: "fill" },
-        { path: "frvp.showVah", label: "VAH", kind: "boolean", group: "line" },
-        { path: "frvp.vahColor", label: "VAH color", kind: "color", group: "line" },
-        { path: "frvp.vahStyle", label: "VAH style", kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
-        { path: "frvp.showVal", label: "VAL", kind: "boolean", group: "line" },
-        { path: "frvp.valColor", label: "VAL color", kind: "color", group: "line" },
-        { path: "frvp.valStyle", label: "VAL style", kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
-        { path: "frvp.showPoc", label: "POC", kind: "boolean", group: "line" },
-        { path: "frvp.pocColor", label: "POC color", kind: "color", group: "line" },
-        { path: "frvp.pocStyle", label: "POC style", kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
-        { path: "frvp.showDevelopingPoc", label: "Developing POC", kind: "boolean", group: "line" },
-        { path: "frvp.developingPocColor", label: "Developing POC color", kind: "color", group: "line" },
-        { path: "frvp.developingPocStyle", label: "Developing POC style", kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
-        { path: "frvp.showDevelopingVa", label: "Developing VA", kind: "boolean", group: "line" },
-        { path: "frvp.developingVaColor", label: "Developing VA color", kind: "color", group: "line" },
-        { path: "frvp.developingVaStyle", label: "Developing VA style", kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" }
+        { path: "frvp.upColor", label: msg("drawing.fixedrangevp.frvpUpColor", "Up Volume"), kind: "color", group: "fill" },
+        { path: "frvp.downColor", label: msg("drawing.fixedrangevp.frvpDownColor", "Down Volume"), kind: "color", group: "fill" },
+        { path: "frvp.vaUpColor", label: msg("drawing.fixedrangevp.frvpVaUpColor", "Value Area Up"), kind: "color", group: "fill" },
+        { path: "frvp.vaDownColor", label: msg("drawing.fixedrangevp.frvpVaDownColor", "Value Area Down"), kind: "color", group: "fill" },
+        { path: "frvp.showVah", label: msg("drawing.fixedrangevp.frvpShowVah", "VAH"), kind: "boolean", group: "line" },
+        { path: "frvp.vahColor", label: msg("drawing.fixedrangevp.frvpVahColor", "VAH color"), kind: "color", group: "line" },
+        { path: "frvp.vahStyle", label: msg("drawing.fixedrangevp.frvpVahStyle", "VAH style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
+        { path: "frvp.showVal", label: msg("drawing.fixedrangevp.frvpShowVal", "VAL"), kind: "boolean", group: "line" },
+        { path: "frvp.valColor", label: msg("drawing.fixedrangevp.frvpValColor", "VAL color"), kind: "color", group: "line" },
+        { path: "frvp.valStyle", label: msg("drawing.fixedrangevp.frvpValStyle", "VAL style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
+        { path: "frvp.showPoc", label: msg("drawing.fixedrangevp.frvpShowPoc", "POC"), kind: "boolean", group: "line" },
+        { path: "frvp.pocColor", label: msg("drawing.fixedrangevp.frvpPocColor", "POC color"), kind: "color", group: "line" },
+        { path: "frvp.pocStyle", label: msg("drawing.fixedrangevp.frvpPocStyle", "POC style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
+        { path: "frvp.showDevelopingPoc", label: msg("drawing.fixedrangevp.frvpShowDevelopingPoc", "Developing POC"), kind: "boolean", group: "line" },
+        { path: "frvp.developingPocColor", label: msg("drawing.fixedrangevp.frvpDevelopingPocColor", "Developing POC color"), kind: "color", group: "line" },
+        { path: "frvp.developingPocStyle", label: msg("drawing.fixedrangevp.frvpDevelopingPocStyle", "Developing POC style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" },
+        { path: "frvp.showDevelopingVa", label: msg("drawing.fixedrangevp.frvpShowDevelopingVa", "Developing VA"), kind: "boolean", group: "line" },
+        { path: "frvp.developingVaColor", label: msg("drawing.fixedrangevp.frvpDevelopingVaColor", "Developing VA color"), kind: "color", group: "line" },
+        { path: "frvp.developingVaStyle", label: msg("drawing.fixedrangevp.frvpDevelopingVaStyle", "Developing VA style"), kind: "lineStyle", options: LINE_STYLE_OPTIONS, group: "line" }
       ]
     };
   }
@@ -2525,8 +3454,8 @@ var Arrow = class extends Drawing {
     return {
       fields: [
         ...LINE_FIELDS,
-        { path: "style.arrowRight", label: "Head (end)", kind: "boolean", group: "line" },
-        { path: "style.arrowLeft", label: "Head (start)", kind: "boolean", group: "line" },
+        { path: "style.arrowRight", label: msg("drawing.arrow.arrowRight", "Head (end)"), kind: "boolean", group: "line" },
+        { path: "style.arrowLeft", label: msg("drawing.arrow.arrowLeft", "Head (start)"), kind: "boolean", group: "line" },
         ...TEXT_FIELDS
       ]
     };
@@ -2716,8 +3645,8 @@ var Freehand = class extends BrushStroke {
 
 // src/core/drawings/types/Highlighter.ts
 var HIGHLIGHTER_FIELDS = [
-  { path: "style.lineColor", label: "Color", kind: "color", group: "line" },
-  { path: "style.lineWidth", label: "Width", kind: "number", min: 4, max: 60, step: 1, group: "line" }
+  { path: "style.lineColor", label: msg("drawing.highlighter.lineColor", "Color"), kind: "color", group: "line" },
+  { path: "style.lineWidth", label: msg("drawing.highlighter.lineWidth", "Width"), kind: "number", min: 4, max: 60, step: 1, group: "line" }
 ];
 var Highlighter = class extends BrushStroke {
   constructor() {
@@ -2836,7 +3765,7 @@ var RotatedRect = class extends SegmentDrawing {
     return { min: Math.min(...ps), max: Math.max(...ps) };
   }
   schema() {
-    return { fields: [...LINE_FIELDS.map((f) => ({ ...f, label: f.label.replace("Line", "Border") })), ...FILL_FIELDS, ...TEXT_FIELDS] };
+    return { fields: [...BORDER_FIELDS, ...FILL_FIELDS, ...TEXT_FIELDS] };
   }
 };
 
@@ -2918,7 +3847,7 @@ var Arc = class extends SegmentDrawing {
     return { min: Math.min(...ps), max: Math.max(...ps) };
   }
   schema() {
-    return { fields: [...LINE_FIELDS.map((f) => ({ ...f, label: f.label.replace("Line", "Border") })), ...FILL_FIELDS, ...TEXT_FIELDS] };
+    return { fields: [...BORDER_FIELDS, ...FILL_FIELDS, ...TEXT_FIELDS] };
   }
 };
 
@@ -3034,7 +3963,7 @@ var ArrowMark = class extends Drawing {
     return a ? { min: a.price, max: a.price } : null;
   }
   schema() {
-    return { fields: [{ path: "style.lineColor", label: "Color", kind: "color", group: "line" }, ...TEXT_FIELDS] };
+    return { fields: [{ path: "style.lineColor", label: msg("drawing.arrowmarkup.lineColor", "Color"), kind: "color", group: "line" }, ...TEXT_FIELDS] };
   }
 };
 var ArrowMarkUp = class extends ArrowMark {
@@ -3057,7 +3986,7 @@ var ArrowMarkDown = class extends ArrowMark {
 };
 
 // src/core/drawings/types/GlyphStamp.ts
-var GLYPH_OPTIONS = ["\u2605", "\u2606", "\u25CF", "\u25C6", "\u25B2", "\u25BC", "\u27A4", "\u2691", "\u271A", "\u2715", "\u2764", "\u2666"];
+var GLYPH_OPTIONS = ["★", "☆", "●", "◆", "▲", "▼", "➤", "⚑", "✚", "✕", "❤", "♦"];
 var STAMP_SIZE_OPTIONS = ["small", "normal", "large", "huge"];
 var STAMP_PX = { small: 16, normal: 22, large: 32, huge: 44 };
 var GlyphStamp = class extends Drawing {
@@ -3106,9 +4035,9 @@ var GlyphStamp = class extends Drawing {
   schema() {
     return {
       fields: [
-        { path: "glyph", label: "Icon", kind: "select", options: GLYPH_OPTIONS.map((g) => ({ value: g, label: g })), group: "line" },
-        { path: "size", label: "Size", kind: "select", options: STAMP_SIZE_OPTIONS.map((s) => ({ value: s, label: s })), group: "line" },
-        { path: "style.lineColor", label: "Color", kind: "color", group: "line" },
+        { path: "glyph", label: msg("drawing.flagmark.glyph", "Icon"), kind: "select", options: GLYPH_OPTIONS.map((g) => ({ value: g, label: g })), group: "line" },
+        { path: "size", label: msg("drawing.flagmark.size", "Size"), kind: "select", options: STAMP_SIZE_OPTIONS.map((s) => ({ value: s, label: s })), group: "line" },
+        { path: "style.lineColor", label: msg("drawing.flagmark.lineColor", "Color"), kind: "color", group: "line" },
         ...TEXT_FIELDS
       ]
     };
@@ -3127,7 +4056,7 @@ var FlagMark = class extends GlyphStamp {
     this.type = "flagmark";
   }
   defaultGlyph() {
-    return "\u2691";
+    return "⚑";
   }
 };
 var IconStamp = class extends GlyphStamp {
@@ -3136,7 +4065,7 @@ var IconStamp = class extends GlyphStamp {
     this.type = "iconstamp";
   }
   defaultGlyph() {
-    return "\u2605";
+    return "★";
   }
 };
 
@@ -3203,8 +4132,8 @@ var FibRatios = class extends Drawing {
   }
   readProps(props) {
     if (Array.isArray(props.levels)) {
-      const parsed = props.levels.map(sanitizeLevel).filter((l) => l != null);
-      if (parsed.length) this.levels = parsed;
+      const parsed2 = props.levels.map(sanitizeLevel).filter((l) => l != null);
+      if (parsed2.length) this.levels = parsed2;
     }
     if (isFibSize(props.numbersSize)) this.numbersSize = props.numbersSize;
     if (isFibSize(props.labelsSize)) this.labelsSize = props.labelsSize;
@@ -3295,8 +4224,8 @@ var FibLevels = class extends FibRatios {
     return {
       fields: [
         ...base.fields,
-        { path: "style.extendLeft", label: "Extend left", kind: "boolean", group: "line" },
-        { path: "style.extendRight", label: "Extend right", kind: "boolean", group: "line" }
+        { path: "style.extendLeft", label: msg("drawing.field.extendLeft", "Extend left"), kind: "boolean", group: "line" },
+        { path: "style.extendRight", label: msg("drawing.field.extendRight", "Extend right"), kind: "boolean", group: "line" }
       ]
     };
   }
@@ -3415,19 +4344,19 @@ function ladder(ratios, on, colors = {}) {
 var FIB_PRESETS = [
   {
     key: "classic",
-    label: "Classic",
+    label: msg("drawing.fibPreset.classic", "Classic"),
     reverse: false,
     levels: ladder(LADDER, [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1])
   },
   {
     key: "extension",
-    label: "Extension",
+    label: msg("drawing.fibPreset.extension", "Extension"),
     reverse: true,
     levels: ladder(LADDER, [0, 1, 1.272, 1.414, 1.618, 2, 2.618, 3.618, 4.236])
   },
   {
     key: "ote",
-    label: "OTE",
+    label: msg("drawing.fibPreset.ote", "OTE"),
     reverse: false,
     // The entry zone reads as one band.
     levels: ladder(OTE_LADDER, [0, 0.5, 0.62, 0.705, 0.79, 1, -0.27, -0.62], { "0.62": LEVEL_AMBER, "0.79": LEVEL_AMBER })
@@ -4376,7 +5305,7 @@ var DedekindTessellation = class extends Drawing {
         ...LINE_FIELDS,
         {
           path: "maxCurvature",
-          label: "Max curvature",
+          label: msg("drawing.dedekind.maxCurvature", "Max curvature"),
           kind: "number",
           min: 4,
           max: 64,
@@ -4416,7 +5345,7 @@ function sanitizeLevel2(v) {
 }
 var SHOW_RATIOS_FIELD = {
   path: "showRatios",
-  label: "Show ratios",
+  label: msg("drawing.sonic.showRatios", "Show ratios"),
   kind: "boolean",
   group: "behavior"
 };
@@ -4568,7 +5497,7 @@ var MachFigure = class extends Drawing {
         ...LINE_FIELDS,
         {
           path: "waveCount",
-          label: "Waves",
+          label: msg("drawing.sonic.waveCount", "Waves"),
           kind: "number",
           min: 3,
           max: 12,
@@ -4593,8 +5522,8 @@ var MachFigure = class extends Drawing {
     }
     if (typeof props.showRatios === "boolean") this.showRatios = props.showRatios;
     if (Array.isArray(props.levels)) {
-      const parsed = props.levels.map(sanitizeLevel2).filter((l) => l != null);
-      if (parsed.length) this.levels = parsed;
+      const parsed2 = props.levels.map(sanitizeLevel2).filter((l) => l != null);
+      if (parsed2.length) this.levels = parsed2;
     }
   }
 };
@@ -4628,7 +5557,7 @@ var Supersonic = class extends MachFigure {
         ...LINE_FIELDS,
         {
           path: "mach",
-          label: "Mach number",
+          label: msg("drawing.supersonic.mach", "Mach number"),
           kind: "number",
           min: 1.5,
           max: 5,
@@ -4637,7 +5566,7 @@ var Supersonic = class extends MachFigure {
         },
         {
           path: "waveCount",
-          label: "Waves",
+          label: msg("drawing.supersonic.waveCount", "Waves"),
           kind: "number",
           min: 3,
           max: 12,
@@ -4702,7 +5631,7 @@ var GoldenSupersonic = class extends MachFigure {
         ...LINE_FIELDS,
         {
           path: "mach",
-          label: "Mach number",
+          label: msg("drawing.goldensupersonic.mach", "Mach number"),
           kind: "number",
           min: 1.5,
           max: 5,
@@ -4859,13 +5788,16 @@ var ElliottCorrection = class extends PatternDrawing {
 };
 
 // src/core/drawings/types/HeadShoulders.ts
+var LEFT_SHOULDER = msg("drawing.headshoulders.leftShoulder", "LS");
+var HEAD = msg("drawing.headshoulders.head", "H");
+var RIGHT_SHOULDER = msg("drawing.headshoulders.rightShoulder", "RS");
 var HeadShoulders = class extends PatternDrawing {
   constructor() {
     super(...arguments);
     this.type = "headshoulders";
   }
   vertexLabels() {
-    return ["", "LS", "", "H", "", "RS", ""];
+    return ["", LEFT_SHOULDER, "", HEAD, "", RIGHT_SHOULDER, ""];
   }
   necklineIndices() {
     return [2, 4];
@@ -4929,7 +5861,7 @@ var Gartley = class extends HarmonicPattern {
     this.type = "gartley";
   }
   patternName() {
-    return "Gartley";
+    return msg("drawing.gartley.patternName", "Gartley");
   }
   ranges() {
     return { ab: { min: 0.55, max: 0.68 }, bc: { min: 0.382, max: 0.886 }, cd: { min: 1.13, max: 1.618 }, ad: { min: 0.74, max: 0.83 } };
@@ -4943,7 +5875,7 @@ var Bat = class extends HarmonicPattern {
     this.type = "bat";
   }
   patternName() {
-    return "Bat";
+    return msg("drawing.bat.patternName", "Bat");
   }
   ranges() {
     return { ab: { min: 0.382, max: 0.5 }, bc: { min: 0.382, max: 0.886 }, cd: { min: 1.618, max: 2.618 }, ad: { min: 0.84, max: 0.92 } };
@@ -4957,7 +5889,7 @@ var Butterfly = class extends HarmonicPattern {
     this.type = "butterfly";
   }
   patternName() {
-    return "Butterfly";
+    return msg("drawing.butterfly.patternName", "Butterfly");
   }
   ranges() {
     return { ab: { min: 0.74, max: 0.83 }, bc: { min: 0.382, max: 0.886 }, cd: { min: 1.618, max: 2.618 }, ad: { min: 1.272, max: 1.618 } };
@@ -4971,7 +5903,7 @@ var Crab = class extends HarmonicPattern {
     this.type = "crab";
   }
   patternName() {
-    return "Crab";
+    return msg("drawing.crab.patternName", "Crab");
   }
   ranges() {
     return { ab: { min: 0.382, max: 0.618 }, bc: { min: 0.382, max: 0.886 }, cd: { min: 2.618, max: 3.618 }, ad: { min: 1.55, max: 1.69 } };
@@ -4985,7 +5917,7 @@ var Shark = class extends HarmonicPattern {
     this.type = "shark";
   }
   patternName() {
-    return "Shark";
+    return msg("drawing.shark.patternName", "Shark");
   }
   ranges() {
     return { ab: { min: 0.382, max: 0.618 }, bc: { min: 1.13, max: 1.618 }, cd: { min: 1.618, max: 2.24 }, ad: { min: 0.886, max: 1.13 } };
@@ -5001,7 +5933,7 @@ var Cypher = class extends HarmonicPattern {
     this.type = "cypher";
   }
   patternName() {
-    return "Cypher";
+    return msg("drawing.cypher.patternName", "Cypher");
   }
   ranges() {
     return { ab: { min: 0.382, max: 0.618 }, bc: { min: 0, max: Infinity }, cd: { min: 0, max: Infinity }, ad: { min: 0, max: Infinity } };
@@ -5035,27 +5967,13 @@ var Cypher = class extends HarmonicPattern {
 };
 
 // src/core/drawings/types/MeasureBox.ts
+var MEASURE_TEXT = {
+  priceChange: msg("drawing.measure.priceChange", "{change} ({percent}%)"),
+  barsAndDuration: msg("drawing.measure.barsAndDuration", "{count, plural, one {{bars} bar} other {{bars} bars}}, {duration}")
+};
 function signed(n) {
   return `${n >= 0 ? "+" : ""}${n.toFixed(2)}`;
 }
-function formatDuration(ms) {
-  const m = Math.abs(ms);
-  const DAY2 = 864e5;
-  const HR = 36e5;
-  const MIN2 = 6e4;
-  if (m >= DAY2) {
-    const d = Math.floor(m / DAY2);
-    const h = Math.round(m % DAY2 / HR);
-    return h ? `${d}d ${h}h` : `${d}d`;
-  }
-  if (m >= HR) {
-    const h = Math.floor(m / HR);
-    const mn = Math.round(m % HR / MIN2);
-    return mn ? `${h}h ${mn}m` : `${h}h`;
-  }
-  if (m >= MIN2) return `${Math.round(m / MIN2)}m`;
-  return `${Math.round(m / 1e3)}s`;
-}
 var MeasureBox = class extends Drawing {
   constructor(init) {
     super(init);
@@ -5067,11 +5985,12 @@ var MeasureBox = class extends Drawing {
   }
   // Placed click-move-click (the inherited 'click' mode): first click sets a corner, the second
   // sets the opposite one — consistent with the box/Gann tools.
-  /** The measurement lines, filtered by the enabled toggles. */
-  measureLabel(proj) {
+  /** The measurement lines, filtered by the enabled toggles, in `i18n`'s language
+   *  (English without one). */
+  measureLabel(proj, i18n) {
     const lines = [];
-    if (this.showPrice) lines.push(this.priceLabel());
-    if (this.showDate) lines.push(this.timeLabel(proj));
+    if (this.showPrice) lines.push(this.priceLabel(i18n));
+    if (this.showDate) lines.push(this.timeLabel(proj, i18n));
     return lines;
   }
   /** Up (later price ≥ earlier) → green; else red. */
@@ -5081,22 +6000,22 @@ var MeasureBox = class extends Drawing {
     return a != null && b != null && b.price >= a.price;
   }
   /** Formatted `Δprice (Δ%)` between the two anchors. */
-  priceLabel() {
+  priceLabel(i18n) {
     const a = this.anchors[0];
     const b = this.anchors[1];
     if (!a || !b) return "";
     const delta = b.price - a.price;
     const percent = a.price !== 0 ? delta / a.price * 100 : 0;
-    return `${signed(delta)} (${signed(percent)}%)`;
+    return textOf(i18n, MEASURE_TEXT.priceChange, { change: localizeNumberText(signed(delta), i18n), percent: localizeNumberText(signed(percent), i18n) });
   }
   /** Formatted `N bars, duration` between the two anchors (bars only when the projector knows). */
-  timeLabel(proj) {
+  timeLabel(proj, i18n) {
     const a = this.anchors[0];
     const b = this.anchors[1];
     if (!a || !b) return "";
-    const duration = formatDuration(b.time - a.time);
+    const duration = (i18n ?? englishTranslator()).format.duration(b.time - a.time, { style: "span", surface: "drawing" });
     const bars = proj.barsBetween ? Math.round(proj.barsBetween(a.time, b.time)) : null;
-    return bars != null ? `${bars} bars, ${duration}` : duration;
+    return bars != null ? textOf(i18n, MEASURE_TEXT.barsAndDuration, { count: bars, bars: localizeNumberText(String(bars), i18n), duration }) : duration;
   }
   rect(proj) {
     const a = this.anchors[0];
@@ -5132,12 +6051,12 @@ var MeasureBox = class extends Drawing {
   schema() {
     return {
       fields: [
-        { path: "showPrice", label: "Show price", kind: "boolean", group: "behavior" },
-        { path: "showDate", label: "Show date", kind: "boolean", group: "behavior" },
+        { path: "showPrice", label: msg("drawing.measure.showPrice", "Show price"), kind: "boolean", group: "behavior" },
+        { path: "showDate", label: msg("drawing.measure.showDate", "Show date"), kind: "boolean", group: "behavior" },
         ...LINE_FIELDS.filter((f) => f.path !== "style.lineColor"),
         // box border (the fill is direction-tinted)
-        { path: "text.color", label: "Text color", kind: "color", group: "text" },
-        { path: "text.size", label: "Text size", kind: "select", options: TEXT_SIZE_OPTIONS, group: "text" }
+        { path: "text.color", label: msg("drawing.field.textColor", "Text color"), kind: "color", group: "text" },
+        { path: "text.size", label: msg("drawing.field.textSize", "Text size"), kind: "select", options: TEXT_SIZE_OPTIONS, group: "text" }
       ]
     };
   }
@@ -5159,9 +6078,17 @@ var DatePriceRange = class extends MeasureBox {
 };
 
 // src/core/drawings/types/PositionTool.ts
+var POSITION_TEXT = {
+  header: msg("drawing.position.header", "{direction, select, long {LONG} other {SHORT}}  ·  R:R {ratio}"),
+  lossSize: msg("drawing.position.lossSize", "Loss {loss}  ·  Size {size}"),
+  target: msg("drawing.position.targetLabel", "Target +{percent}%"),
+  targetAt: msg("drawing.position.targetLabelAt", "Target +{percent}%  @ {price}"),
+  stop: msg("drawing.position.stopLabel", "Stop −{percent}%"),
+  stopAt: msg("drawing.position.stopLabelAt", "Stop −{percent}%  @ {price}")
+};
 var DIRECTION_OPTIONS = [
-  { value: "long", label: "Long" },
-  { value: "short", label: "Short" }
+  { value: "long", label: msg("drawing.position.option.long", "Long") },
+  { value: "short", label: msg("drawing.position.option.short", "Short") }
 ];
 var _PositionTool = class _PositionTool extends Drawing {
   constructor(init) {
@@ -5339,7 +6266,7 @@ var _PositionTool = class _PositionTool extends Drawing {
     const p = this.prices();
     return p && p.entry !== 0 ? Math.abs(p.entry - p.stop) / p.entry * 100 : 0;
   }
-  /** Dollar amount risked at the stop = accountBalance × riskPercent / 100. */
+  /** Amount risked at the stop, in the balance's units = accountBalance × riskPercent / 100. */
   dollarLoss() {
     return Math.max(0, this.accountBalance) * (Math.max(0, this.riskPercent) / 100);
   }
@@ -5351,25 +6278,34 @@ var _PositionTool = class _PositionTool extends Drawing {
     return risk < 1e-9 ? 0 : this.dollarLoss() / risk;
   }
   // ── painted label lines (each respects its own toggle; the painter checks showText) ──
-  /** `DIR · R:R x.xx` — the always-on header when text is shown. */
-  headerLabel() {
-    return `${this.directionLabel()}  \xB7  R:R ${this.rr().toFixed(2)}`;
+  /** `DIR · R:R x.xx` — the always-on header when text is shown, in `i18n`'s language
+   *  (English without one). */
+  headerLabel(i18n) {
+    return textOf(i18n, POSITION_TEXT.header, {
+      direction: this.directionLabel() === "LONG" ? "long" : "short",
+      ratio: localizeNumberText(this.rr().toFixed(2), i18n)
+    });
   }
-  /** `Loss $… · Size …` — the painter hides it when showLossSize is off. */
-  lossSizeLabel() {
-    return `Loss $${formatMoney(this.dollarLoss())}  \xB7  Size ${formatQty(this.positionSize())}`;
+  /** `Loss … · Size …` — the painter hides it when showLossSize is off. */
+  lossSizeLabel(i18n) {
+    return textOf(i18n, POSITION_TEXT.lossSize, {
+      loss: localizeNumberText(formatMoney(this.dollarLoss()), i18n),
+      size: localizeNumberText(formatQty(this.positionSize()), i18n)
+    });
   }
   /** `Target +x.xx%`, with the level price appended when showPrices is on. */
-  targetLabel() {
+  targetLabel(i18n) {
     const p = this.prices();
-    const at = this.showPrices && p ? `  @ ${formatPrice(p.target)}` : "";
-    return `Target +${this.rewardPct().toFixed(2)}%${at}`;
+    const percent = localizeNumberText(this.rewardPct().toFixed(2), i18n);
+    if (this.showPrices && p) return textOf(i18n, POSITION_TEXT.targetAt, { percent, price: localizeNumberText(formatPrice2(p.target), i18n) });
+    return textOf(i18n, POSITION_TEXT.target, { percent });
   }
   /** `Stop −x.xx%`, with the level price appended when showPrices is on. */
-  stopLabel() {
+  stopLabel(i18n) {
     const p = this.prices();
-    const at = this.showPrices && p ? `  @ ${formatPrice(p.stop)}` : "";
-    return `Stop \u2212${this.riskPct().toFixed(2)}%${at}`;
+    const percent = localizeNumberText(this.riskPct().toFixed(2), i18n);
+    if (this.showPrices && p) return textOf(i18n, POSITION_TEXT.stopAt, { percent, price: localizeNumberText(formatPrice2(p.stop), i18n) });
+    return textOf(i18n, POSITION_TEXT.stop, { percent });
   }
   // ── stop/target input units (the gear panel's Price / Points dropdowns) ──
   /** The stop or target expressed in the given unit: the absolute price, or the distance from
@@ -5438,24 +6374,24 @@ var _PositionTool = class _PositionTool extends Drawing {
   schema() {
     return {
       fields: [
-        { path: "riskPercent", label: "Risk %", kind: "number", min: 0, max: 100, step: 0.1, group: "behavior" },
-        { path: "accountBalance", label: "Account balance", kind: "number", min: 0, max: 1e12, step: 1, group: "behavior" },
-        { path: "quantity", label: "Position size", kind: "number", group: "behavior" },
-        { path: "direction", label: "Direction", kind: "select", options: DIRECTION_OPTIONS, group: "behavior" },
-        { path: "entryPrice", label: "Entry price", kind: "number", group: "behavior" },
-        { path: "stopPrice", label: "Stop price", kind: "number", group: "behavior" },
-        { path: "targetPrice", label: "Target price", kind: "number", group: "behavior" },
-        { path: "showText", label: "Show text", kind: "boolean", group: "behavior" },
-        { path: "showHeader", label: "Show direction & ratio", kind: "boolean", group: "behavior" },
-        { path: "showLossSize", label: "Show loss & size", kind: "boolean", group: "behavior" },
-        { path: "showTargetLabel", label: "Show target label", kind: "boolean", group: "behavior" },
-        { path: "showStopLabel", label: "Show stop label", kind: "boolean", group: "behavior" },
-        { path: "showPrices", label: "Show level prices", kind: "boolean", group: "behavior" },
-        { path: "profitColor", label: "Profit zone", kind: "color", group: "fill" },
-        { path: "lossColor", label: "Loss zone", kind: "color", group: "fill" },
+        { path: "riskPercent", label: msg("drawing.position.riskPercent", "Risk %"), kind: "number", min: 0, max: 100, step: 0.1, group: "behavior" },
+        { path: "accountBalance", label: msg("drawing.position.accountBalance", "Account balance"), kind: "number", min: 0, max: 1e12, step: 1, group: "behavior" },
+        { path: "quantity", label: msg("drawing.position.quantity", "Position size"), kind: "number", group: "behavior" },
+        { path: "direction", label: msg("drawing.position.direction", "Direction"), kind: "select", options: DIRECTION_OPTIONS, group: "behavior" },
+        { path: "entryPrice", label: msg("drawing.position.entryPrice", "Entry price"), kind: "number", group: "behavior" },
+        { path: "stopPrice", label: msg("drawing.position.stopPrice", "Stop price"), kind: "number", group: "behavior" },
+        { path: "targetPrice", label: msg("drawing.position.targetPrice", "Target price"), kind: "number", group: "behavior" },
+        { path: "showText", label: msg("drawing.position.showText", "Show text"), kind: "boolean", group: "behavior" },
+        { path: "showHeader", label: msg("drawing.position.showHeader", "Show direction & ratio"), kind: "boolean", group: "behavior" },
+        { path: "showLossSize", label: msg("drawing.position.showLossSize", "Show loss & size"), kind: "boolean", group: "behavior" },
+        { path: "showTargetLabel", label: msg("drawing.position.showTargetLabel", "Show target label"), kind: "boolean", group: "behavior" },
+        { path: "showStopLabel", label: msg("drawing.position.showStopLabel", "Show stop label"), kind: "boolean", group: "behavior" },
+        { path: "showPrices", label: msg("drawing.position.showPrices", "Show level prices"), kind: "boolean", group: "behavior" },
+        { path: "profitColor", label: msg("drawing.position.profitColor", "Profit zone"), kind: "color", group: "fill" },
+        { path: "lossColor", label: msg("drawing.position.lossColor", "Loss zone"), kind: "color", group: "fill" },
         ...LINE_FIELDS.filter((f) => f.path !== "style.lineColor"),
-        { path: "text.color", label: "Text color", kind: "color", group: "text" },
-        { path: "text.size", label: "Text size", kind: "select", options: TEXT_SIZE_OPTIONS, group: "text" }
+        { path: "text.color", label: msg("drawing.position.textColor", "Text color"), kind: "color", group: "text" },
+        { path: "text.size", label: msg("drawing.position.textSize", "Text size"), kind: "select", options: TEXT_SIZE_OPTIONS, group: "text" }
       ]
     };
   }
@@ -5513,7 +6449,7 @@ function formatQty(n) {
   if (n >= 1) return n.toFixed(4).replace(/\.?0+$/, "");
   return n.toPrecision(4).replace(/\.?0+$/, "");
 }
-function formatPrice(n) {
+function formatPrice2(n) {
   if (!Number.isFinite(n)) return "0";
   if (Math.abs(n) >= 1) return n.toFixed(2);
   return n.toPrecision(4).replace(/\.?0+$/, "");
@@ -5524,14 +6460,14 @@ function roundFloat(n) {
 
 // src/core/drawings/types/Magnifier.ts
 var MAGNIFIER_TIMEFRAME_OPTIONS = [
-  { value: "auto", label: "Auto", ms: 0 },
-  { value: "1", label: "1m", ms: 6e4 },
-  { value: "5", label: "5m", ms: 3e5 },
-  { value: "15", label: "15m", ms: 9e5 },
-  { value: "30", label: "30m", ms: 18e5 },
-  { value: "60", label: "1h", ms: 36e5 },
-  { value: "240", label: "4h", ms: 144e5 },
-  { value: "D", label: "1D", ms: 864e5 }
+  { value: "auto", label: msg("drawing.magnifier.option.auto", "Auto"), ms: 0 },
+  { value: "1", label: msg("drawing.magnifier.option.n1", "1m"), ms: 6e4 },
+  { value: "5", label: msg("drawing.magnifier.option.n5", "5m"), ms: 3e5 },
+  { value: "15", label: msg("drawing.magnifier.option.n15", "15m"), ms: 9e5 },
+  { value: "30", label: msg("drawing.magnifier.option.n30", "30m"), ms: 18e5 },
+  { value: "60", label: msg("drawing.magnifier.option.n60", "1h"), ms: 36e5 },
+  { value: "240", label: msg("drawing.magnifier.option.n240", "4h"), ms: 144e5 },
+  { value: "D", label: msg("drawing.magnifier.option.d", "1D"), ms: 864e5 }
 ];
 function defaultMagnifierStyle() {
   return { timeframe: "auto", upColor: "", downColor: "" };
@@ -5597,14 +6533,14 @@ var Magnifier = class extends Drawing {
       fields: [
         {
           path: "magnifier.timeframe",
-          label: "Timeframe",
+          label: msg("drawing.magnifier.magnifierTimeframe", "Timeframe"),
           kind: "select",
           options: MAGNIFIER_TIMEFRAME_OPTIONS,
           group: "behavior"
         },
-        ...LINE_FIELDS.map((f) => ({ ...f, label: f.label.replace("Line", "Border") })),
-        { path: "magnifier.upColor", label: "Up candles", kind: "color", group: "fill" },
-        { path: "magnifier.downColor", label: "Down candles", kind: "color", group: "fill" }
+        ...BORDER_FIELDS,
+        { path: "magnifier.upColor", label: msg("drawing.magnifier.magnifierUpColor", "Up candles"), kind: "color", group: "fill" },
+        { path: "magnifier.downColor", label: msg("drawing.magnifier.magnifierDownColor", "Down candles"), kind: "color", group: "fill" }
       ]
     };
   }
@@ -5807,10 +6743,10 @@ var PriceActionZone = class extends PriceActionTool {
 
 // src/core/drawings/types/FairValueGap.ts
 var EXTEND_OPTIONS = [
-  { value: "tested", label: "Until tested" },
-  { value: "half", label: "Until 50%" },
-  { value: "filled", label: "Until filled" },
-  { value: "always", label: "Always" }
+  { value: "tested", label: msg("drawing.fairvaluegap.option.tested", "Until tested") },
+  { value: "half", label: msg("drawing.fairvaluegap.option.half", "Until 50%") },
+  { value: "filled", label: msg("drawing.fairvaluegap.option.filled", "Until filled") },
+  { value: "always", label: msg("drawing.fairvaluegap.option.always", "Always") }
 ];
 function defaults2() {
   return { extend: "filled", upColor: `${BULLISH}33`, downColor: `${BEARISH}33`, midline: true, border: false, fade: true, inverse: false };
@@ -5834,13 +6770,13 @@ var FairValueGap = class extends PriceActionZone {
   schema() {
     return {
       fields: [
-        { path: "gap.extend", label: "Extend right", kind: "select", options: EXTEND_OPTIONS, group: "behavior" },
-        { path: "gap.upColor", label: "Bullish", kind: "color", group: "fill" },
-        { path: "gap.downColor", label: "Bearish", kind: "color", group: "fill" },
-        { path: "gap.midline", label: "Midline", kind: "boolean", group: "line" },
-        { path: "gap.border", label: "Border", kind: "boolean", group: "line" },
-        { path: "gap.fade", label: "Fade at end", kind: "boolean", group: "behavior", when: { path: "gap.extend", in: ["tested", "half", "filled"] } },
-        { path: "gap.inverse", label: "Flip on close", kind: "boolean", group: "behavior", when: { path: "gap.extend", in: ["filled"] } }
+        { path: "gap.extend", label: msg("drawing.fairvaluegap.gapExtend", "Extend right"), kind: "select", options: EXTEND_OPTIONS, group: "behavior" },
+        { path: "gap.upColor", label: msg("drawing.fairvaluegap.gapUpColor", "Bullish"), kind: "color", group: "fill" },
+        { path: "gap.downColor", label: msg("drawing.fairvaluegap.gapDownColor", "Bearish"), kind: "color", group: "fill" },
+        { path: "gap.midline", label: msg("drawing.fairvaluegap.gapMidline", "Midline"), kind: "boolean", group: "line" },
+        { path: "gap.border", label: msg("drawing.fairvaluegap.gapBorder", "Border"), kind: "boolean", group: "line" },
+        { path: "gap.fade", label: msg("drawing.fairvaluegap.gapFade", "Fade at end"), kind: "boolean", group: "behavior", when: { path: "gap.extend", in: ["tested", "half", "filled"] } },
+        { path: "gap.inverse", label: msg("drawing.fairvaluegap.gapInverse", "Flip on close"), kind: "boolean", group: "behavior", when: { path: "gap.extend", in: ["filled"] } }
       ]
     };
   }
@@ -5864,14 +6800,14 @@ var FairValueGap = class extends PriceActionZone {
 
 // src/core/drawings/types/OrderBlock.ts
 var RANGE_OPTIONS = [
-  { value: "body", label: "Body" },
-  { value: "wick", label: "Full range" }
+  { value: "body", label: msg("drawing.orderblock.option.body", "Body") },
+  { value: "wick", label: msg("drawing.orderblock.option.wick", "Full range") }
 ];
 var EXTEND_OPTIONS2 = [
-  { value: "tested", label: "Until tested" },
-  { value: "half", label: "Until 50%" },
-  { value: "broken", label: "Until broken" },
-  { value: "always", label: "Always" }
+  { value: "tested", label: msg("drawing.orderblock.option.tested", "Until tested") },
+  { value: "half", label: msg("drawing.orderblock.option.half", "Until 50%") },
+  { value: "broken", label: msg("drawing.orderblock.option.broken", "Until broken") },
+  { value: "always", label: msg("drawing.orderblock.option.always", "Always") }
 ];
 function defaults3() {
   return { range: "body", extend: "broken", upColor: `${BULLISH}29`, downColor: `${BEARISH}29`, midline: true, border: true, fade: true, breaker: true };
@@ -5895,14 +6831,14 @@ var OrderBlock = class extends PriceActionZone {
   schema() {
     return {
       fields: [
-        { path: "block.range", label: "Zone", kind: "select", options: RANGE_OPTIONS, group: "behavior" },
-        { path: "block.extend", label: "Extend right", kind: "select", options: EXTEND_OPTIONS2, group: "behavior" },
-        { path: "block.upColor", label: "Bullish", kind: "color", group: "fill" },
-        { path: "block.downColor", label: "Bearish", kind: "color", group: "fill" },
-        { path: "block.midline", label: "Midline", kind: "boolean", group: "line" },
-        { path: "block.border", label: "Border", kind: "boolean", group: "line" },
-        { path: "block.fade", label: "Fade at end", kind: "boolean", group: "behavior", when: { path: "block.extend", in: ["tested", "half", "broken"] } },
-        { path: "block.breaker", label: "Breaker", kind: "boolean", group: "behavior", when: { path: "block.extend", in: ["broken"] } }
+        { path: "block.range", label: msg("drawing.orderblock.blockRange", "Zone"), kind: "select", options: RANGE_OPTIONS, group: "behavior" },
+        { path: "block.extend", label: msg("drawing.orderblock.blockExtend", "Extend right"), kind: "select", options: EXTEND_OPTIONS2, group: "behavior" },
+        { path: "block.upColor", label: msg("drawing.orderblock.blockUpColor", "Bullish"), kind: "color", group: "fill" },
+        { path: "block.downColor", label: msg("drawing.orderblock.blockDownColor", "Bearish"), kind: "color", group: "fill" },
+        { path: "block.midline", label: msg("drawing.orderblock.blockMidline", "Midline"), kind: "boolean", group: "line" },
+        { path: "block.border", label: msg("drawing.orderblock.blockBorder", "Border"), kind: "boolean", group: "line" },
+        { path: "block.fade", label: msg("drawing.orderblock.blockFade", "Fade at end"), kind: "boolean", group: "behavior", when: { path: "block.extend", in: ["tested", "half", "broken"] } },
+        { path: "block.breaker", label: msg("drawing.orderblock.blockBreaker", "Breaker"), kind: "boolean", group: "behavior", when: { path: "block.extend", in: ["broken"] } }
       ]
     };
   }
@@ -5927,9 +6863,9 @@ var OrderBlock = class extends PriceActionZone {
 
 // src/core/drawings/types/Liquidity.ts
 var EXTEND_OPTIONS3 = [
-  { value: "swept", label: "Until swept" },
-  { value: "broken", label: "Until broken" },
-  { value: "always", label: "Always" }
+  { value: "swept", label: msg("drawing.liquidity.option.swept", "Until swept") },
+  { value: "broken", label: msg("drawing.liquidity.option.broken", "Until broken") },
+  { value: "always", label: msg("drawing.liquidity.option.always", "Always") }
 ];
 function defaults4() {
   return { extend: "swept", markSweep: true };
@@ -5985,8 +6921,8 @@ var Liquidity = class extends PriceActionTool {
     return {
       fields: [
         ...LINE_FIELDS,
-        { path: "liq.extend", label: "Extend right", kind: "select", options: EXTEND_OPTIONS3, group: "behavior" },
-        { path: "liq.markSweep", label: "Mark sweep", kind: "boolean", group: "behavior" }
+        { path: "liq.extend", label: msg("drawing.liquidity.liqExtend", "Extend right"), kind: "select", options: EXTEND_OPTIONS3, group: "behavior" },
+        { path: "liq.markSweep", label: msg("drawing.liquidity.liqMarkSweep", "Mark sweep"), kind: "boolean", group: "behavior" }
       ]
     };
   }
@@ -6008,18 +6944,26 @@ var REGISTRY2 = /* @__PURE__ */ new Map();
 function registerDrawingType(meta) {
   REGISTRY2.set(meta.type, meta);
 }
-function getDrawingType(type) {
-  return REGISTRY2.get(type);
+function resolved2(meta, i18n) {
+  if (typeof meta.label === "string" && (meta.placementHint === void 0 || typeof meta.placementHint === "string")) return meta;
+  const out = { ...meta, label: textOf(i18n, meta.label), placementHint: void 0 };
+  if (meta.placementHint !== void 0) out.placementHint = textOf(i18n, meta.placementHint);
+  else delete out.placementHint;
+  return out;
+}
+function getDrawingType(type, i18n) {
+  const meta = REGISTRY2.get(type);
+  return meta ? resolved2(meta, i18n) : void 0;
 }
-function drawingTypes() {
-  return [...REGISTRY2.values()];
+function drawingTypes(i18n) {
+  return [...REGISTRY2.values()].map((meta) => resolved2(meta, i18n));
 }
 var LINE_ICON = svg24('<line x1="4" y1="19" x2="20" y2="5"/>');
 var HLINE_ICON = svg24('<line x1="3" y1="12" x2="21" y2="12"/>');
 registerDrawingType({
   type: "trendline",
   group: "lines",
-  label: "Trend Line",
+  label: msg("drawing.trendline.label", "Trend Line"),
   icon: LINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new TrendLine(init)
@@ -6027,7 +6971,7 @@ registerDrawingType({
 registerDrawingType({
   type: "hline",
   group: "lines",
-  label: "Horizontal Line",
+  label: msg("drawing.hline.label", "Horizontal Line"),
   icon: HLINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "dashed" },
   create: (init) => new HorizontalLine(init)
@@ -6038,7 +6982,7 @@ var TEXT_ICON = svg24('<path d="M5 6h14M12 6v13"/>');
 registerDrawingType({
   type: "ray",
   group: "lines",
-  label: "Ray",
+  label: msg("drawing.ray.label", "Ray"),
   icon: RAY_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new Ray(init)
@@ -6052,7 +6996,7 @@ var TRENDANGLE_ICON = svg24('<path d="M4 20 20 6"/><path d="M4 20 15 20"/><path
 registerDrawingType({
   type: "extendedline",
   group: "lines",
-  label: "Extended Line",
+  label: msg("drawing.extendedline.label", "Extended Line"),
   icon: EXTLINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new ExtendedLine(init)
@@ -6060,7 +7004,7 @@ registerDrawingType({
 registerDrawingType({
   type: "vline",
   group: "lines",
-  label: "Vertical Line",
+  label: msg("drawing.vline.label", "Vertical Line"),
   icon: VLINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new VerticalLine(init)
@@ -6068,7 +7012,7 @@ registerDrawingType({
 registerDrawingType({
   type: "hray",
   group: "lines",
-  label: "Horizontal Ray",
+  label: msg("drawing.hray.label", "Horizontal Ray"),
   icon: HRAY_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new HorizontalRay(init)
@@ -6076,7 +7020,7 @@ registerDrawingType({
 registerDrawingType({
   type: "crossline",
   group: "lines",
-  label: "Cross Line",
+  label: msg("drawing.crossline.label", "Cross Line"),
   icon: CROSSLINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new CrossLine(init)
@@ -6084,7 +7028,7 @@ registerDrawingType({
 registerDrawingType({
   type: "infoline",
   group: "lines",
-  label: "Info Line",
+  label: msg("drawing.infoline.label", "Info Line"),
   icon: INFOLINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new InfoLine(init)
@@ -6092,7 +7036,7 @@ registerDrawingType({
 registerDrawingType({
   type: "trendangle",
   group: "lines",
-  label: "Trend Angle",
+  label: msg("drawing.trendangle.label", "Trend Angle"),
   icon: TRENDANGLE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new TrendAngle(init)
@@ -6100,7 +7044,7 @@ registerDrawingType({
 registerDrawingType({
   type: "box",
   group: "shapes",
-  label: "Rectangle",
+  label: msg("drawing.box.label", "Rectangle"),
   icon: BOX_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}26` },
   create: (init) => new Box(init)
@@ -6108,7 +7052,7 @@ registerDrawingType({
 registerDrawingType({
   type: "text",
   group: "annotations",
-  label: "Text",
+  label: msg("drawing.text.label", "Text"),
   icon: TEXT_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new TextLabel(init)
@@ -6117,7 +7061,7 @@ var CALLOUT_ICON = svg24('<path d="M5 4h14a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-6l-5 5
 registerDrawingType({
   type: "callout",
   group: "annotations",
-  label: "Callout",
+  label: msg("drawing.callout.label", "Callout"),
   icon: CALLOUT_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}d9` },
   create: (init) => new Callout(init)
@@ -6130,7 +7074,7 @@ var SIGNPOST_ICON = svg24('<path d="M12 11.5V21"/><rect x="5" y="4" width="14" h
 registerDrawingType({
   type: "note",
   group: "annotations",
-  label: "Note",
+  label: msg("drawing.note.label", "Note"),
   icon: NOTE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}d9` },
   create: (init) => new Note(init)
@@ -6138,7 +7082,7 @@ registerDrawingType({
 registerDrawingType({
   type: "pricenote",
   group: "annotations",
-  label: "Price Note",
+  label: msg("drawing.pricenote.label", "Price Note"),
   icon: PRICE_NOTE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}d9` },
   create: (init) => new PriceNote(init)
@@ -6146,7 +7090,7 @@ registerDrawingType({
 registerDrawingType({
   type: "comment",
   group: "annotations",
-  label: "Comment",
+  label: msg("drawing.comment.label", "Comment"),
   icon: COMMENT_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}d9` },
   create: (init) => new Comment(init)
@@ -6154,7 +7098,7 @@ registerDrawingType({
 registerDrawingType({
   type: "pricelabel",
   group: "annotations",
-  label: "Price Label",
+  label: msg("drawing.pricelabel.label", "Price Label"),
   icon: PRICE_LABEL_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}d9` },
   create: (init) => new PriceLabel(init)
@@ -6162,7 +7106,7 @@ registerDrawingType({
 registerDrawingType({
   type: "signpost",
   group: "annotations",
-  label: "Signpost",
+  label: msg("drawing.signpost.label", "Signpost"),
   icon: SIGNPOST_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}d9` },
   create: (init) => new Signpost(init)
@@ -6173,7 +7117,7 @@ var PITCHFORK_ICON = svg24('<circle cx="4" cy="12" r="1.6" fill="currentColor"/>
 registerDrawingType({
   type: "parallelchannel",
   group: "channels",
-  label: "Parallel Channel",
+  label: msg("drawing.parallelchannel.label", "Parallel Channel"),
   icon: PARALLEL_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}1a` },
   create: (init) => new ParallelChannel(init)
@@ -6181,7 +7125,7 @@ registerDrawingType({
 registerDrawingType({
   type: "disjointchannel",
   group: "channels",
-  label: "Disjoint Channel",
+  label: msg("drawing.disjointchannel.label", "Disjoint Channel"),
   icon: DISJOINT_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}1a` },
   create: (init) => new DisjointChannel(init)
@@ -6190,7 +7134,7 @@ var FLATTOP_ICON = svg24('<line x1="3" y1="7" x2="21" y2="7"/><line x1="3" y1="1
 registerDrawingType({
   type: "flattopbottom",
   group: "channels",
-  label: "Flat Top/Bottom",
+  label: msg("drawing.flattopbottom.label", "Flat Top/Bottom"),
   icon: FLATTOP_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}1a` },
   create: (init) => new FlatTopBottom(init)
@@ -6199,7 +7143,7 @@ var REGRESSION_ICON = svg24('<line x1="3" y1="8" x2="21" y2="4"/><line x1="3" y1
 registerDrawingType({
   type: "regressionchannel",
   group: "channels",
-  label: "Linear Regression",
+  label: msg("drawing.regressionchannel.label", "Linear Regression"),
   icon: REGRESSION_ICON,
   defaultStyle: { lineColor: NEUTRAL, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new RegressionChannel(init)
@@ -6207,7 +7151,7 @@ registerDrawingType({
 registerDrawingType({
   type: "pitchfork",
   group: "pitchforks",
-  label: "Pitchfork",
+  label: msg("drawing.pitchfork.label", "Pitchfork"),
   icon: PITCHFORK_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new Pitchfork(init)
@@ -6218,7 +7162,7 @@ var INSIDE_ICON = svg24('<line x1="4" y1="12" x2="10" y2="12"/><line x1="10" y1=
 registerDrawingType({
   type: "schiffpitchfork",
   group: "pitchforks",
-  label: "Schiff Pitchfork",
+  label: msg("drawing.schiffpitchfork.label", "Schiff Pitchfork"),
   icon: SCHIFF_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new SchiffPitchfork(init)
@@ -6226,7 +7170,7 @@ registerDrawingType({
 registerDrawingType({
   type: "modifiedschiffpitchfork",
   group: "pitchforks",
-  label: "Modified Schiff Pitchfork",
+  label: msg("drawing.modifiedschiffpitchfork.label", "Modified Schiff Pitchfork"),
   icon: MODSCHIFF_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new ModifiedSchiffPitchfork(init)
@@ -6234,7 +7178,7 @@ registerDrawingType({
 registerDrawingType({
   type: "insidepitchfork",
   group: "pitchforks",
-  label: "Inside Pitchfork",
+  label: msg("drawing.insidepitchfork.label", "Inside Pitchfork"),
   icon: INSIDE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new InsidePitchfork(init)
@@ -6245,7 +7189,7 @@ var TRIANGLE_ICON = svg24('<path d="M12 4 20 19 4 19Z"/>');
 registerDrawingType({
   type: "arrow",
   group: "shapes",
-  label: "Arrow",
+  label: msg("drawing.arrow.label", "Arrow"),
   icon: ARROW_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", arrowRight: true },
   create: (init) => new Arrow(init)
@@ -6253,7 +7197,7 @@ registerDrawingType({
 registerDrawingType({
   type: "ellipse",
   group: "shapes",
-  label: "Ellipse",
+  label: msg("drawing.ellipse.label", "Ellipse"),
   icon: ELLIPSE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}1a` },
   create: (init) => new Ellipse(init)
@@ -6261,7 +7205,7 @@ registerDrawingType({
 registerDrawingType({
   type: "triangle",
   group: "shapes",
-  label: "Triangle",
+  label: msg("drawing.triangle.label", "Triangle"),
   icon: TRIANGLE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}1a` },
   create: (init) => new Triangle(init)
@@ -6272,7 +7216,7 @@ var HIGHLIGHTER_ICON = svg24('<path d="M9 11 15 5l4 4-6 6H9Z"/><path d="M9 15l-2
 registerDrawingType({
   type: "polyline",
   group: "shapes",
-  label: "Polyline",
+  label: msg("drawing.polyline.label", "Polyline"),
   icon: POLYLINE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new Polyline(init)
@@ -6280,7 +7224,7 @@ registerDrawingType({
 registerDrawingType({
   type: "freehand",
   group: "shapes",
-  label: "Brush",
+  label: msg("drawing.freehand.label", "Brush"),
   icon: FREEHAND_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new Freehand(init)
@@ -6288,7 +7232,7 @@ registerDrawingType({
 registerDrawingType({
   type: "highlighter",
   group: "shapes",
-  label: "Highlighter",
+  label: msg("drawing.highlighter.label", "Highlighter"),
   icon: HIGHLIGHTER_ICON,
   // A marker: wide + translucent by default (the alpha in the color is the highlight's see-through).
   defaultStyle: { lineColor: `${MARKER}59`, lineWidth: 14, lineStyle: "solid" },
@@ -6304,7 +7248,7 @@ var ARROW_DOWN_ICON = svg24('<path d="M12 5 12 19"/><path d="M6 13 12 19 18 13"/
 registerDrawingType({
   type: "circle",
   group: "shapes",
-  label: "Circle",
+  label: msg("drawing.circle.label", "Circle"),
   icon: CIRCLE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}1a` },
   create: (init) => new Circle(init)
@@ -6312,7 +7256,7 @@ registerDrawingType({
 registerDrawingType({
   type: "rotatedrect",
   group: "shapes",
-  label: "Rotated Rectangle",
+  label: msg("drawing.rotatedrect.label", "Rotated Rectangle"),
   icon: ROTRECT_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}26` },
   create: (init) => new RotatedRect(init)
@@ -6320,7 +7264,7 @@ registerDrawingType({
 registerDrawingType({
   type: "path",
   group: "shapes",
-  label: "Path",
+  label: msg("drawing.path.label", "Path"),
   icon: PATH_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new Path(init)
@@ -6328,7 +7272,7 @@ registerDrawingType({
 registerDrawingType({
   type: "arc",
   group: "shapes",
-  label: "Arc",
+  label: msg("drawing.arc.label", "Arc"),
   icon: ARC_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid", fillColor: `${DEFAULT_DRAWING_COLOR}26` },
   create: (init) => new Arc(init)
@@ -6336,7 +7280,7 @@ registerDrawingType({
 registerDrawingType({
   type: "curve",
   group: "shapes",
-  label: "Curve",
+  label: msg("drawing.curve.label", "Curve"),
   icon: CURVE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new Curve(init)
@@ -6344,7 +7288,7 @@ registerDrawingType({
 registerDrawingType({
   type: "arrowmarkup",
   group: "shapes",
-  label: "Arrow Mark Up",
+  label: msg("drawing.arrowmarkup.label", "Arrow Mark Up"),
   icon: ARROW_UP_ICON,
   defaultStyle: { lineColor: BULLISH, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new ArrowMarkUp(init)
@@ -6352,7 +7296,7 @@ registerDrawingType({
 registerDrawingType({
   type: "arrowmarkdown",
   group: "shapes",
-  label: "Arrow Mark Down",
+  label: msg("drawing.arrowmarkdown.label", "Arrow Mark Down"),
   icon: ARROW_DOWN_ICON,
   defaultStyle: { lineColor: BEARISH, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new ArrowMarkDown(init)
@@ -6362,7 +7306,7 @@ var ICON_STAMP_ICON = svg24('<path d="m12 3 2.6 5.8 6.4.6-4.8 4.2 1.4 6.2L12 16.
 registerDrawingType({
   type: "flagmark",
   group: "stamps",
-  label: "Flag",
+  label: msg("drawing.flagmark.label", "Flag"),
   icon: FLAG_MARK_ICON,
   defaultStyle: { lineColor: ACCENT, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FlagMark(init)
@@ -6370,7 +7314,7 @@ registerDrawingType({
 registerDrawingType({
   type: "iconstamp",
   group: "stamps",
-  label: "Icon",
+  label: msg("drawing.iconstamp.label", "Icon"),
   icon: ICON_STAMP_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new IconStamp(init)
@@ -6380,7 +7324,7 @@ var FIB_EXTEND_ICON = svg24('<line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1
 registerDrawingType({
   type: "fibretracement",
   group: "fibonacci",
-  label: "Fib Retracement",
+  label: msg("drawing.fibretracement.label", "Fib Retracement"),
   icon: FIB_RETRACE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibRetracement(init)
@@ -6388,7 +7332,7 @@ registerDrawingType({
 registerDrawingType({
   type: "fibextension",
   group: "fibonacci",
-  label: "Fib Extension",
+  label: msg("drawing.fibextension.label", "Fib Extension"),
   icon: FIB_EXTEND_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibExtension(init)
@@ -6397,7 +7341,7 @@ var FIB_TREND_ICON = svg24('<path d="M3 20 10 9l4 5"/><path d="M14 14h7M14 9h7M1
 registerDrawingType({
   type: "fibextensiontrend",
   group: "fibonacci",
-  label: "Trend-Based Fib Extension",
+  label: msg("drawing.fibextensiontrend.label", "Trend-Based Fib Extension"),
   icon: FIB_TREND_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibExtensionTrend(init)
@@ -6407,7 +7351,7 @@ var FIB_TZ_ICON = svg24('<path d="M3 5v14M6 5v14M11 5v14M19 5v14"/>');
 registerDrawingType({
   type: "fibfan",
   group: "fibonacci",
-  label: "Fib Fan",
+  label: msg("drawing.fibfan.label", "Fib Fan"),
   icon: FIB_FAN_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibFan(init)
@@ -6415,7 +7359,7 @@ registerDrawingType({
 registerDrawingType({
   type: "fibtimezones",
   group: "fibonacci",
-  label: "Fib Time Zones",
+  label: msg("drawing.fibtimezones.label", "Fib Time Zones"),
   icon: FIB_TZ_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "dashed" },
   create: (init) => new FibTimeZones(init)
@@ -6426,7 +7370,7 @@ var FIB_TRENDTIME_ICON = svg24('<path d="M3 19 9 8M9 8 12 5v14M14 5v14M18 5v14M2
 registerDrawingType({
   type: "fibchannel",
   group: "fibonacci",
-  label: "Fib Channel",
+  label: msg("drawing.fibchannel.label", "Fib Channel"),
   icon: FIB_CHANNEL_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibChannel(init)
@@ -6434,7 +7378,7 @@ registerDrawingType({
 registerDrawingType({
   type: "fibspeedfan",
   group: "fibonacci",
-  label: "Fib Speed Resistance Fan",
+  label: msg("drawing.fibspeedfan.label", "Fib Speed Resistance Fan"),
   icon: FIB_SPEEDFAN_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibSpeedFan(init)
@@ -6442,7 +7386,7 @@ registerDrawingType({
 registerDrawingType({
   type: "trendfibtime",
   group: "fibonacci",
-  label: "Trend-Based Fib Time",
+  label: msg("drawing.trendfibtime.label", "Trend-Based Fib Time"),
   icon: FIB_TRENDTIME_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "dashed" },
   create: (init) => new TrendFibTime(init)
@@ -6454,7 +7398,7 @@ var FIB_SPIRAL_ICON = svg24('<path d="M13 12a2 2 0 1 1-2-2 4 4 0 0 1 4 4 6 6 0 0
 registerDrawingType({
   type: "fibcircles",
   group: "fibonacci",
-  label: "Fib Circles",
+  label: msg("drawing.fibcircles.label", "Fib Circles"),
   icon: FIB_CIRCLES_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibCircles(init)
@@ -6462,7 +7406,7 @@ registerDrawingType({
 registerDrawingType({
   type: "fibarcs",
   group: "fibonacci",
-  label: "Fib Speed Resistance Arcs",
+  label: msg("drawing.fibarcs.label", "Fib Speed Resistance Arcs"),
   icon: FIB_ARCS_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibArcs(init)
@@ -6470,7 +7414,7 @@ registerDrawingType({
 registerDrawingType({
   type: "fibwedge",
   group: "fibonacci",
-  label: "Fib Wedge",
+  label: msg("drawing.fibwedge.label", "Fib Wedge"),
   icon: FIB_WEDGE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FibWedge(init)
@@ -6478,7 +7422,7 @@ registerDrawingType({
 registerDrawingType({
   type: "fibspiral",
   group: "fibonacci",
-  label: "Fib Spiral",
+  label: msg("drawing.fibspiral.label", "Fib Spiral"),
   icon: FIB_SPIRAL_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new FibSpiral(init)
@@ -6488,7 +7432,7 @@ var GANN_BOX_ICON = svg24('<rect x="4" y="4" width="16" height="16" rx="1"/><pat
 registerDrawingType({
   type: "gannfan",
   group: "fibonacci",
-  label: "Gann Fan",
+  label: msg("drawing.gannfan.label", "Gann Fan"),
   icon: GANN_FAN_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new GannFan(init)
@@ -6496,7 +7440,7 @@ registerDrawingType({
 registerDrawingType({
   type: "gannbox",
   group: "fibonacci",
-  label: "Gann Box",
+  label: msg("drawing.gannbox.label", "Gann Box"),
   icon: GANN_BOX_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new GannBox(init)
@@ -6505,7 +7449,7 @@ var GANN_SQUARE_ICON = svg24('<rect x="4" y="4" width="16" height="16" rx="1"/><
 registerDrawingType({
   type: "gannsquare",
   group: "fibonacci",
-  label: "Gann Square",
+  label: msg("drawing.gannsquare.label", "Gann Square"),
   icon: GANN_SQUARE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new GannSquare(init)
@@ -6516,7 +7460,7 @@ var DEDEKIND_ICON = svg24(
 registerDrawingType({
   type: "dedekind",
   group: "geometry",
-  label: "Dedekind Tessellation",
+  label: msg("drawing.dedekind.label", "Dedekind Tessellation"),
   icon: DEDEKIND_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new DedekindTessellation(init)
@@ -6530,7 +7474,7 @@ var SUPERSONIC_ICON = svg24(
 registerDrawingType({
   type: "sonic",
   group: "geometry",
-  label: "Sonic",
+  label: msg("drawing.sonic.label", "Sonic"),
   icon: SONIC_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new Sonic(init)
@@ -6538,7 +7482,7 @@ registerDrawingType({
 registerDrawingType({
   type: "supersonic",
   group: "geometry",
-  label: "Supersonic",
+  label: msg("drawing.supersonic.label", "Supersonic"),
   icon: SUPERSONIC_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new Supersonic(init)
@@ -6552,7 +7496,7 @@ var GOLDEN_SUPERSONIC_ICON = svg24(
 registerDrawingType({
   type: "goldensonic",
   group: "geometry",
-  label: "Golden Sonic",
+  label: msg("drawing.goldensonic.label", "Golden Sonic"),
   icon: GOLDEN_SONIC_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new GoldenSonic(init)
@@ -6560,7 +7504,7 @@ registerDrawingType({
 registerDrawingType({
   type: "goldensupersonic",
   group: "geometry",
-  label: "Golden Supersonic",
+  label: msg("drawing.goldensupersonic.label", "Golden Supersonic"),
   icon: GOLDEN_SUPERSONIC_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new GoldenSupersonic(init)
@@ -6573,7 +7517,7 @@ var HEAD_SHOULDERS_ICON = svg24('<path d="M3 18 6 12 9 16 12 5 15 16 18 12 21 18
 registerDrawingType({
   type: "xabcd",
   group: "patterns",
-  label: "XABCD Pattern",
+  label: msg("drawing.xabcd.label", "XABCD Pattern"),
   icon: XABCD_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new XABCD(init)
@@ -6581,7 +7525,7 @@ registerDrawingType({
 registerDrawingType({
   type: "abcd",
   group: "patterns",
-  label: "ABCD Pattern",
+  label: msg("drawing.abcd.label", "ABCD Pattern"),
   icon: ABCD_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new ABCDPattern(init)
@@ -6589,7 +7533,7 @@ registerDrawingType({
 registerDrawingType({
   type: "elliottimpulse",
   group: "patterns",
-  label: "Elliott Impulse Wave (1-5)",
+  label: msg("drawing.elliottimpulse.label", "Elliott Impulse Wave (1-5)"),
   icon: ELLIOTT_IMPULSE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new ElliottImpulse(init)
@@ -6597,7 +7541,7 @@ registerDrawingType({
 registerDrawingType({
   type: "elliottcorrection",
   group: "patterns",
-  label: "Elliott Correction Wave (ABC)",
+  label: msg("drawing.elliottcorrection.label", "Elliott Correction Wave (ABC)"),
   icon: ELLIOTT_CORRECTION_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new ElliottCorrection(init)
@@ -6605,24 +7549,24 @@ registerDrawingType({
 registerDrawingType({
   type: "headshoulders",
   group: "patterns",
-  label: "Head & Shoulders",
+  label: msg("drawing.headshoulders.label", "Head & Shoulders"),
   icon: HEAD_SHOULDERS_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new HeadShoulders(init)
 });
 var HARMONIC_ICON = svg24('<path d="M3 17 7 6 12 14 17 5 21 16"/><path d="M3 17 21 16" opacity="0.45"/>');
 var harmonic = { group: "patterns", icon: HARMONIC_ICON, defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" } };
-registerDrawingType({ type: "gartley", label: "Gartley", ...harmonic, create: (init) => new Gartley(init) });
-registerDrawingType({ type: "bat", label: "Bat", ...harmonic, create: (init) => new Bat(init) });
-registerDrawingType({ type: "butterfly", label: "Butterfly", ...harmonic, create: (init) => new Butterfly(init) });
-registerDrawingType({ type: "crab", label: "Crab", ...harmonic, create: (init) => new Crab(init) });
-registerDrawingType({ type: "shark", label: "Shark", ...harmonic, create: (init) => new Shark(init) });
-registerDrawingType({ type: "cypher", label: "Cypher", ...harmonic, create: (init) => new Cypher(init) });
+registerDrawingType({ type: "gartley", label: msg("drawing.gartley.label", "Gartley"), ...harmonic, create: (init) => new Gartley(init) });
+registerDrawingType({ type: "bat", label: msg("drawing.bat.label", "Bat"), ...harmonic, create: (init) => new Bat(init) });
+registerDrawingType({ type: "butterfly", label: msg("drawing.butterfly.label", "Butterfly"), ...harmonic, create: (init) => new Butterfly(init) });
+registerDrawingType({ type: "crab", label: msg("drawing.crab.label", "Crab"), ...harmonic, create: (init) => new Crab(init) });
+registerDrawingType({ type: "shark", label: msg("drawing.shark.label", "Shark"), ...harmonic, create: (init) => new Shark(init) });
+registerDrawingType({ type: "cypher", label: msg("drawing.cypher.label", "Cypher"), ...harmonic, create: (init) => new Cypher(init) });
 var MEASURE_ICON = svg24('<rect x="4" y="6" width="16" height="12" rx="1"/><path d="M4 18 20 6" opacity="0.5"/>');
 registerDrawingType({
   type: "datepricerange",
   group: "measure",
-  label: "Date & Price Range",
+  label: msg("drawing.datepricerange.label", "Date & Price Range"),
   icon: MEASURE_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new DatePriceRange(init)
@@ -6633,7 +7577,7 @@ var POSITION_ICON = svg24(
 registerDrawingType({
   type: "position",
   group: "measure",
-  label: "Long/Short Position",
+  label: msg("drawing.position.label", "Long/Short Position"),
   icon: POSITION_ICON,
   defaultStyle: { lineColor: DEFAULT_DRAWING_COLOR, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new PositionTool(init)
@@ -6644,21 +7588,21 @@ var MAGNIFIER_ICON = svg24(
 registerDrawingType({
   type: "magnifier",
   group: "measure",
-  label: "Magnifier",
+  label: msg("drawing.magnifier.label", "Magnifier"),
   icon: MAGNIFIER_ICON,
   // An empty border color means the THEME's contrast ink (white on dark, black on
   // light), resolved at paint time so it follows theme switches; a user pick wins.
   defaultStyle: { lineColor: "", lineWidth: 1, lineStyle: "solid" },
   coversSeries: true,
   // the inset's backdrop must sit over the base candles it replaces
-  placementHint: "Drag an area on the chart to view it at a lower timeframe",
+  placementHint: msg("drawing.magnifier.placementHint", "Drag an area on the chart to view it at a lower timeframe"),
   create: (init) => new Magnifier(init)
 });
 var VWAP_ICON = svg24('<line x1="5" y1="3" x2="5" y2="21"/><path d="M5 16c4 0 5-9 8-9s3 5 8 3"/>');
 registerDrawingType({
   type: "anchoredvwap",
   group: "measure",
-  label: "Anchored VWAP",
+  label: msg("drawing.anchoredvwap.label", "Anchored VWAP"),
   icon: VWAP_ICON,
   defaultStyle: { lineColor: INFO, lineWidth: 2, lineStyle: "solid" },
   create: (init) => new AnchoredVwap(init)
@@ -6667,7 +7611,7 @@ var FRVP_ICON = svg24('<path d="M4 4v16"/><path d="M4 8h10"/><path d="M4 12h14"/
 registerDrawingType({
   type: "fixedrangevp",
   group: "measure",
-  label: "Fixed Range Volume Profile",
+  label: msg("drawing.fixedrangevp.label", "Fixed Range Volume Profile"),
   icon: FRVP_ICON,
   defaultStyle: { lineColor: BULLISH, lineWidth: 1, lineStyle: "solid" },
   create: (init) => new FixedRangeVolumeProfile(init)
@@ -6678,28 +7622,28 @@ var LIQUIDITY_ICON = svg24('<path d="M3 8h12" stroke-dasharray="2.5 2.5"/><path
 registerDrawingType({
   type: "fairvaluegap",
   group: "priceaction",
-  label: "Fair Value Gap",
+  label: msg("drawing.fairvaluegap.label", "Fair Value Gap"),
   icon: FVG_ICON,
   defaultStyle: { lineColor: BULLISH, lineWidth: 1, lineStyle: "solid" },
-  placementHint: "Click the middle candle of a gap",
+  placementHint: msg("drawing.fairvaluegap.placementHint", "Click the middle candle of a gap"),
   create: (init) => new FairValueGap(init)
 });
 registerDrawingType({
   type: "orderblock",
   group: "priceaction",
-  label: "Order Block",
+  label: msg("drawing.orderblock.label", "Order Block"),
   icon: ORDER_BLOCK_ICON,
   defaultStyle: { lineColor: BULLISH, lineWidth: 1, lineStyle: "solid" },
-  placementHint: "Click the candle that forms the block",
+  placementHint: msg("drawing.orderblock.placementHint", "Click the candle that forms the block"),
   create: (init) => new OrderBlock(init)
 });
 registerDrawingType({
   type: "liquidity",
   group: "priceaction",
-  label: "Liquidity",
+  label: msg("drawing.liquidity.label", "Liquidity"),
   icon: LIQUIDITY_ICON,
   defaultStyle: { lineColor: WARNING, lineWidth: 1, lineStyle: "solid" },
-  placementHint: "Click near a candle's high or low",
+  placementHint: msg("drawing.liquidity.placementHint", "Click near a candle's high or low"),
   create: (init) => new Liquidity(init)
 });
 
@@ -6765,6 +7709,7 @@ exports.categoricalColor = categoricalColor;
 exports.chartType = chartType;
 exports.chartTypes = chartTypes;
 exports.clampPanelWidth = clampPanelWidth;
+exports.createTranslator = createTranslator;
 exports.drawingTypes = drawingTypes;
 exports.getDrawingType = getDrawingType;
 exports.getNativeIndicator = getNativeIndicator;
@@ -6773,6 +7718,7 @@ exports.inputDeltas = inputDeltas;
 exports.inputVisible = inputVisible;
 exports.legendActions = legendActions;
 exports.legendCallouts = legendCallouts;
+exports.msg = msg;
 exports.nativeIndicatorTypes = nativeIndicatorTypes;
 exports.normalizeSettingsRow = normalizeSettingsRow;
 exports.registerChartType = registerChartType;
@@ -6780,6 +7726,7 @@ exports.registerDefaultEngine = registerDefaultEngine;
 exports.registerIcon = registerIcon;
 exports.registerLegendAction = registerLegendAction;
 exports.registerLegendCallout = registerLegendCallout;
+exports.registerLocale = registerLocale;
 exports.registerNativeIndicator = registerNativeIndicator;
 exports.registerRendererDefaults = registerRendererDefaults;
 exports.registerRendererLayer = registerRendererLayer;
@@ -6788,6 +7735,7 @@ exports.registerStatePersistence = registerStatePersistence;
 exports.registerSymbolRanking = registerSymbolRanking;
 exports.registerWidgetAction = registerWidgetAction;
 exports.registerWidgetAttachment = registerWidgetAttachment;
+exports.registeredLocales = registeredLocales;
 exports.rendererDefaults = rendererDefaults;
 exports.rendererLayers = rendererLayers;
 exports.resolveEngines = resolveEngines;
@@ -6813,3 +7761,4 @@ exports.unregisterWidgetAction = unregisterWidgetAction;
 exports.unregisterWidgetAttachment = unregisterWidgetAttachment;
 exports.widgetActions = widgetActions;
 exports.widgetAttachments = widgetAttachments;
+exports.withValues = withValues;