@tellahq/rescript 10.1.0-alpha.1

package/lib/es6/node.js

@@ -0,0 +1,39 @@
+
+
+
+function test(x) {
+  if (typeof x === "string") {
+    return [
+            /* String */0,
+            x
+          ];
+  } else {
+    return [
+            /* Buffer */1,
+            x
+          ];
+  }
+}
+
+var Path;
+
+var Fs;
+
+var Process;
+
+var Module;
+
+var $$Buffer;
+
+var Child_process;
+
+export {
+  Path ,
+  Fs ,
+  Process ,
+  Module ,
+  $$Buffer ,
+  Child_process ,
+  test ,
+}
+/* No side effect */

package/lib/es6/node_buffer.js

@@ -0,0 +1 @@
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/lib/es6/node_child_process.js

@@ -0,0 +1 @@
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/lib/es6/node_fs.js

@@ -0,0 +1,9 @@
+
+
+
+var Watch = {};
+
+export {
+  Watch ,
+}
+/* No side effect */

package/lib/es6/node_module.js

@@ -0,0 +1 @@
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/lib/es6/node_path.js

@@ -0,0 +1 @@
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/lib/es6/node_process.js

@@ -0,0 +1,18 @@
+
+
+import * as Js_dict from "./js_dict.js";
+import * as Process from "process";
+
+function putEnvVar(key, $$var) {
+  Process.env[key] = $$var;
+}
+
+function deleteEnvVar(s) {
+  Js_dict.unsafeDeleteKey(Process.env, s);
+}
+
+export {
+  putEnvVar ,
+  deleteEnvVar ,
+}
+/* process Not a pure module */

package/lib/es6/obj.js

@@ -0,0 +1,11 @@
+
+
+
+function is_block(a) {
+  return typeof a !== "number";
+}
+
+export {
+  is_block ,
+}
+/* No side effect */

package/lib/es6/package.json

@@ -0,0 +1 @@
+{"type" : "module"}

package/lib/es6/parsing.js

