repl-sdk 0.0.0 → 1.0.1

package/dist/haxe-7MlzfeYV.js

@@ -0,0 +1,515 @@
+function kw(type2) {
+  return { type: type2, style: "keyword" };
+}
+var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
+var operator = kw("operator"), atom = { type: "atom", style: "atom" }, attribute = { type: "attribute", style: "attribute" };
+var type = kw("typedef");
+var keywords = {
+  "if": A,
+  "while": A,
+  "else": B,
+  "do": B,
+  "try": B,
+  "return": C,
+  "break": C,
+  "continue": C,
+  "new": C,
+  "throw": C,
+  "var": kw("var"),
+  "inline": attribute,
+  "static": attribute,
+  "using": kw("import"),
+  "public": attribute,
+  "private": attribute,
+  "cast": kw("cast"),
+  "import": kw("import"),
+  "macro": kw("macro"),
+  "function": kw("function"),
+  "catch": kw("catch"),
+  "untyped": kw("untyped"),
+  "callback": kw("cb"),
+  "for": kw("for"),
+  "switch": kw("switch"),
+  "case": kw("case"),
+  "default": kw("default"),
+  "in": operator,
+  "never": kw("property_access"),
+  "trace": kw("trace"),
+  "class": type,
+  "abstract": type,
+  "enum": type,
+  "interface": type,
+  "typedef": type,
+  "extends": type,
+  "implements": type,
+  "dynamic": type,
+  "true": atom,
+  "false": atom,
+  "null": atom
+};
+var isOperatorChar = /[+\-*&%=<>!?|]/;
+function chain(stream, state, f) {
+  state.tokenize = f;
+  return f(stream, state);
+}
+function toUnescaped(stream, end) {
+  var escaped = false, next;
+  while ((next = stream.next()) != null) {
+    if (next == end && !escaped)
+      return true;
+    escaped = !escaped && next == "\\";
+  }
+}
+var type, content;
+function ret(tp, style, cont2) {
+  type = tp;
+  content = cont2;
+  return style;
+}
+function haxeTokenBase(stream, state) {
+  var ch = stream.next();
+  if (ch == '"' || ch == "'") {
+    return chain(stream, state, haxeTokenString(ch));
+  } else if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+    return ret(ch);
+  } else if (ch == "0" && stream.eat(/x/i)) {
+    stream.eatWhile(/[\da-f]/i);
+    return ret("number", "number");
+  } else if (/\d/.test(ch) || ch == "-" && stream.eat(/\d/)) {
+    stream.match(/^\d*(?:\.\d*(?!\.))?(?:[eE][+\-]?\d+)?/);
+    return ret("number", "number");
+  } else if (state.reAllowed && (ch == "~" && stream.eat(/\//))) {
+    toUnescaped(stream, "/");
+    stream.eatWhile(/[gimsu]/);
+    return ret("regexp", "string.special");
+  } else if (ch == "/") {
+    if (stream.eat("*")) {
+      return chain(stream, state, haxeTokenComment);
+    } else if (stream.eat("/")) {
+      stream.skipToEnd();
+      return ret("comment", "comment");
+    } else {
+      stream.eatWhile(isOperatorChar);
+      return ret("operator", null, stream.current());
+    }
+  } else if (ch == "#") {
+    stream.skipToEnd();
+    return ret("conditional", "meta");
+  } else if (ch == "@") {
+    stream.eat(/:/);
+    stream.eatWhile(/[\w_]/);
+    return ret("metadata", "meta");
+  } else if (isOperatorChar.test(ch)) {
+    stream.eatWhile(isOperatorChar);
+    return ret("operator", null, stream.current());
+  } else {
+    var word;
+    if (/[A-Z]/.test(ch)) {
+      stream.eatWhile(/[\w_<>]/);
+      word = stream.current();
+      return ret("type", "type", word);
+    } else {
+      stream.eatWhile(/[\w_]/);
+      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
+      return known && state.kwAllowed ? ret(known.type, known.style, word) : ret("variable", "variable", word);
+    }
+  }
+}
+function haxeTokenString(quote) {
+  return function(stream, state) {
+    if (toUnescaped(stream, quote))
+      state.tokenize = haxeTokenBase;
+    return ret("string", "string");
+  };
+}
+function haxeTokenComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "/" && maybeEnd) {
+      state.tokenize = haxeTokenBase;
+      break;
+    }
+    maybeEnd = ch == "*";
+  }
+  return ret("comment", "comment");
+}
+var atomicTypes = { "atom": true, "number": true, "variable": true, "string": true, "regexp": true };
+function HaxeLexical(indented, column, type2, align, prev, info) {
+  this.indented = indented;
+  this.column = column;
+  this.type = type2;
+  this.prev = prev;
+  this.info = info;
+  if (align != null) this.align = align;
+}
+function inScope(state, varname) {
+  for (var v = state.localVars; v; v = v.next)
+    if (v.name == varname) return true;
+}
+function parseHaxe(state, style, type2, content2, stream) {
+  var cc = state.cc;
+  cx.state = state;
+  cx.stream = stream;
+  cx.marked = null, cx.cc = cc;
+  if (!state.lexical.hasOwnProperty("align"))
+    state.lexical.align = true;
+  while (true) {
+    var combinator = cc.length ? cc.pop() : statement;
+    if (combinator(type2, content2)) {
+      while (cc.length && cc[cc.length - 1].lex)
+        cc.pop()();
+      if (cx.marked) return cx.marked;
+      if (type2 == "variable" && inScope(state, content2)) return "variableName.local";
+      if (type2 == "variable" && imported(state, content2)) return "variableName.special";
+      return style;
+    }
+  }
+}
+function imported(state, typename) {
+  if (/[a-z]/.test(typename.charAt(0)))
+    return false;
+  var len = state.importedtypes.length;
+  for (var i = 0; i < len; i++)
+    if (state.importedtypes[i] == typename) return true;
+}
+function registerimport(importname) {
+  var state = cx.state;
+  for (var t = state.importedtypes; t; t = t.next)
+    if (t.name == importname) return;
+  state.importedtypes = { name: importname, next: state.importedtypes };
+}
+var cx = { state: null, marked: null, cc: null };
+function pass() {
+  for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
+}
+function cont() {
+  pass.apply(null, arguments);
+  return true;
+}
+function inList(name, list) {
+  for (var v = list; v; v = v.next)
+    if (v.name == name) return true;
+  return false;
+}
+function register(varname) {
+  var state = cx.state;
+  if (state.context) {
+    cx.marked = "def";
+    if (inList(varname, state.localVars)) return;
+    state.localVars = { name: varname, next: state.localVars };
+  } else if (state.globalVars) {
+    if (inList(varname, state.globalVars)) return;
+    state.globalVars = { name: varname, next: state.globalVars };
+  }
+}
+var defaultVars = { name: "this", next: null };
+function pushcontext() {
+  if (!cx.state.context) cx.state.localVars = defaultVars;
+  cx.state.context = { prev: cx.state.context, vars: cx.state.localVars };
+}
+function popcontext() {
+  cx.state.localVars = cx.state.context.vars;
+  cx.state.context = cx.state.context.prev;
+}
+popcontext.lex = true;
+function pushlex(type2, info) {
+  var result = function() {
+    var state = cx.state;
+    state.lexical = new HaxeLexical(state.indented, cx.stream.column(), type2, null, state.lexical, info);
+  };
+  result.lex = true;
+  return result;
+}
+function poplex() {
+  var state = cx.state;
+  if (state.lexical.prev) {
+    if (state.lexical.type == ")")
+      state.indented = state.lexical.indented;
+    state.lexical = state.lexical.prev;
+  }
+}
+poplex.lex = true;
+function expect(wanted) {
+  function f(type2) {
+    if (type2 == wanted) return cont();
+    else if (wanted == ";") return pass();
+    else return cont(f);
+  }
+  return f;
+}
+function statement(type2) {
+  if (type2 == "@") return cont(metadef);
+  if (type2 == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
+  if (type2 == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+  if (type2 == "keyword b") return cont(pushlex("form"), statement, poplex);
+  if (type2 == "{") return cont(pushlex("}"), pushcontext, block, poplex, popcontext);
+  if (type2 == ";") return cont();
+  if (type2 == "attribute") return cont(maybeattribute);
+  if (type2 == "function") return cont(functiondef);
+  if (type2 == "for") return cont(
+    pushlex("form"),
+    expect("("),
+    pushlex(")"),
+    forspec1,
+    expect(")"),
+    poplex,
+    statement,
+    poplex
+  );
+  if (type2 == "variable") return cont(pushlex("stat"), maybelabel);
+  if (type2 == "switch") return cont(
+    pushlex("form"),
+    expression,
+    pushlex("}", "switch"),
+    expect("{"),
+    block,
+    poplex,
+    poplex
+  );
+  if (type2 == "case") return cont(expression, expect(":"));
+  if (type2 == "default") return cont(expect(":"));
+  if (type2 == "catch") return cont(
+    pushlex("form"),
+    pushcontext,
+    expect("("),
+    funarg,
+    expect(")"),
+    statement,
+    poplex,
+    popcontext
+  );
+  if (type2 == "import") return cont(importdef, expect(";"));
+  if (type2 == "typedef") return cont(typedef);
+  return pass(pushlex("stat"), expression, expect(";"), poplex);
+}
+function expression(type2) {
+  if (atomicTypes.hasOwnProperty(type2)) return cont(maybeoperator);
+  if (type2 == "type") return cont(maybeoperator);
+  if (type2 == "function") return cont(functiondef);
+  if (type2 == "keyword c") return cont(maybeexpression);
+  if (type2 == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeoperator);
+  if (type2 == "operator") return cont(expression);
+  if (type2 == "[") return cont(pushlex("]"), commasep(maybeexpression, "]"), poplex, maybeoperator);
+  if (type2 == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+  return cont();
+}
+function maybeexpression(type2) {
+  if (type2.match(/[;\}\)\],]/)) return pass();
+  return pass(expression);
+}
+function maybeoperator(type2, value) {
+  if (type2 == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
+  if (type2 == "operator" || type2 == ":") return cont(expression);
+  if (type2 == ";") return;
+  if (type2 == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
+  if (type2 == ".") return cont(property, maybeoperator);
+  if (type2 == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
+}
+function maybeattribute(type2) {
+  if (type2 == "attribute") return cont(maybeattribute);
+  if (type2 == "function") return cont(functiondef);
+  if (type2 == "var") return cont(vardef1);
+}
+function metadef(type2) {
+  if (type2 == ":") return cont(metadef);
+  if (type2 == "variable") return cont(metadef);
+  if (type2 == "(") return cont(pushlex(")"), commasep(metaargs, ")"), poplex, statement);
+}
+function metaargs(type2) {
+  if (type2 == "variable") return cont();
+}
+function importdef(type2, value) {
+  if (type2 == "variable" && /[A-Z]/.test(value.charAt(0))) {
+    registerimport(value);
+    return cont();
+  } else if (type2 == "variable" || type2 == "property" || type2 == "." || value == "*") return cont(importdef);
+}
+function typedef(type2, value) {
+  if (type2 == "variable" && /[A-Z]/.test(value.charAt(0))) {
+    registerimport(value);
+    return cont();
+  } else if (type2 == "type" && /[A-Z]/.test(value.charAt(0))) {
+    return cont();
+  }
+}
+function maybelabel(type2) {
+  if (type2 == ":") return cont(poplex, statement);
+  return pass(maybeoperator, expect(";"), poplex);
+}
+function property(type2) {
+  if (type2 == "variable") {
+    cx.marked = "property";
+    return cont();
+  }
+}
+function objprop(type2) {
+  if (type2 == "variable") cx.marked = "property";
+  if (atomicTypes.hasOwnProperty(type2)) return cont(expect(":"), expression);
+}
+function commasep(what, end) {
+  function proceed(type2) {
+    if (type2 == ",") return cont(what, proceed);
+    if (type2 == end) return cont();
+    return cont(expect(end));
+  }
+  return function(type2) {
+    if (type2 == end) return cont();
+    else return pass(what, proceed);
+  };
+}
+function block(type2) {
+  if (type2 == "}") return cont();
+  return pass(statement, block);
+}
+function vardef1(type2, value) {
+  if (type2 == "variable") {
+    register(value);
+    return cont(typeuse, vardef2);
+  }
+  return cont();
+}
+function vardef2(type2, value) {
+  if (value == "=") return cont(expression, vardef2);
+  if (type2 == ",") return cont(vardef1);
+}
+function forspec1(type2, value) {
+  if (type2 == "variable") {
+    register(value);
+    return cont(forin, expression);
+  } else {
+    return pass();
+  }
+}
+function forin(_type, value) {
+  if (value == "in") return cont();
+}
+function functiondef(type2, value) {
+  if (type2 == "variable" || type2 == "type") {
+    register(value);
+    return cont(functiondef);
+  }
+  if (value == "new") return cont(functiondef);
+  if (type2 == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, typeuse, statement, popcontext);
+}
+function typeuse(type2) {
+  if (type2 == ":") return cont(typestring);
+}
+function typestring(type2) {
+  if (type2 == "type") return cont();
+  if (type2 == "variable") return cont();
+  if (type2 == "{") return cont(pushlex("}"), commasep(typeprop, "}"), poplex);
+}
+function typeprop(type2) {
+  if (type2 == "variable") return cont(typeuse);
+}
+function funarg(type2, value) {
+  if (type2 == "variable") {
+    register(value);
+    return cont(typeuse);
+  }
+}
+const haxe = {
+  name: "haxe",
+  startState: function(indentUnit) {
+    var defaulttypes = ["Int", "Float", "String", "Void", "Std", "Bool", "Dynamic", "Array"];
+    var state = {
+      tokenize: haxeTokenBase,
+      reAllowed: true,
+      kwAllowed: true,
+      cc: [],
+      lexical: new HaxeLexical(-indentUnit, 0, "block", false),
+      importedtypes: defaulttypes,
+      context: null,
+      indented: 0
+    };
+    return state;
+  },
+  token: function(stream, state) {
+    if (stream.sol()) {
+      if (!state.lexical.hasOwnProperty("align"))
+        state.lexical.align = false;
+      state.indented = stream.indentation();
+    }
+    if (stream.eatSpace()) return null;
+    var style = state.tokenize(stream, state);
+    if (type == "comment") return style;
+    state.reAllowed = !!(type == "operator" || type == "keyword c" || type.match(/^[\[{}\(,;:]$/));
+    state.kwAllowed = type != ".";
+    return parseHaxe(state, style, type, content, stream);
+  },
+  indent: function(state, textAfter, cx2) {
+    if (state.tokenize != haxeTokenBase) return 0;
+    var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;
+    if (lexical.type == "stat" && firstChar == "}") lexical = lexical.prev;
+    var type2 = lexical.type, closing = firstChar == type2;
+    if (type2 == "vardef") return lexical.indented + 4;
+    else if (type2 == "form" && firstChar == "{") return lexical.indented;
+    else if (type2 == "stat" || type2 == "form") return lexical.indented + cx2.unit;
+    else if (lexical.info == "switch" && !closing)
+      return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? cx2.unit : 2 * cx2.unit);
+    else if (lexical.align) return lexical.column + (closing ? 0 : 1);
+    else return lexical.indented + (closing ? 0 : cx2.unit);
+  },
+  languageData: {
+    indentOnInput: /^\s*[{}]$/,
+    commentTokens: { line: "//", block: { open: "/*", close: "*/" } }
+  }
+};
+const hxml = {
+  name: "hxml",
+  startState: function() {
+    return {
+      define: false,
+      inString: false
+    };
+  },
+  token: function(stream, state) {
+    var ch = stream.peek();
+    var sol = stream.sol();
+    if (ch == "#") {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (sol && ch == "-") {
+      var style = "variable-2";
+      stream.eat(/-/);
+      if (stream.peek() == "-") {
+        stream.eat(/-/);
+        style = "keyword a";
+      }
+      if (stream.peek() == "D") {
+        stream.eat(/[D]/);
+        style = "keyword c";
+        state.define = true;
+      }
+      stream.eatWhile(/[A-Z]/i);
+      return style;
+    }
+    var ch = stream.peek();
+    if (state.inString == false && ch == "'") {
+      state.inString = true;
+      stream.next();
+    }
+    if (state.inString == true) {
+      if (stream.skipTo("'")) ;
+      else {
+        stream.skipToEnd();
+      }
+      if (stream.peek() == "'") {
+        stream.next();
+        state.inString = false;
+      }
+      return "string";
+    }
+    stream.next();
+    return null;
+  },
+  languageData: {
+    commentTokens: { line: "#" }
+  }
+};
+export {
+  haxe,
+  hxml
+};
+//# sourceMappingURL=haxe-7MlzfeYV.js.map

package/dist/haxe-7MlzfeYV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haxe-7MlzfeYV.js","sources":["../../../node_modules/.pnpm/@codemirror+legacy-modes@6.5.2/node_modules/@codemirror/legacy-modes/mode/haxe.js"],"sourcesContent":["// Tokenizer\n\nfunction kw(type) {return {type: type, style: \"keyword\"};}\nvar A = kw(\"keyword a\"), B = kw(\"keyword b\"), C = kw(\"keyword c\");\nvar operator = kw(\"operator\"), atom = {type: \"atom\", style: \"atom\"}, attribute = {type:\"attribute\", style: \"attribute\"};\nvar type = kw(\"typedef\");\nvar keywords = {\n  \"if\": A, \"while\": A, \"else\": B, \"do\": B, \"try\": B,\n  \"return\": C, \"break\": C, \"continue\": C, \"new\": C, \"throw\": C,\n  \"var\": kw(\"var\"), \"inline\":attribute, \"static\": attribute, \"using\":kw(\"import\"),\n  \"public\": attribute, \"private\": attribute, \"cast\": kw(\"cast\"), \"import\": kw(\"import\"), \"macro\": kw(\"macro\"),\n  \"function\": kw(\"function\"), \"catch\": kw(\"catch\"), \"untyped\": kw(\"untyped\"), \"callback\": kw(\"cb\"),\n  \"for\": kw(\"for\"), \"switch\": kw(\"switch\"), \"case\": kw(\"case\"), \"default\": kw(\"default\"),\n  \"in\": operator, \"never\": kw(\"property_access\"), \"trace\":kw(\"trace\"),\n  \"class\": type, \"abstract\":type, \"enum\":type, \"interface\":type, \"typedef\":type, \"extends\":type, \"implements\":type, \"dynamic\":type,\n  \"true\": atom, \"false\": atom, \"null\": atom\n};\n\nvar isOperatorChar = /[+\\-*&%=<>!?|]/;\n\nfunction chain(stream, state, f) {\n  state.tokenize = f;\n  return f(stream, state);\n}\n\nfunction toUnescaped(stream, end) {\n  var escaped = false, next;\n  while ((next = stream.next()) != null) {\n    if (next == end && !escaped)\n      return true;\n    escaped = !escaped && next == \"\\\\\";\n  }\n}\n\n// Used as scratch variables to communicate multiple values without\n// consing up tons of objects.\nvar type, content;\nfunction ret(tp, style, cont) {\n  type = tp; content = cont;\n  return style;\n}\n\nfunction haxeTokenBase(stream, state) {\n  var ch = stream.next();\n  if (ch == '\"' || ch == \"'\") {\n    return chain(stream, state, haxeTokenString(ch));\n  } else if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n    return ret(ch);\n  } else if (ch == \"0\" && stream.eat(/x/i)) {\n    stream.eatWhile(/[\\da-f]/i);\n    return ret(\"number\", \"number\");\n  } else if (/\\d/.test(ch) || ch == \"-\" && stream.eat(/\\d/)) {\n    stream.match(/^\\d*(?:\\.\\d*(?!\\.))?(?:[eE][+\\-]?\\d+)?/);\n    return ret(\"number\", \"number\");\n  } else if (state.reAllowed && (ch == \"~\" && stream.eat(/\\//))) {\n    toUnescaped(stream, \"/\");\n    stream.eatWhile(/[gimsu]/);\n    return ret(\"regexp\", \"string.special\");\n  } else if (ch == \"/\") {\n    if (stream.eat(\"*\")) {\n      return chain(stream, state, haxeTokenComment);\n    } else if (stream.eat(\"/\")) {\n      stream.skipToEnd();\n      return ret(\"comment\", \"comment\");\n    } else {\n      stream.eatWhile(isOperatorChar);\n      return ret(\"operator\", null, stream.current());\n    }\n  } else if (ch == \"#\") {\n    stream.skipToEnd();\n    return ret(\"conditional\", \"meta\");\n  } else if (ch == \"@\") {\n    stream.eat(/:/);\n    stream.eatWhile(/[\\w_]/);\n    return ret (\"metadata\", \"meta\");\n  } else if (isOperatorChar.test(ch)) {\n    stream.eatWhile(isOperatorChar);\n    return ret(\"operator\", null, stream.current());\n  } else {\n    var word;\n    if(/[A-Z]/.test(ch)) {\n      stream.eatWhile(/[\\w_<>]/);\n      word = stream.current();\n      return ret(\"type\", \"type\", word);\n    } else {\n      stream.eatWhile(/[\\w_]/);\n      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];\n      return (known && state.kwAllowed) ? ret(known.type, known.style, word) :\n        ret(\"variable\", \"variable\", word);\n    }\n  }\n}\n\nfunction haxeTokenString(quote) {\n  return function(stream, state) {\n    if (toUnescaped(stream, quote))\n      state.tokenize = haxeTokenBase;\n    return ret(\"string\", \"string\");\n  };\n}\n\nfunction haxeTokenComment(stream, state) {\n  var maybeEnd = false, ch;\n  while (ch = stream.next()) {\n    if (ch == \"/\" && maybeEnd) {\n      state.tokenize = haxeTokenBase;\n      break;\n    }\n    maybeEnd = (ch == \"*\");\n  }\n  return ret(\"comment\", \"comment\");\n}\n\n// Parser\n\nvar atomicTypes = {\"atom\": true, \"number\": true, \"variable\": true, \"string\": true, \"regexp\": true};\n\nfunction HaxeLexical(indented, column, type, align, prev, info) {\n  this.indented = indented;\n  this.column = column;\n  this.type = type;\n  this.prev = prev;\n  this.info = info;\n  if (align != null) this.align = align;\n}\n\nfunction inScope(state, varname) {\n  for (var v = state.localVars; v; v = v.next)\n    if (v.name == varname) return true;\n}\n\nfunction parseHaxe(state, style, type, content, stream) {\n  var cc = state.cc;\n  // Communicate our context to the combinators.\n  // (Less wasteful than consing up a hundred closures on every call.)\n  cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;\n\n  if (!state.lexical.hasOwnProperty(\"align\"))\n    state.lexical.align = true;\n\n  while(true) {\n    var combinator = cc.length ? cc.pop() : statement;\n    if (combinator(type, content)) {\n      while(cc.length && cc[cc.length - 1].lex)\n        cc.pop()();\n      if (cx.marked) return cx.marked;\n      if (type == \"variable\" && inScope(state, content)) return \"variableName.local\";\n      if (type == \"variable\" && imported(state, content)) return \"variableName.special\";\n      return style;\n    }\n  }\n}\n\nfunction imported(state, typename) {\n  if (/[a-z]/.test(typename.charAt(0)))\n    return false;\n  var len = state.importedtypes.length;\n  for (var i = 0; i<len; i++)\n    if(state.importedtypes[i]==typename) return true;\n}\n\nfunction registerimport(importname) {\n  var state = cx.state;\n  for (var t = state.importedtypes; t; t = t.next)\n    if(t.name == importname) return;\n  state.importedtypes = { name: importname, next: state.importedtypes };\n}\n// Combinator utils\n\nvar cx = {state: null, column: null, marked: null, cc: null};\nfunction pass() {\n  for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);\n}\nfunction cont() {\n  pass.apply(null, arguments);\n  return true;\n}\nfunction inList(name, list) {\n  for (var v = list; v; v = v.next)\n    if (v.name == name) return true;\n  return false;\n}\nfunction register(varname) {\n  var state = cx.state;\n  if (state.context) {\n    cx.marked = \"def\";\n    if (inList(varname, state.localVars)) return;\n    state.localVars = {name: varname, next: state.localVars};\n  } else if (state.globalVars) {\n    if (inList(varname, state.globalVars)) return;\n    state.globalVars = {name: varname, next: state.globalVars};\n  }\n}\n\n// Combinators\n\nvar defaultVars = {name: \"this\", next: null};\nfunction pushcontext() {\n  if (!cx.state.context) cx.state.localVars = defaultVars;\n  cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};\n}\nfunction popcontext() {\n  cx.state.localVars = cx.state.context.vars;\n  cx.state.context = cx.state.context.prev;\n}\npopcontext.lex = true;\nfunction pushlex(type, info) {\n  var result = function() {\n    var state = cx.state;\n    state.lexical = new HaxeLexical(state.indented, cx.stream.column(), type, null, state.lexical, info);\n  };\n  result.lex = true;\n  return result;\n}\nfunction poplex() {\n  var state = cx.state;\n  if (state.lexical.prev) {\n    if (state.lexical.type == \")\")\n      state.indented = state.lexical.indented;\n    state.lexical = state.lexical.prev;\n  }\n}\npoplex.lex = true;\n\nfunction expect(wanted) {\n  function f(type) {\n    if (type == wanted) return cont();\n    else if (wanted == \";\") return pass();\n    else return cont(f);\n  }\n  return f;\n}\n\nfunction statement(type) {\n  if (type == \"@\") return cont(metadef);\n  if (type == \"var\") return cont(pushlex(\"vardef\"), vardef1, expect(\";\"), poplex);\n  if (type == \"keyword a\") return cont(pushlex(\"form\"), expression, statement, poplex);\n  if (type == \"keyword b\") return cont(pushlex(\"form\"), statement, poplex);\n  if (type == \"{\") return cont(pushlex(\"}\"), pushcontext, block, poplex, popcontext);\n  if (type == \";\") return cont();\n  if (type == \"attribute\") return cont(maybeattribute);\n  if (type == \"function\") return cont(functiondef);\n  if (type == \"for\") return cont(pushlex(\"form\"), expect(\"(\"), pushlex(\")\"), forspec1, expect(\")\"),\n                                 poplex, statement, poplex);\n  if (type == \"variable\") return cont(pushlex(\"stat\"), maybelabel);\n  if (type == \"switch\") return cont(pushlex(\"form\"), expression, pushlex(\"}\", \"switch\"), expect(\"{\"),\n                                    block, poplex, poplex);\n  if (type == \"case\") return cont(expression, expect(\":\"));\n  if (type == \"default\") return cont(expect(\":\"));\n  if (type == \"catch\") return cont(pushlex(\"form\"), pushcontext, expect(\"(\"), funarg, expect(\")\"),\n                                   statement, poplex, popcontext);\n  if (type == \"import\") return cont(importdef, expect(\";\"));\n  if (type == \"typedef\") return cont(typedef);\n  return pass(pushlex(\"stat\"), expression, expect(\";\"), poplex);\n}\nfunction expression(type) {\n  if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);\n  if (type == \"type\" ) return cont(maybeoperator);\n  if (type == \"function\") return cont(functiondef);\n  if (type == \"keyword c\") return cont(maybeexpression);\n  if (type == \"(\") return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex, maybeoperator);\n  if (type == \"operator\") return cont(expression);\n  if (type == \"[\") return cont(pushlex(\"]\"), commasep(maybeexpression, \"]\"), poplex, maybeoperator);\n  if (type == \"{\") return cont(pushlex(\"}\"), commasep(objprop, \"}\"), poplex, maybeoperator);\n  return cont();\n}\nfunction maybeexpression(type) {\n  if (type.match(/[;\\}\\)\\],]/)) return pass();\n  return pass(expression);\n}\n\nfunction maybeoperator(type, value) {\n  if (type == \"operator\" && /\\+\\+|--/.test(value)) return cont(maybeoperator);\n  if (type == \"operator\" || type == \":\") return cont(expression);\n  if (type == \";\") return;\n  if (type == \"(\") return cont(pushlex(\")\"), commasep(expression, \")\"), poplex, maybeoperator);\n  if (type == \".\") return cont(property, maybeoperator);\n  if (type == \"[\") return cont(pushlex(\"]\"), expression, expect(\"]\"), poplex, maybeoperator);\n}\n\nfunction maybeattribute(type) {\n  if (type == \"attribute\") return cont(maybeattribute);\n  if (type == \"function\") return cont(functiondef);\n  if (type == \"var\") return cont(vardef1);\n}\n\nfunction metadef(type) {\n  if(type == \":\") return cont(metadef);\n  if(type == \"variable\") return cont(metadef);\n  if(type == \"(\") return cont(pushlex(\")\"), commasep(metaargs, \")\"), poplex, statement);\n}\nfunction metaargs(type) {\n  if(type == \"variable\") return cont();\n}\n\nfunction importdef (type, value) {\n  if(type == \"variable\" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }\n  else if(type == \"variable\" || type == \"property\" || type == \".\" || value == \"*\") return cont(importdef);\n}\n\nfunction typedef (type, value)\n{\n  if(type == \"variable\" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }\n  else if (type == \"type\" && /[A-Z]/.test(value.charAt(0))) { return cont(); }\n}\n\nfunction maybelabel(type) {\n  if (type == \":\") return cont(poplex, statement);\n  return pass(maybeoperator, expect(\";\"), poplex);\n}\nfunction property(type) {\n  if (type == \"variable\") {cx.marked = \"property\"; return cont();}\n}\nfunction objprop(type) {\n  if (type == \"variable\") cx.marked = \"property\";\n  if (atomicTypes.hasOwnProperty(type)) return cont(expect(\":\"), expression);\n}\nfunction commasep(what, end) {\n  function proceed(type) {\n    if (type == \",\") return cont(what, proceed);\n    if (type == end) return cont();\n    return cont(expect(end));\n  }\n  return function(type) {\n    if (type == end) return cont();\n    else return pass(what, proceed);\n  };\n}\nfunction block(type) {\n  if (type == \"}\") return cont();\n  return pass(statement, block);\n}\nfunction vardef1(type, value) {\n  if (type == \"variable\"){register(value); return cont(typeuse, vardef2);}\n  return cont();\n}\nfunction vardef2(type, value) {\n  if (value == \"=\") return cont(expression, vardef2);\n  if (type == \",\") return cont(vardef1);\n}\nfunction forspec1(type, value) {\n  if (type == \"variable\") {\n    register(value);\n    return cont(forin, expression)\n  } else {\n    return pass()\n  }\n}\nfunction forin(_type, value) {\n  if (value == \"in\") return cont();\n}\nfunction functiondef(type, value) {\n  //function names starting with upper-case letters are recognised as types, so cludging them together here.\n  if (type == \"variable\" || type == \"type\") {register(value); return cont(functiondef);}\n  if (value == \"new\") return cont(functiondef);\n  if (type == \"(\") return cont(pushlex(\")\"), pushcontext, commasep(funarg, \")\"), poplex, typeuse, statement, popcontext);\n}\nfunction typeuse(type) {\n  if(type == \":\") return cont(typestring);\n}\nfunction typestring(type) {\n  if(type == \"type\") return cont();\n  if(type == \"variable\") return cont();\n  if(type == \"{\") return cont(pushlex(\"}\"), commasep(typeprop, \"}\"), poplex);\n}\nfunction typeprop(type) {\n  if(type == \"variable\") return cont(typeuse);\n}\nfunction funarg(type, value) {\n  if (type == \"variable\") {register(value); return cont(typeuse);}\n}\n\n// Interface\nexport const haxe = {\n  name: \"haxe\",\n  startState: function(indentUnit) {\n    var defaulttypes = [\"Int\", \"Float\", \"String\", \"Void\", \"Std\", \"Bool\", \"Dynamic\", \"Array\"];\n    var state = {\n      tokenize: haxeTokenBase,\n      reAllowed: true,\n      kwAllowed: true,\n      cc: [],\n      lexical: new HaxeLexical(-indentUnit, 0, \"block\", false),\n      importedtypes: defaulttypes,\n      context: null,\n      indented: 0\n    };\n    return state;\n  },\n\n  token: function(stream, state) {\n    if (stream.sol()) {\n      if (!state.lexical.hasOwnProperty(\"align\"))\n        state.lexical.align = false;\n      state.indented = stream.indentation();\n    }\n    if (stream.eatSpace()) return null;\n    var style = state.tokenize(stream, state);\n    if (type == \"comment\") return style;\n    state.reAllowed = !!(type == \"operator\" || type == \"keyword c\" || type.match(/^[\\[{}\\(,;:]$/));\n    state.kwAllowed = type != '.';\n    return parseHaxe(state, style, type, content, stream);\n  },\n\n  indent: function(state, textAfter, cx) {\n    if (state.tokenize != haxeTokenBase) return 0;\n    var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;\n    if (lexical.type == \"stat\" && firstChar == \"}\") lexical = lexical.prev;\n    var type = lexical.type, closing = firstChar == type;\n    if (type == \"vardef\") return lexical.indented + 4;\n    else if (type == \"form\" && firstChar == \"{\") return lexical.indented;\n    else if (type == \"stat\" || type == \"form\") return lexical.indented + cx.unit;\n    else if (lexical.info == \"switch\" && !closing)\n      return lexical.indented + (/^(?:case|default)\\b/.test(textAfter) ? cx.unit : 2 * cx.unit);\n    else if (lexical.align) return lexical.column + (closing ? 0 : 1);\n    else return lexical.indented + (closing ? 0 : cx.unit);\n  },\n\n  languageData: {\n    indentOnInput: /^\\s*[{}]$/,\n    commentTokens: {line: \"//\", block: {open: \"/*\", close: \"*/\"}}\n  }\n};\n\nexport const hxml = {\n  name: \"hxml\",\n  startState: function () {\n    return {\n      define: false,\n      inString: false\n    };\n  },\n  token: function (stream, state) {\n    var ch = stream.peek();\n    var sol = stream.sol();\n\n    ///* comments */\n    if (ch == \"#\") {\n      stream.skipToEnd();\n      return \"comment\";\n    }\n    if (sol && ch == \"-\") {\n      var style = \"variable-2\";\n\n      stream.eat(/-/);\n\n      if (stream.peek() == \"-\") {\n        stream.eat(/-/);\n        style = \"keyword a\";\n      }\n\n      if (stream.peek() == \"D\") {\n        stream.eat(/[D]/);\n        style = \"keyword c\";\n        state.define = true;\n      }\n\n      stream.eatWhile(/[A-Z]/i);\n      return style;\n    }\n\n    var ch = stream.peek();\n\n    if (state.inString == false && ch == \"'\") {\n      state.inString = true;\n      stream.next();\n    }\n\n    if (state.inString == true) {\n      if (stream.skipTo(\"'\")) {\n\n      } else {\n        stream.skipToEnd();\n      }\n\n      if (stream.peek() == \"'\") {\n        stream.next();\n        state.inString = false;\n      }\n\n      return \"string\";\n    }\n\n    stream.next();\n    return null;\n  },\n  languageData: {\n    commentTokens: {line: \"#\"}\n  }\n}\n"],"names":["type","cont","content","cx"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/hbs-CxcmWxSJ.js

@@ -0,0 +1,62 @@
+import { i as isRecord } from "./index-CVGAEPMV.js";
+import { r as renderApp } from "./render-app-island-B-i8rvGi.js";
+let elementId = 0;
+function filterOptions(options) {
+  if (!isRecord(options)) {
+    return { scope: {} };
+  }
+  return {
+    scope: (
+      /** @type {Record<string, unknown>}*/
+      options?.scope || {}
+    )
+  };
+}
+async function compiler(config, api) {
+  const hbsCompiler = {
+    compile: async (text, options) => {
+      const { template } = await api.tryResolve("@ember/template-compiler/runtime");
+      const component = template(text, {
+        scope: () => ({
+          ...filterOptions(config).scope,
+          ...filterOptions(options).scope
+        })
+      });
+      await new Promise(requestAnimationFrame);
+      return component;
+    },
+    render: async (element, compiled, extra, compiler2) => {
+      const attribute = `data-repl-sdk-ember-hbs-${elementId++}`;
+      element.setAttribute(attribute, "");
+      const [application, destroyable, resolver, router, route, testWaiters, runloop] = await compiler2.tryResolveAll([
+        "@ember/application",
+        "@ember/destroyable",
+        "ember-resolver",
+        "@ember/routing/router",
+        "@ember/routing/route",
+        "@ember/test-waiters",
+        "@ember/runloop"
+      ]);
+      return renderApp({
+        element,
+        selector: `[${attribute}]`,
+        component: compiled,
+        log: compiler2.announce,
+        modules: {
+          application,
+          destroyable,
+          resolver,
+          router,
+          route,
+          testWaiters,
+          runloop
+        }
+      });
+    }
+  };
+  return hbsCompiler;
+}
+export {
+  compiler
+};
+//# sourceMappingURL=hbs-CxcmWxSJ.js.map

package/dist/hbs-CxcmWxSJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hbs-CxcmWxSJ.js","sources":["../src/compilers/ember/hbs.js"],"sourcesContent":["import { isRecord } from '../../utils.js';\nimport { renderApp } from './render-app-island.js';\n\nlet elementId = 0;\n\n/**\n * @param {unknown} [ options ]\n * @returns {{ scope: Record<string, unknown> }}\n */\nfunction filterOptions(options) {\n  if (!isRecord(options)) {\n    return { scope: {} };\n  }\n\n  return {\n    scope: /** @type {Record<string, unknown>}*/ (options?.scope || {}),\n  };\n}\n\n/**\n * @type {import('../../types.ts').CompilerConfig['compiler']}\n */\nexport async function compiler(config, api) {\n  /**\n   * @type {import('../../types.ts').Compiler}\n   */\n  const hbsCompiler = {\n    compile: async (text, options) => {\n      const { template } = await api.tryResolve('@ember/template-compiler/runtime');\n\n      const component = template(text, {\n        scope: () => ({\n          ...filterOptions(config).scope,\n          ...filterOptions(options).scope,\n        }),\n      });\n\n      /**\n       * Some versions of ember implement the runtime template compiler incorrectly (albeit, correct enough for the constraints at the time).\n       * So we need to wait longer than a microtask queue request could take.\n       *\n       * To make sure that the template is compiled, and \"component\"\n       * has a value.\n       *\n       * See:\n       * - https://github.com/emberjs/ember.js/issues/20913\n       * - https://github.com/emberjs/ember.js/issues/20914\n       */\n      await new Promise(requestAnimationFrame);\n\n      /**\n       * Is this allowed here? or do I just return text,\n       * and do the above in 'render'\n       */\n      return component;\n    },\n    render: async (element, compiled, extra, compiler) => {\n      /**\n       *\n       * TODO: These will make things easier:\n       *    https://github.com/emberjs/rfcs/pull/1099\n       *    https://github.com/ember-cli/ember-addon-blueprint/blob/main/files/tests/test-helper.js\n       */\n      const attribute = `data-repl-sdk-ember-hbs-${elementId++}`;\n\n      element.setAttribute(attribute, '');\n\n      const [application, destroyable, resolver, router, route, testWaiters, runloop] =\n        await compiler.tryResolveAll([\n          '@ember/application',\n          '@ember/destroyable',\n          'ember-resolver',\n          '@ember/routing/router',\n          '@ember/routing/route',\n          '@ember/test-waiters',\n          '@ember/runloop',\n        ]);\n\n      return renderApp({\n        element,\n        selector: `[${attribute}]`,\n        component: compiled,\n        log: compiler.announce,\n        modules: {\n          application,\n          destroyable,\n          resolver,\n          router,\n          route,\n          testWaiters,\n          runloop,\n        },\n      });\n    },\n  };\n\n  return hbsCompiler;\n}\n"],"names":["compiler"],"mappings":";;AAGA,IAAI,YAAY;AAMhB,SAAS,cAAc,SAAS;AAC9B,MAAI,CAAC,SAAS,OAAO,GAAG;AACtB,WAAO,EAAE,OAAO,GAAE;AAAA,EACpB;AAEA,SAAO;AAAA,IACL;AAAA;AAAA,MAA8C,SAAS,SAAS;;EACpE;AACA;AAKO,eAAe,SAAS,QAAQ,KAAK;AAI1C,QAAM,cAAc;AAAA,IAClB,SAAS,OAAO,MAAM,YAAY;AAChC,YAAM,EAAE,SAAQ,IAAK,MAAM,IAAI,WAAW,kCAAkC;AAE5E,YAAM,YAAY,SAAS,MAAM;AAAA,QAC/B,OAAO,OAAO;AAAA,UACZ,GAAG,cAAc,MAAM,EAAE;AAAA,UACzB,GAAG,cAAc,OAAO,EAAE;AAAA,QACpC;AAAA,MACA,CAAO;AAaD,YAAM,IAAI,QAAQ,qBAAqB;AAMvC,aAAO;AAAA,IACT;AAAA,IACA,QAAQ,OAAO,SAAS,UAAU,OAAOA,cAAa;AAOpD,YAAM,YAAY,2BAA2B,WAAW;AAExD,cAAQ,aAAa,WAAW,EAAE;AAElC,YAAM,CAAC,aAAa,aAAa,UAAU,QAAQ,OAAO,aAAa,OAAO,IAC5E,MAAMA,UAAS,cAAc;AAAA,QAC3B;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACV,CAAS;AAEH,aAAO,UAAU;AAAA,QACf;AAAA,QACA,UAAU,IAAI,SAAS;AAAA,QACvB,WAAW;AAAA,QACX,KAAKA,UAAS;AAAA,QACd,SAAS;AAAA,UACP;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACV;AAAA,MACA,CAAO;AAAA,IACH;AAAA,EACJ;AAEE,SAAO;AACT;"}