@coderyo/pine-lite 1.0.0-rc.3 → 1.0.1

package/dist/index.js

@@ -1,16 +1,768 @@
-// src/vm.ts
-function runPineVm(ir, length) {
-  const plots = Array.from({ length }, (_, i) => Math.sin(i * 0.05));
-  void ir;
-  return { plots };
+import {
+  runPineIr
+} from "./chunk-JLVAE3JC.js";
+
+// src/builtins.ts
+var SERIES_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "close",
+  "open",
+  "high",
+  "low",
+  "volume",
+  "hl2",
+  "hlc3"
+]);
+var INDICATOR_BUILTINS = /* @__PURE__ */ new Set([
+  "sma",
+  "ema",
+  "rsi",
+  "highest",
+  "lowest",
+  "crossover",
+  "crossunder"
+]);
+function isBuiltin(name) {
+  return SERIES_IDENTIFIERS.has(name) || INDICATOR_BUILTINS.has(name);
+}
+function builtinArity(name) {
+  if (SERIES_IDENTIFIERS.has(name)) return 0;
+  if (name === "sma" || name === "ema" || name === "rsi" || name === "highest" || name === "lowest") {
+    return 2;
+  }
+  if (name === "crossover" || name === "crossunder") return 2;
+  return null;
+}
+
+// src/compile.ts
+var Emitter = class {
+  ops = [];
+  plotIndex = 0;
+  emit(op) {
+    this.ops.push(op);
+    return this.ops.length - 1;
+  }
+  patchJump(index, target) {
+    const op = this.ops[index];
+    if (op.op === "jump" || op.op === "jump_if_false") op.target = target;
+  }
+  emitExpr(expr, errors, vars) {
+    switch (expr.kind) {
+      case "number":
+        this.emit({ op: "push", value: expr.value });
+        return true;
+      case "bool":
+        this.emit({ op: "push", value: expr.value ? 1 : 0 });
+        return true;
+      case "ident":
+        if (vars.has(expr.name)) {
+          this.emit({ op: "load_var", name: expr.name });
+          return true;
+        }
+        if (isBuiltin(expr.name) && builtinArity(expr.name) === 0) {
+          this.emit({ op: "load_series", name: expr.name });
+          return true;
+        }
+        errors.push(`Unknown identifier '${expr.name}'`);
+        return false;
+      case "unary":
+        if (!this.emitExpr(expr.arg, errors, vars)) return false;
+        this.emit({ op: expr.op === "not" ? "not" : "neg" });
+        return true;
+      case "binary":
+        if (expr.op === "and" || expr.op === "or") {
+          if (!this.emitExpr(expr.left, errors, vars) || !this.emitExpr(expr.right, errors, vars)) {
+            return false;
+          }
+          this.emit({ op: expr.op });
+          return true;
+        }
+        if (!this.emitExpr(expr.left, errors, vars) || !this.emitExpr(expr.right, errors, vars)) {
+          return false;
+        }
+        if (expr.op === "+" || expr.op === "-" || expr.op === "*" || expr.op === "/") {
+          this.emit({
+            op: expr.op === "+" ? "add" : expr.op === "-" ? "sub" : expr.op === "*" ? "mul" : "div"
+          });
+          return true;
+        }
+        this.emit({
+          op: "cmp",
+          mode: expr.op === "==" ? "eq" : expr.op === "!=" ? "ne" : expr.op === "<" ? "lt" : expr.op === ">" ? "gt" : expr.op === "<=" ? "le" : "ge"
+        });
+        return true;
+      case "call": {
+        const arity = builtinArity(expr.name);
+        if (arity == null) {
+          errors.push(`Unknown function '${expr.name}'`);
+          return false;
+        }
+        if (expr.args.length !== arity) {
+          errors.push(`'${expr.name}' expects ${arity} arguments, got ${expr.args.length}`);
+          return false;
+        }
+        const fn = expr.name;
+        if ((fn === "crossover" || fn === "crossunder") && expr.args[0]?.kind === "ident" && expr.args[1]?.kind === "ident" && SERIES_IDENTIFIERS.has(expr.args[0].name) && SERIES_IDENTIFIERS.has(expr.args[1].name)) {
+          this.emit({
+            op: "call_ind",
+            fn,
+            series: expr.args[0].name,
+            series2: expr.args[1].name
+          });
+          return true;
+        }
+        if ((fn === "sma" || fn === "ema" || fn === "rsi" || fn === "highest" || fn === "lowest") && expr.args[0]?.kind === "ident" && SERIES_IDENTIFIERS.has(expr.args[0].name)) {
+          if (!this.emitExpr(expr.args[1], errors, vars)) return false;
+          this.emit({ op: "call_ind", fn, series: expr.args[0].name });
+          return true;
+        }
+        for (const arg of expr.args) {
+          if (!this.emitExpr(arg, errors, vars)) return false;
+        }
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+  emitStmt(stmt, errors, vars, plots) {
+    switch (stmt.kind) {
+      case "block":
+        for (const s of stmt.body) this.emitStmt(s, errors, vars, plots);
+        break;
+      case "var":
+        vars.add(stmt.name);
+        if (this.emitExpr(stmt.init, errors, vars)) this.emit({ op: "store_var", name: stmt.name });
+        break;
+      case "assign":
+        if (!vars.has(stmt.name)) vars.add(stmt.name);
+        if (this.emitExpr(stmt.value, errors, vars)) this.emit({ op: "store_var", name: stmt.name });
+        break;
+      case "plot": {
+        if (!this.emitExpr(stmt.expr, errors, vars)) break;
+        const title = stmt.title ?? `plot_${this.plotIndex++}`;
+        plots.push(title);
+        this.emit({ op: "plot", title });
+        break;
+      }
+      case "expr":
+        if (this.emitExpr(stmt.expr, errors, vars)) this.emit({ op: "pop" });
+        break;
+      case "if": {
+        if (!this.emitExpr(stmt.cond, errors, vars)) break;
+        const jmpFalse = this.emit({ op: "jump_if_false", target: 0 });
+        for (const s of stmt.then) this.emitStmt(s, errors, vars, plots);
+        if (stmt.else?.length) {
+          const jmpEnd = this.emit({ op: "jump", target: 0 });
+          this.patchJump(jmpFalse, this.ops.length);
+          for (const s of stmt.else) this.emitStmt(s, errors, vars, plots);
+          this.patchJump(jmpEnd, this.ops.length);
+        } else {
+          this.patchJump(jmpFalse, this.ops.length);
+        }
+        break;
+      }
+      case "while": {
+        const loopStart = this.ops.length;
+        if (!this.emitExpr(stmt.cond, errors, vars)) break;
+        const jmpEnd = this.emit({ op: "jump_if_false", target: 0 });
+        for (const s of stmt.body) this.emitStmt(s, errors, vars, plots);
+        this.emit({ op: "jump", target: loopStart });
+        this.patchJump(jmpEnd, this.ops.length);
+        break;
+      }
+      case "for": {
+        vars.add(stmt.name);
+        if (!this.emitExpr(stmt.from, errors, vars)) break;
+        this.emit({ op: "store_var", name: stmt.name });
+        const loopStart = this.ops.length;
+        this.emit({ op: "load_var", name: stmt.name });
+        if (!this.emitExpr(stmt.to, errors, vars)) break;
+        this.emit({ op: "cmp", mode: "le" });
+        const jmpEnd = this.emit({ op: "jump_if_false", target: 0 });
+        for (const s of stmt.body) this.emitStmt(s, errors, vars, plots);
+        this.emit({ op: "load_var", name: stmt.name });
+        this.emit({ op: "push", value: 1 });
+        this.emit({ op: "add" });
+        this.emit({ op: "store_var", name: stmt.name });
+        this.emit({ op: "jump", target: loopStart });
+        this.patchJump(jmpEnd, this.ops.length);
+        break;
+      }
+    }
+  }
+};
+function compileAst(program) {
+  const errors = [];
+  const vars = /* @__PURE__ */ new Set();
+  const plots = [];
+  const emitter = new Emitter();
+  for (const stmt of program.body) {
+    emitter.emitStmt(stmt, errors, vars, plots);
+  }
+  if (errors.length) return { ir: null, errors };
+  return {
+    ir: { version: 2, ops: emitter.ops, vars: [...vars], plots },
+    errors
+  };
+}
+
+// src/diagnostics.ts
+function offsetToLineCol(source, offset) {
+  let line = 1;
+  let col = 1;
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source[i] === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+  }
+  return { line, col };
+}
+function diagnosticFromMessage(source, message) {
+  const at = message.match(/\bat\s+(\d+)\b/);
+  if (at) {
+    const pos = Number(at[1]);
+    const { line, col } = offsetToLineCol(source, pos);
+    return { line, col, message: message.replace(/\s+at\s+\d+\s*$/, ""), severity: "error" };
+  }
+  return { line: 1, col: 1, message, severity: "error" };
+}
+function diagnosticsFromMessages(source, messages) {
+  return messages.map((m) => diagnosticFromMessage(source, m));
+}
+
+// src/lexer.ts
+var KEYWORDS = {
+  var: "var",
+  plot: "plot",
+  if: "if",
+  else: "else",
+  while: "while",
+  for: "for",
+  to: "to",
+  and: "and",
+  or: "or",
+  not: "not",
+  true: "true",
+  false: "false"
+};
+function tokenize(source) {
+  const tokens = [];
+  const errors = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  const push = (type, value, pos, startLine, startCol) => {
+    tokens.push({ type, value, pos, line: startLine, col: startCol });
+  };
+  while (i < source.length) {
+    const pos = i;
+    const startLine = line;
+    const startCol = col;
+    const ch = source[i];
+    if (ch === " " || ch === "	" || ch === "\r") {
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "\n") {
+      i++;
+      line++;
+      col = 1;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      i += 2;
+      col += 2;
+      while (i < source.length && source[i] !== "\n") {
+        i++;
+        col++;
+      }
+      continue;
+    }
+    if (ch >= "0" && ch <= "9") {
+      let j = i + 1;
+      while (j < source.length && /[0-9.]/.test(source[j])) j++;
+      const raw = source.slice(i, j);
+      push("number", raw, pos, startLine, startCol);
+      col += j - i;
+      i = j;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      let j = i + 1;
+      while (j < source.length && /[A-Za-z0-9_]/.test(source[j])) j++;
+      const word = source.slice(i, j);
+      const kw = KEYWORDS[word];
+      push(kw ?? "ident", word, pos, startLine, startCol);
+      col += j - i;
+      i = j;
+      continue;
+    }
+    if (ch === ":" && source[i + 1] === "=") {
+      push("assign", ":=", pos, startLine, startCol);
+      i += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "=" && source[i + 1] === "=") {
+      push("eq", "==", pos, startLine, startCol);
+      i += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "!" && source[i + 1] === "=") {
+      push("ne", "!=", pos, startLine, startCol);
+      i += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "<" && source[i + 1] === "=") {
+      push("le", "<=", pos, startLine, startCol);
+      i += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === ">" && source[i + 1] === "=") {
+      push("ge", ">=", pos, startLine, startCol);
+      i += 2;
+      col += 2;
+      continue;
+    }
+    if (ch === "<") {
+      push("lt", "<", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === ">") {
+      push("gt", ">", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "{") {
+      push("lbrace", "{", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "}") {
+      push("rbrace", "}", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "(") {
+      push("lparen", "(", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === ")") {
+      push("rparen", ")", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === ",") {
+      push("comma", ",", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "+") {
+      push("plus", "+", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "-") {
+      push("minus", "-", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "*") {
+      push("star", "*", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "/") {
+      push("slash", "/", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    if (ch === "=") {
+      push("eq", "=", pos, startLine, startCol);
+      i++;
+      col++;
+      continue;
+    }
+    errors.push(`Unexpected '${ch}' at line ${startLine}, col ${startCol}`);
+    i++;
+    col++;
+  }
+  tokens.push({ type: "eof", value: "", pos: i, line, col });
+  return { tokens, errors };
+}
+
+// src/parser.ts
+function parseProgram(tokens) {
+  const errors = [];
+  let i = 0;
+  const peek = () => tokens[i];
+  const at = (t) => peek().type === t;
+  const err = (msg) => {
+    errors.push({ message: msg, line: peek().line, col: peek().col });
+  };
+  const eat = (t) => {
+    if (!at(t)) {
+      err(`Expected ${t}, got ${peek().type}`);
+      return false;
+    }
+    i++;
+    return true;
+  };
+  const parseBlock = () => {
+    if (at("lbrace")) {
+      i++;
+      const body2 = [];
+      while (!at("rbrace") && !at("eof")) {
+        const stmt2 = parseStmt();
+        if (!stmt2) break;
+        body2.push(stmt2);
+      }
+      if (!eat("rbrace")) return body2;
+      return body2;
+    }
+    const stmt = parseStmt();
+    return stmt ? [stmt] : [];
+  };
+  const parseOr = () => {
+    let left = parseAnd();
+    if (!left) return null;
+    while (at("or")) {
+      i++;
+      const right = parseAnd();
+      if (!right) return null;
+      left = { kind: "binary", op: "or", left, right };
+    }
+    return left;
+  };
+  const parseAnd = () => {
+    let left = parseCompare();
+    if (!left) return null;
+    while (at("and")) {
+      i++;
+      const right = parseCompare();
+      if (!right) return null;
+      left = { kind: "binary", op: "and", left, right };
+    }
+    return left;
+  };
+  const parseCompare = () => {
+    let left = parseAdd();
+    if (!left) return null;
+    const cmpTypes = ["eq", "ne", "lt", "gt", "le", "ge"];
+    while (cmpTypes.some((t) => at(t))) {
+      const t = peek().type;
+      const opMap = {
+        eq: "==",
+        ne: "!=",
+        lt: "<",
+        gt: ">",
+        le: "<=",
+        ge: ">="
+      };
+      i++;
+      const right = parseAdd();
+      if (!right) return null;
+      left = { kind: "binary", op: opMap[t], left, right };
+    }
+    return left;
+  };
+  const parseAdd = () => {
+    let left = parseMul();
+    if (!left) return null;
+    while (at("plus") || at("minus")) {
+      const op = peek().type === "plus" ? "+" : "-";
+      i++;
+      const right = parseMul();
+      if (!right) return null;
+      left = { kind: "binary", op, left, right };
+    }
+    return left;
+  };
+  const parseMul = () => {
+    let left = parseUnary();
+    if (!left) return null;
+    while (at("star") || at("slash")) {
+      const op = peek().type === "star" ? "*" : "/";
+      i++;
+      const right = parseUnary();
+      if (!right) return null;
+      left = { kind: "binary", op, left, right };
+    }
+    return left;
+  };
+  const parseUnary = () => {
+    if (at("not")) {
+      i++;
+      const arg = parseUnary();
+      return arg ? { kind: "unary", op: "not", arg } : null;
+    }
+    if (at("minus")) {
+      i++;
+      const arg = parseUnary();
+      return arg ? { kind: "unary", op: "-", arg } : null;
+    }
+    return parsePrimary();
+  };
+  const parsePrimary = () => {
+    const t = peek();
+    if (t.type === "number") {
+      i++;
+      return { kind: "number", value: Number(t.value) };
+    }
+    if (t.type === "true" || t.type === "false") {
+      i++;
+      return { kind: "bool", value: t.type === "true" };
+    }
+    if (t.type === "ident") {
+      const name = t.value;
+      i++;
+      if (at("lparen")) {
+        i++;
+        const args = [];
+        if (!at("rparen")) {
+          const first = parseOr();
+          if (!first) return null;
+          args.push(first);
+          while (at("comma")) {
+            i++;
+            const next = parseOr();
+            if (!next) return null;
+            args.push(next);
+          }
+        }
+        if (!eat("rparen")) return null;
+        return { kind: "call", name, args };
+      }
+      return { kind: "ident", name };
+    }
+    if (at("lparen")) {
+      i++;
+      const inner = parseOr();
+      if (!inner || !eat("rparen")) return null;
+      return inner;
+    }
+    err(`Unexpected token ${t.type}`);
+    return null;
+  };
+  const parseStmt = () => {
+    if (at("if")) {
+      i++;
+      if (!eat("lparen")) return null;
+      const cond = parseOr();
+      if (!cond || !eat("rparen")) return null;
+      const then = parseBlock();
+      let elseBody;
+      if (at("else")) {
+        i++;
+        elseBody = parseBlock();
+      }
+      return { kind: "if", cond, then, else: elseBody };
+    }
+    if (at("while")) {
+      i++;
+      if (!eat("lparen")) return null;
+      const cond = parseOr();
+      if (!cond || !eat("rparen")) return null;
+      const body2 = parseBlock();
+      return { kind: "while", cond, body: body2 };
+    }
+    if (at("for")) {
+      i++;
+      if (!at("ident")) {
+        err("Expected loop variable after for");
+        return null;
+      }
+      const name = peek().value;
+      i++;
+      if (!eat("eq")) return null;
+      const from = parseOr();
+      if (!from || !at("to")) {
+        err('Expected "to" in for loop');
+        return null;
+      }
+      i++;
+      const to = parseOr();
+      if (!to) return null;
+      const body2 = parseBlock();
+      return { kind: "for", name, from, to, body: body2 };
+    }
+    if (at("var")) {
+      i++;
+      if (!at("ident")) {
+        err("Expected identifier after var");
+        return null;
+      }
+      const name = peek().value;
+      i++;
+      if (!eat("eq")) return null;
+      const init = parseOr();
+      return init ? { kind: "var", name, init } : null;
+    }
+    if (at("plot")) {
+      i++;
+      if (!eat("lparen")) return null;
+      const expr = parseOr();
+      if (!expr || !eat("rparen")) return null;
+      return { kind: "plot", expr };
+    }
+    if (at("ident")) {
+      const name = peek().value;
+      i++;
+      if (at("assign") || at("eq")) {
+        i++;
+        const value = parseOr();
+        return value ? { kind: "assign", name, value } : null;
+      }
+      i--;
+      const expr = parseOr();
+      return expr ? { kind: "expr", expr } : null;
+    }
+    if (at("lbrace")) {
+      return { kind: "block", body: parseBlock() };
+    }
+    err(`Unexpected statement ${peek().type}`);
+    return null;
+  };
+  const body = [];
+  while (!at("eof")) {
+    const stmt = parseStmt();
+    if (!stmt) break;
+    body.push(stmt);
+  }
+  if (!at("eof")) err("Unexpected tokens after program end");
+  return { program: { kind: "program", body }, errors };
+}
+
+// src/worker-client.ts
+var worker = null;
+var seq = 0;
+var pending = /* @__PURE__ */ new Map();
+function ensureWorker() {
+  if (typeof Worker === "undefined") return null;
+  if (worker) return worker;
+  try {
+    worker = new Worker(new URL("./pine.worker.js", import.meta.url), { type: "module" });
+    worker.onmessage = (ev) => {
+      const msg = ev.data;
+      const p = pending.get(msg.id);
+      if (!p) return;
+      pending.delete(msg.id);
+      if (msg.ok && msg.result) p.resolve(msg.result);
+      else p.reject(new Error(msg.error ?? "Pine worker failed"));
+    };
+    worker.onerror = () => {
+      for (const [, p] of pending) p.reject(new Error("Pine worker error"));
+      pending.clear();
+      worker?.terminate();
+      worker = null;
+    };
+    return worker;
+  } catch {
+    return null;
+  }
+}
+function runPineLiteAsync(ir, bars, opts) {
+  if (opts?.useWorker === false) {
+    return Promise.resolve(runPineIr(ir, bars));
+  }
+  const w = ensureWorker();
+  if (!w) return Promise.resolve(runPineIr(ir, bars));
+  const id = ++seq;
+  const req = { id, ir, bars };
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    w.postMessage(req);
+  });
+}
+function terminatePineWorker() {
+  worker?.terminate();
+  worker = null;
+  pending.clear();
 }
 
 // src/index.ts
-function compilePineLite(_source) {
-  return { ok: true, errors: [], ir: { version: 0, plots: [] } };
+var MAX_SOURCE_LEN = 32 * 1024;
+function compilePineLite(source) {
+  const diagnostics = [];
+  const pushDiag = (line, col, message) => {
+    diagnostics.push({ line, col, message, severity: "error" });
+  };
+  if (source.length > MAX_SOURCE_LEN) {
+    const msg = `Source exceeds ${MAX_SOURCE_LEN} bytes`;
+    pushDiag(1, 1, msg);
+    return { ok: false, errors: [msg], diagnostics };
+  }
+  const { tokens, errors: lexErr } = tokenize(source);
+  for (const m of lexErr) diagnostics.push(diagnosticFromMessage(source, m));
+  if (lexErr.length) {
+    return { ok: false, errors: lexErr, diagnostics };
+  }
+  const { program, errors: parseErr } = parseProgram(tokens);
+  for (const e of parseErr) pushDiag(e.line, e.col, e.message);
+  if (parseErr.length || !program) {
+    return { ok: false, errors: parseErr.map((e) => e.message), diagnostics };
+  }
+  const { ir, errors: compileErr } = compileAst(program);
+  for (const m of compileErr) diagnostics.push(diagnosticFromMessage(source, m));
+  if (compileErr.length || !ir) {
+    return { ok: false, errors: compileErr, diagnostics };
+  }
+  if (ir.plots.length > 16) {
+    const msg = "Too many plot() calls (max 16)";
+    pushDiag(1, 1, msg);
+    return { ok: false, errors: [msg], diagnostics };
+  }
+  if (ir.vars.length > 256) {
+    const msg = "Too many variables (max 256)";
+    pushDiag(1, 1, msg);
+    return { ok: false, errors: [msg], diagnostics };
+  }
+  return { ok: true, errors: [], diagnostics, ir };
+}
+function runPineLite(ir, bars) {
+  return runPineIr(ir, bars);
+}
+var PINE_SAMPLE_SCRIPT = `// Pine-lite \u2014 if / while / for\u3001\u6BD4\u8F03\u3001and/or/not
+var len = 20
+if (close > 0) {
+  plot(sma(close, len))
+} else {
+  plot(open)
+}
+for i = 1 to 2 {
+  plot(rsi(close, 14))
 }
+`;
+var PINE_EDITOR_DEFAULT = PINE_SAMPLE_SCRIPT;
 export {
+  PINE_EDITOR_DEFAULT,
+  PINE_SAMPLE_SCRIPT,
   compilePineLite,
-  runPineVm
+  diagnosticFromMessage,
+  diagnosticsFromMessages,
+  offsetToLineCol,
+  runPineLite,
+  runPineLiteAsync,
+  terminatePineWorker
 };
 //# sourceMappingURL=index.js.map