@@ -0,0 +1,237 @@
+
+
+import * as $$Array from "./array.js";
+import * as Curry from "./curry.js";
+import * as Lexing from "./lexing.js";
+import * as Caml_obj from "./caml_obj.js";
+import * as Caml_array from "./caml_array.js";
+import * as Caml_parser from "./caml_parser.js";
+import * as Caml_exceptions from "./caml_exceptions.js";
+import * as Caml_js_exceptions from "./caml_js_exceptions.js";
+
+var YYexit = /* @__PURE__ */Caml_exceptions.create("Parsing.YYexit");
+
+var Parse_error = /* @__PURE__ */Caml_exceptions.create("Parsing.Parse_error");
+
+var env = {
+  s_stack: Caml_array.make(100, 0),
+  v_stack: Caml_array.make(100, undefined),
+  symb_start_stack: Caml_array.make(100, Lexing.dummy_pos),
+  symb_end_stack: Caml_array.make(100, Lexing.dummy_pos),
+  stacksize: 100,
+  stackbase: 0,
+  curr_char: 0,
+  lval: undefined,
+  symb_start: Lexing.dummy_pos,
+  symb_end: Lexing.dummy_pos,
+  asp: 0,
+  rule_len: 0,
+  rule_number: 0,
+  sp: 0,
+  state: 0,
+  errflag: 0
+};
+
+function grow_stacks(param) {
+  var oldsize = env.stacksize;
+  var newsize = (oldsize << 1);
+  var new_s = Caml_array.make(newsize, 0);
+  var new_v = Caml_array.make(newsize, undefined);
+  var new_start = Caml_array.make(newsize, Lexing.dummy_pos);
+  var new_end = Caml_array.make(newsize, Lexing.dummy_pos);
+  $$Array.blit(env.s_stack, 0, new_s, 0, oldsize);
+  env.s_stack = new_s;
+  $$Array.blit(env.v_stack, 0, new_v, 0, oldsize);
+  env.v_stack = new_v;
+  $$Array.blit(env.symb_start_stack, 0, new_start, 0, oldsize);
+  env.symb_start_stack = new_start;
+  $$Array.blit(env.symb_end_stack, 0, new_end, 0, oldsize);
+  env.symb_end_stack = new_end;
+  env.stacksize = newsize;
+}
+
+function clear_parser(param) {
+  $$Array.fill(env.v_stack, 0, env.stacksize, undefined);
+  env.lval = undefined;
+}
+
+var current_lookahead_fun = {
+  contents: (function (param) {
+      return false;
+    })
+};
+
+function yyparse(tables, start, lexer, lexbuf) {
+  var init_asp = env.asp;
+  var init_sp = env.sp;
+  var init_stackbase = env.stackbase;
+  var init_state = env.state;
+  var init_curr_char = env.curr_char;
+  var init_lval = env.lval;
+  var init_errflag = env.errflag;
+  env.stackbase = env.sp + 1 | 0;
+  env.curr_char = start;
+  env.symb_end = lexbuf.lex_curr_p;
+  try {
+    var _cmd = /* Start */0;
+    var _arg;
+    while(true) {
+      var arg = _arg;
+      var cmd = _cmd;
+      var match = Caml_parser.parse_engine(tables, env, cmd, arg);
+      switch (match) {
+        case /* Read_token */0 :
+            var t = Curry._1(lexer, lexbuf);
+            env.symb_start = lexbuf.lex_start_p;
+            env.symb_end = lexbuf.lex_curr_p;
+            _arg = t;
+            _cmd = /* Token_read */1;
+            continue ;
+        case /* Raise_parse_error */1 :
+            throw {
+                  RE_EXN_ID: Parse_error,
+                  Error: new Error()
+                };
+        case /* Grow_stacks_1 */2 :
+            grow_stacks(undefined);
+            _arg = undefined;
+            _cmd = /* Stacks_grown_1 */2;
+            continue ;
+        case /* Grow_stacks_2 */3 :
+            grow_stacks(undefined);
+            _arg = undefined;
+            _cmd = /* Stacks_grown_2 */3;
+            continue ;
+        case /* Compute_semantic_action */4 :
+            var match$1;
+            try {
+              match$1 = [
+                /* Semantic_action_computed */4,
+                Curry._1(Caml_array.get(tables.actions, env.rule_number), env)
+              ];
+            }
+            catch (raw_exn){
+              var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+              if (exn.RE_EXN_ID === Parse_error) {
+                match$1 = [
+                  /* Error_detected */5,
+                  undefined
+                ];
+              } else {
+                throw exn;
+              }
+            }
+            _arg = match$1[1];
+            _cmd = match$1[0];
+            continue ;
+        case /* Call_error_function */5 :
+            Curry._1(tables.error_function, "syntax error");
+            _arg = undefined;
+            _cmd = /* Error_detected */5;
+            continue ;
+        
+      }
+    };
+  }
+  catch (raw_exn$1){
+    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+    var curr_char = env.curr_char;
+    env.asp = init_asp;
+    env.sp = init_sp;
+    env.stackbase = init_stackbase;
+    env.state = init_state;
+    env.curr_char = init_curr_char;
+    env.lval = init_lval;
+    env.errflag = init_errflag;
+    if (exn$1.RE_EXN_ID === YYexit) {
+      return exn$1._1;
+    }
+    current_lookahead_fun.contents = (function (tok) {
+        if (typeof tok !== "number") {
+          return Caml_array.get(tables.transl_block, tok.TAG | 0) === curr_char;
+        } else {
+          return Caml_array.get(tables.transl_const, tok) === curr_char;
+        }
+      });
+    throw exn$1;
+  }
+}
+
+function peek_val(env, n) {
+  return Caml_array.get(env.v_stack, env.asp - n | 0);
+}
+
+function symbol_start_pos(param) {
+  var _i = env.rule_len;
+  while(true) {
+    var i = _i;
+    if (i <= 0) {
+      return Caml_array.get(env.symb_end_stack, env.asp);
+    }
+    var st = Caml_array.get(env.symb_start_stack, (env.asp - i | 0) + 1 | 0);
+    var en = Caml_array.get(env.symb_end_stack, (env.asp - i | 0) + 1 | 0);
+    if (Caml_obj.notequal(st, en)) {
+      return st;
+    }
+    _i = i - 1 | 0;
+    continue ;
+  };
+}
+
+function symbol_end_pos(param) {
+  return Caml_array.get(env.symb_end_stack, env.asp);
+}
+
+function rhs_start_pos(n) {
+  return Caml_array.get(env.symb_start_stack, env.asp - (env.rule_len - n | 0) | 0);
+}
+
+function rhs_end_pos(n) {
+  return Caml_array.get(env.symb_end_stack, env.asp - (env.rule_len - n | 0) | 0);
+}
+
+function symbol_start(param) {
+  return symbol_start_pos(undefined).pos_cnum;
+}
+
+function symbol_end(param) {
+  return symbol_end_pos(undefined).pos_cnum;
+}
+
+function rhs_start(n) {
+  return rhs_start_pos(n).pos_cnum;
+}
+
+function rhs_end(n) {
+  return rhs_end_pos(n).pos_cnum;
+}
+
+function is_current_lookahead(tok) {
+  return Curry._1(current_lookahead_fun.contents, tok);
+}
+
+function parse_error(param) {
+  
+}
+
+var set_trace = Caml_parser.set_parser_trace;
+
+export {
+  symbol_start ,
+  symbol_end ,
+  rhs_start ,
+  rhs_end ,
+  symbol_start_pos ,
+  symbol_end_pos ,
+  rhs_start_pos ,
+  rhs_end_pos ,
+  clear_parser ,
+  Parse_error ,
+  set_trace ,
+  YYexit ,
+  yyparse ,
+  peek_val ,
+  is_current_lookahead ,
+  parse_error ,
+}
+/* No side effect */

