pure-dango 1.8.3 → 1.8.5

package/dist/lib/main.js

@@ -0,0 +1,481 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var main_exports = {};
+__export(main_exports, {
+  OPERATORS: () => OPERATORS,
+  next: () => next,
+  parseExpression: () => parseExpression,
+  parseStatement: () => parseStatement,
+  parser: () => parser,
+  peek: () => peek
+});
+module.exports = __toCommonJS(main_exports);
+var import_errors = require("../../runtime/errors");
+var import_stdlib = require("../../runtime/stdlib");
+var handlers = __toESM(require("./handlers"), 1);
+var helpers = __toESM(require("./helpers"), 1);
+const OPERATORS = {
+  // operators
+  "+": { prec: 10, assoc: "left", type: "binary" },
+  "-": { prec: 10, assoc: "left", type: "binary" },
+  "*": { prec: 20, assoc: "left", type: "binary" },
+  "/": { prec: 20, assoc: "left", type: "binary" },
+  "%": { prec: 20, assoc: "left", type: "binary" },
+  // assignment operators
+  "=": { prec: 5, assoc: "right", type: "assignment" },
+  "-=": { prec: 5, assoc: "right", type: "assignment" },
+  "+=": { prec: 5, assoc: "right", type: "assignment" },
+  "*=": { prec: 5, assoc: "right", type: "assignment" },
+  "/=": { prec: 5, assoc: "right", type: "assignment" },
+  // equality operators
+  "==": { prec: 7, assoc: "left", type: "binary" },
+  "!=": { prec: 7, assoc: "left", type: "binary" },
+  ">": { prec: 8, assoc: "left", type: "binary" },
+  "<": { prec: 8, assoc: "left", type: "binary" },
+  ">=": { prec: 8, assoc: "left", type: "binary" },
+  "<=": { prec: 8, assoc: "left", type: "binary" },
+  // logical operators
+  "&&": { prec: 3, assoc: "left", type: "logical" },
+  "||": { prec: 2, assoc: "left", type: "logical" },
+  "??": { prec: 1, assoc: "left", type: "logical" },
+  // unary operators
+  "!": { prec: 30, assoc: "right", type: "unary", fix: "prefix" },
+  "~": { prec: 30, assoc: "right", type: "unary", fix: "prefix" },
+  "+u": { prec: 30, assoc: "right", type: "unary", fix: "prefix" },
+  "-u": { prec: 30, assoc: "right", type: "unary", fix: "prefix" },
+  "++": { prec: 30, assoc: "right", type: "unary", fix: "both" },
+  "--": { prec: 30, assoc: "right", type: "unary", fix: "both" },
+  // bitwise operators
+  "&": { prec: 9, assoc: "left", type: "binary" },
+  "^": { prec: 8, assoc: "left", type: "binary" },
+  "|": { prec: 7, assoc: "left", type: "binary" },
+  "<<": { prec: 12, assoc: "left", type: "binary" },
+  ">>": { prec: 12, assoc: "left", type: "binary" },
+  ">>>": { prec: 12, assoc: "left", type: "binary" },
+  "&=": { prec: 5, assoc: "right", type: "assignment" },
+  "|=": { prec: 5, assoc: "right", type: "assignment" },
+  "^=": { prec: 5, assoc: "right", type: "assignment" },
+  "<<=": { prec: 5, assoc: "right", type: "assignment" },
+  ">>=": { prec: 5, assoc: "right", type: "assignment" },
+  ">>>=": { prec: 5, assoc: "right", type: "assignment" }
+};
+function peek(tokens, state) {
+  return tokens[state.position];
+}
+function next(tokens, state) {
+  if (state.position >= tokens.length)
+    return null;
+  const token = tokens[state.position++];
+  state.lastToken = token;
+  return token;
+}
+function isUnaryPrefix(operator) {
+  return OPERATORS[operator]?.type === "unary" && OPERATORS[operator].fix !== "postfix";
+}
+function parseStartingToken(token, tokens, state) {
+  if (!token)
+    (0, import_stdlib.errorTemplate)("parseStartingToken", `Unexpected end of input`);
+  let {
+    type,
+    value,
+    row,
+    column
+  } = token;
+  if (type === "Keyword" && value === "function")
+    return handlers.parseFunctionNode(tokens, state, true);
+  if (type === "Keyword" && value === "inst")
+    return handlers.parseInstantationExpression(token, tokens, state);
+  if (type === "Operator" && (value === "+" || value === "-")) {
+    const previousToken = state.lastToken;
+    const isUnaryContext = !previousToken || previousToken.type === "Keyword" || previousToken.value === "(" || previousToken.value === "," || previousToken.type === "Operator" && previousToken.value !== ")" && previousToken.value !== "++" && previousToken.value !== "--";
+    if (isUnaryContext)
+      value += "u";
+  }
+  if (type === "Literal" || type === "StringLiteral") {
+    return {
+      type,
+      value,
+      row,
+      column
+    };
+  }
+  if (isUnaryPrefix(value)) {
+    const valueObject = OPERATORS[value];
+    const operand = parseExpression(tokens, valueObject.prec, state);
+    if (valueObject.fix === "both") {
+      return {
+        type: "UnaryExpression",
+        value: value.toString(),
+        argument: operand,
+        row,
+        column
+      };
+    }
+    if (valueObject.fix === "prefix") {
+      return {
+        type: "UnaryExpression",
+        value,
+        argument: operand,
+        row,
+        column
+      };
+    }
+    throw new import_errors.parseErrors.UnaryOperatorError(value, row, column);
+  }
+  if (type === "Identifier") {
+    const peekToken = peek(tokens, state);
+    if (peekToken && peekToken.value === "(")
+      return parseFunctionCall(value, tokens, state);
+    return {
+      type: "VariableReference",
+      value,
+      row,
+      column
+    };
+  }
+  if (value === "(") {
+    const expression = parseExpression(tokens, 0, state);
+    const peekToken = peek(tokens, state);
+    if (!peekToken || peekToken.value !== ")")
+      throw new import_errors.parseErrors.MissingTokenError(")", expression.row, expression.column);
+    next(tokens, state);
+    return expression;
+  }
+  if (value === "[") {
+    const elements = [];
+    while (peek(tokens, state) && peek(tokens, state).value !== "]") {
+      const element = parseExpression(tokens, 0, state, true);
+      if (element)
+        elements.push(element);
+      const peekToken = peek(tokens, state);
+      if (peekToken && peekToken.value === ",")
+        next(tokens, state);
+      else if (peekToken && peekToken.value !== "]")
+        throw new import_errors.parseErrors.UnexpectedTokenError(peekToken.value, peekToken.row, peekToken.column);
+    }
+    if (!peek(tokens, state) || peek(tokens, state).value !== "]")
+      throw new import_errors.parseErrors.MissingTokenError("]", token.row, token.column);
+    next(tokens, state);
+    return {
+      type: "ArrayLiteral",
+      elements,
+      row,
+      column
+    };
+  }
+  if (value === "{") {
+    const properties = [];
+    while (peek(tokens, state) && peek(tokens, state).value !== "}") {
+      const keyToken = next(tokens, state);
+      const isInvalid = !keyToken || !(keyToken.type === "Identifier" || keyToken.type === "StringLiteral" || keyToken.type === "Literal");
+      if (isInvalid)
+        throw new import_errors.parseErrors.UnexpectedTokenError(keyToken?.value, keyToken?.row ?? row, keyToken?.column ?? column);
+      if (!peek(tokens, state) || peek(tokens, state).value !== ":")
+        throw new import_errors.parseErrors.MissingTokenError(":", keyToken.row, keyToken.column);
+      next(tokens, state);
+      const value2 = parseExpression(tokens, 0, state, true);
+      properties.unshift({ key: keyToken.value, value: value2 });
+      const peekToken = peek(tokens, state);
+      if (peekToken && peekToken.value === ",")
+        next(tokens, state);
+      else if (peekToken && peekToken.value !== "}")
+        throw new import_errors.parseErrors.UnexpectedTokenError(peekToken.value, peekToken.row, peekToken.column);
+    }
+    if (!peek(tokens, state) || peek(tokens, state).value !== "}")
+      throw new import_errors.parseErrors.MissingTokenError("}", token.row, token.column);
+    next(tokens, state);
+    const node = {
+      type: "ObjectLiteral",
+      properties,
+      row,
+      column
+    };
+    return node;
+  }
+  if (value === ";")
+    return null;
+  throw new import_errors.parseErrors.UnexpectedTokenError(value, row, column);
+}
+function parseExpression(tokens, minimumPrecedence = 0, state, stopAtComma = false) {
+  let operatorStack = [];
+  let outputStack = [];
+  let token = next(tokens, state);
+  if (!token)
+    return null;
+  let node = parseStartingToken(token, tokens, state);
+  node = helpers.attach(node, tokens, state, stopAtComma);
+  outputStack.push(node);
+  while (true) {
+    let token2 = peek(tokens, state);
+    if (helpers.stoppingCheck(token2, stopAtComma))
+      break;
+    const operatorInfo = OPERATORS[token2.value];
+    if (!operatorInfo || operatorInfo.prec < minimumPrecedence)
+      break;
+    const operator = next(tokens, state);
+    while (outputStack.length > 0) {
+      const topOperator = operatorStack[operatorStack.length - 1];
+      const topInfo = OPERATORS[topOperator?.value] ?? null;
+      if (!topInfo)
+        break;
+      if (topInfo.type !== "assignment" && (operatorInfo.assoc === "left" && operatorInfo.prec <= topInfo.prec || operatorInfo.assoc === "right" && operatorInfo.prec < topInfo.prec)) {
+        if (topInfo.type === "unary") {
+          const operand = outputStack.pop();
+          outputStack.push(
+            {
+              type: "UnaryExpression",
+              value: topOperator.value,
+              argument: operand,
+              row: topOperator.row,
+              column: topOperator.column
+            }
+          );
+        } else {
+          const rightNode = outputStack.pop();
+          const leftNode = outputStack.pop();
+          outputStack.push(
+            {
+              type: topInfo.type === "logical" ? "LogicalExpression" : "BinaryExpression",
+              operator: topOperator.value,
+              left: leftNode,
+              right: rightNode,
+              row: topOperator.row,
+              column: topOperator.column
+            }
+          );
+        }
+        operatorStack.pop();
+      } else
+        break;
+    }
+    if (operatorInfo.type === "assignment") {
+      const leftNode = outputStack.pop();
+      if (leftNode.type !== "VariableReference" && leftNode.type !== "ArrayAccess" && leftNode.type !== "MemberExpression")
+        throw new import_errors.parseErrors.AssignmentError(operator.value, operator.row, operator.column);
+      const rightNode = parseExpression(tokens, operatorInfo.prec, state, stopAtComma);
+      const baseOperators = {
+        "+=": "+",
+        "-=": "-",
+        "*=": "*",
+        "/=": "/",
+        "%=": "%",
+        "&=": "&",
+        "|=": "|",
+        "^=": "^",
+        "<<=": "<<",
+        ">>=": ">>",
+        ">>>=": ">>>"
+      };
+      const name = leftNode.type === "ArrayAccess" || leftNode.type === "MemberExpression" ? leftNode : leftNode.value;
+      const valueType = OPERATORS[baseOperators[operator.value]]?.type === "logical" ? "LogicalExpression" : "BinaryExpression";
+      outputStack.push(
+        {
+          type: "Assignment",
+          name,
+          value: operator.value === "=" ? rightNode : {
+            type: valueType,
+            operator: baseOperators[operator.value],
+            left: leftNode,
+            right: rightNode
+          },
+          row: operator.row,
+          column: operator.column
+        }
+      );
+      break;
+    }
+    operatorStack.push(operator);
+    let nextToken = next(tokens, state);
+    if (!nextToken)
+      throw new import_errors.parseErrors.UnexpectedTokenError("end of input", operator.row, operator.column);
+    let node2 = parseStartingToken(nextToken, tokens, state);
+    if (!node2)
+      throw new import_errors.parseErrors.UnexpectedTokenError(nextToken.value, nextToken.row, nextToken.column);
+    node2 = helpers.attach(node2, tokens, state, stopAtComma);
+    outputStack.push(node2);
+  }
+  while (operatorStack.length) {
+    const operator = operatorStack.pop();
+    const operatorInfo = OPERATORS[operator.value];
+    if (operatorInfo.type === "unary") {
+      const operand = outputStack.pop();
+      outputStack.push(
+        {
+          type: "UnaryExpression",
+          value: operator.value,
+          argument: operand,
+          row: operator.row,
+          column: operator.column
+        }
+      );
+    } else {
+      const rightNode = outputStack.pop();
+      const leftNode = outputStack.pop();
+      outputStack.push(
+        {
+          type: operatorInfo.type === "logical" ? "LogicalExpression" : "BinaryExpression",
+          operator: operator.value,
+          left: leftNode,
+          right: rightNode,
+          row: operator.row,
+          column: operator.column
+        }
+      );
+    }
+  }
+  const maybeTernary = peek(tokens, state);
+  if (maybeTernary && maybeTernary.value === "?") {
+    next(tokens, state);
+    const thenBranch = parseExpression(tokens, 0, state, stopAtComma);
+    const elseColon = peek(tokens, state);
+    if (!elseColon || elseColon.value !== ":")
+      throw new import_errors.parseErrors.MissingTokenError(":", elseColon?.row ?? 0, elseColon?.column ?? 0);
+    next(tokens, state);
+    const elseBranch = parseExpression(tokens, 0, state, stopAtComma);
+    return {
+      type: "TernaryExpression",
+      condition: outputStack[0],
+      then: thenBranch,
+      else: elseBranch,
+      row: maybeTernary.row,
+      column: maybeTernary.column
+    };
+  }
+  return outputStack[0];
+}
+function parseFunctionCall(name, tokens, state) {
+  const row = state.lastToken?.row ?? 0;
+  const column = state.lastToken?.column ?? 0;
+  next(tokens, state);
+  let args = [];
+  const peekToken = peek(tokens, state);
+  if (peekToken && peekToken.value === ")") {
+    next(tokens, state);
+    return {
+      type: "FunctionCall",
+      name,
+      args,
+      row,
+      column
+    };
+  }
+  while (peek(tokens, state) && peek(tokens, state).value !== ")") {
+    if (peek(tokens, state)?.value === "...") {
+      next(tokens, state);
+      const expression = parseExpression(tokens, 0, state, true);
+      args.push(
+        {
+          type: "SpreadElement",
+          argument: expression,
+          row,
+          column
+        }
+      );
+    } else {
+      const expression = parseExpression(tokens, 0, state, true);
+      if (!expression) {
+        console.warn(`
+ Expected expression in function call "${name}"`);
+        break;
+      }
+      args.push(expression);
+    }
+    const peekToken2 = peek(tokens, state);
+    if (peekToken2 && peekToken2.value === ",")
+      next(tokens, state);
+    else if (peekToken2 && peekToken2.value !== ")")
+      throw new import_errors.parseErrors.UnexpectedTokenError(peekToken2.value, peekToken2.row, peekToken2.column);
+  }
+  if (!peek(tokens, state) || peek(tokens, state).value !== ")") {
+    const lastToken = tokens[state.position - 1];
+    const row2 = lastToken?.row ?? 0;
+    const column2 = lastToken?.column ?? 0;
+    throw new import_errors.parseErrors.FunctionCallError(`Missing ")" in function call for name "${name}"`, row2, column2);
+  }
+  next(tokens, state);
+  if (peek(tokens, state) && peek(tokens, state).value === "(")
+    throw new import_errors.parseErrors.ChainedFunctionCallError(name, peek(tokens, state).row, peek(tokens, state).column);
+  return {
+    type: "FunctionCall",
+    name,
+    args,
+    row,
+    column
+  };
+}
+function parseStatement(ast, tokens, state) {
+  const token = peek(tokens, state);
+  if (!token)
+    return null;
+  if (token.type === "Keyword") {
+    if (handlers.variableHandler(ast, token, tokens, state)) return true;
+    else if (handlers.ifHandler(ast, token, tokens, state)) return true;
+    else if (handlers.doWhileHandler(ast, token, tokens, state)) return true;
+    else if (handlers.whileHandler(ast, token, tokens, state)) return true;
+    else if (handlers.loopControlHandler(ast, token, tokens, state)) return true;
+    else if (handlers.forHandler(ast, token, tokens, state)) return true;
+    else if (handlers.functionHandler(ast, token, tokens, state)) return true;
+    else if (handlers.returnHandler(ast, token, tokens, state)) return true;
+    else if (handlers.importHandler(ast, token, tokens, state)) return true;
+    else if (handlers.classHandler(ast, token, tokens, state)) return true;
+    else if (handlers.tryHandler(ast, token, tokens, state)) return true;
+    else if (handlers.switchHandler(ast, token, tokens, state)) return true;
+  }
+  const expression = parseExpression(tokens, 0, state);
+  if (expression)
+    ast.body.push(expression);
+  return expression;
+}
+function parser(tokens) {
+  let state = {
+    position: 0,
+    time: 0,
+    lastToken: null
+  };
+  let ast = {
+    type: "Program",
+    body: []
+  };
+  while (state.position < tokens.length) {
+    const token = peek(tokens, state);
+    if (!token)
+      break;
+    parseStatement(ast, tokens, state);
+  }
+  return ast;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OPERATORS,
+  next,
+  parseExpression,
+  parseStatement,
+  parser,
+  peek
+});