package/lib/es6/pervasives.js

@@ -0,0 +1,250 @@
+
+
+import * as Curry from "./curry.js";
+import * as Caml_sys from "./caml_sys.js";
+import * as Caml_format from "./caml_format.js";
+import * as Caml_string from "./caml_string.js";
+import * as Caml_exceptions from "./caml_exceptions.js";
+import * as Caml_js_exceptions from "./caml_js_exceptions.js";
+
+function failwith(s) {
+  throw {
+        RE_EXN_ID: "Failure",
+        _1: s,
+        Error: new Error()
+      };
+}
+
+function invalid_arg(s) {
+  throw {
+        RE_EXN_ID: "Invalid_argument",
+        _1: s,
+        Error: new Error()
+      };
+}
+
+var Exit = /* @__PURE__ */Caml_exceptions.create("Pervasives.Exit");
+
+function abs(x) {
+  if (x >= 0) {
+    return x;
+  } else {
+    return -x | 0;
+  }
+}
+
+function lnot(x) {
+  return x ^ -1;
+}
+
+var min_int = -2147483648;
+
+function classify_float(x) {
+  if (isFinite(x)) {
+    if (Math.abs(x) >= 2.22507385850720138e-308) {
+      return /* FP_normal */0;
+    } else if (x !== 0) {
+      return /* FP_subnormal */1;
+    } else {
+      return /* FP_zero */2;
+    }
+  } else if (isNaN(x)) {
+    return /* FP_nan */4;
+  } else {
+    return /* FP_infinite */3;
+  }
+}
+
+function char_of_int(n) {
+  if (n < 0 || n > 255) {
+    throw {
+          RE_EXN_ID: "Invalid_argument",
+          _1: "char_of_int",
+          Error: new Error()
+        };
+  }
+  return n;
+}
+
+function string_of_bool(b) {
+  if (b) {
+    return "true";
+  } else {
+    return "false";
+  }
+}
+
+function bool_of_string(param) {
+  switch (param) {
+    case "false" :
+        return false;
+    case "true" :
+        return true;
+    default:
+      throw {
+            RE_EXN_ID: "Invalid_argument",
+            _1: "bool_of_string",
+            Error: new Error()
+          };
+  }
+}
+
+function bool_of_string_opt(param) {
+  switch (param) {
+    case "false" :
+        return false;
+    case "true" :
+        return true;
+    default:
+      return ;
+  }
+}
+
+function int_of_string_opt(s) {
+  try {
+    return Caml_format.int_of_string(s);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Failure") {
+      return ;
+    }
+    throw exn;
+  }
+}
+
+function valid_float_lexem(s) {
+  var l = s.length;
+  var _i = 0;
+  while(true) {
+    var i = _i;
+    if (i >= l) {
+      return s + ".";
+    }
+    var match = Caml_string.get(s, i);
+    if (match >= 48) {
+      if (match >= 58) {
+        return s;
+      }
+      _i = i + 1 | 0;
+      continue ;
+    }
+    if (match !== 45) {
+      return s;
+    }
+    _i = i + 1 | 0;
+    continue ;
+  };
+}
+
+function string_of_float(f) {
+  return valid_float_lexem(Caml_format.format_float("%.12g", f));
+}
+
+function float_of_string_opt(s) {
+  try {
+    return Caml_format.float_of_string(s);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Failure") {
+      return ;
+    }
+    throw exn;
+  }
+}
+
+function $at(l1, l2) {
+  if (l1) {
+    return {
+            hd: l1.hd,
+            tl: $at(l1.tl, l2)
+          };
+  } else {
+    return l2;
+  }
+}
+
+function print_newline(param) {
+  console.log("");
+}
+
+function prerr_newline(param) {
+  console.error("");
+}
+
+function print_int(i) {
+  console.log(String(i));
+}
+
+function print_float(i) {
+  console.log(valid_float_lexem(Caml_format.format_float("%.12g", i)));
+}
+
+function print_string(prim) {
+  console.log(prim);
+}
+
+var exit_function = {
+  contents: (function (prim) {
+      
+    })
+};
+
+function at_exit(f) {
+  var g = exit_function.contents;
+  exit_function.contents = (function (param) {
+      Curry._1(f, undefined);
+      Curry._1(g, undefined);
+    });
+}
+
+function exit(retcode) {
+  Curry._1(exit_function.contents, undefined);
+  return Caml_sys.sys_exit(retcode);
+}
+
+var max_int = 2147483647;
+
+var infinity = Infinity;
+
+var neg_infinity = -Infinity;
+
+var max_float = 1.79769313486231571e+308;
+
+var min_float = 2.22507385850720138e-308;
+
+var epsilon_float = 2.22044604925031308e-16;
+
+export {
+  invalid_arg ,
+  failwith ,
+  Exit ,
+  abs ,
+  max_int ,
+  min_int ,
+  lnot ,
+  infinity ,
+  neg_infinity ,
+  max_float ,
+  min_float ,
+  epsilon_float ,
+  classify_float ,
+  char_of_int ,
+  string_of_bool ,
+  bool_of_string ,
+  bool_of_string_opt ,
+  int_of_string_opt ,
+  string_of_float ,
+  float_of_string_opt ,
+  $at ,
+  print_string ,
+  print_int ,
+  print_float ,
+  print_newline ,
+  prerr_newline ,
+  exit ,
+  at_exit ,
+  valid_float_lexem ,
+}
+/* No side effect */

package/lib/es6/printexc.js

@@ -0,0 +1,102 @@
+
+
+import * as Curry from "./curry.js";
+import * as Pervasives from "./pervasives.js";
+import * as Caml_exceptions from "./caml_exceptions.js";
+import * as Caml_js_exceptions from "./caml_js_exceptions.js";
+
+var printers = {
+  contents: /* [] */0
+};
+
+function locfmt(s, linum, start, finish, msg) {
+  return "File \"" + s + "\", line " + linum + ", characters " + start + "-" + finish + ": " + msg;
+}
+
+var fields = (function(x){
+  var s = "" 
+  var index = 1
+  while ("_"+index in x){
+    s += x ["_" + index];
+    ++ index
+  }
+  if(index === 1){
+    return s 
+  }
+  return "(" + s + ")"
+});
+
+function to_string(x) {
+  var _param = printers.contents;
+  while(true) {
+    var param = _param;
+    if (param) {
+      var s;
+      try {
+        s = Curry._1(param.hd, x);
+      }
+      catch (exn){
+        s = undefined;
+      }
+      if (s !== undefined) {
+        return s;
+      }
+      _param = param.tl;
+      continue ;
+    }
+    if (x.RE_EXN_ID === "Match_failure") {
+      var match = x._1;
+      var $$char = match[2];
+      return locfmt(match[0], match[1], $$char, $$char + 5 | 0, "Pattern matching failed");
+    }
+    if (x.RE_EXN_ID === "Assert_failure") {
+      var match$1 = x._1;
+      var $$char$1 = match$1[2];
+      return locfmt(match$1[0], match$1[1], $$char$1, $$char$1 + 6 | 0, "Assertion failed");
+    }
+    if (x.RE_EXN_ID === "Undefined_recursive_module") {
+      var match$2 = x._1;
+      var $$char$2 = match$2[2];
+      return locfmt(match$2[0], match$2[1], $$char$2, $$char$2 + 6 | 0, "Undefined recursive module");
+    }
+    var constructor = Caml_exceptions.exn_slot_name(x);
+    return constructor + fields(x);
+  };
+}
+
+function print(fct, arg) {
+  try {
+    return Curry._1(fct, arg);
+  }
+  catch (raw_x){
+    var x = Caml_js_exceptions.internalToOCamlException(raw_x);
+    console.log("Uncaught exception: " + to_string(x));
+    throw x;
+  }
+}
+
+function $$catch(fct, arg) {
+  try {
+    return Curry._1(fct, arg);
+  }
+  catch (raw_x){
+    var x = Caml_js_exceptions.internalToOCamlException(raw_x);
+    console.log("Uncaught exception: " + to_string(x));
+    return Pervasives.exit(2);
+  }
+}
+
+function register_printer(fn) {
+  printers.contents = {
+    hd: fn,
+    tl: printers.contents
+  };
+}
+
+export {
+  to_string ,
+  print ,
+  $$catch ,
+  register_printer ,
+}
+/* No side effect */