pure-dango 1.8.3 → 1.8.4

package/dist/lib/parser/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
+});

package/dist/lib/tokenizer/tokenizer.js

@@ -0,0 +1,298 @@
+"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 tokenizer_exports = {};
+__export(tokenizer_exports, {
+  tokenizer: () => tokenizer
+});
+module.exports = __toCommonJS(tokenizer_exports);
+var import_errors = require("../../runtime/errors");
+var quote_crimes = __toESM(require("./funnies"), 1);
+const REGEX = new RegExp([
+  // strings
+  "(`(?:[^`\\\\]|\\\\.)*`)",
+  // backtick strings
+  "('(?:[^'\\\\]|\\\\.)*')",
+  // single quote strings
+  "(\u201C(?:[^\u201C\u201D\\\\]|\\\\.)*\u201D)",
+  // curly single quote strings
+  "(\u2018(?:[^\u2018\u2019\\\\]|\\\\.)*\u2019)",
+  // curly double quote strings
+  // multi-char operators
+  "\\?\\?",
+  "&&",
+  "\\|\\|",
+  "!=",
+  "<=",
+  ">=",
+  "==",
+  "--",
+  "\\+\\+",
+  "-=",
+  "\\+=",
+  "/=",
+  "\\*=",
+  "&=",
+  "\\|=",
+  "\\^=",
+  // bitwise assignment
+  "<<=",
+  ">>=",
+  ">>>=",
+  // shift assignment
+  ">>>",
+  ">>",
+  "<<",
+  // shifts (longest first)
+  "\\.\\..",
+  // spread
+  // number literals
+  "0b[01]+",
+  // binary
+  "0x[0-9a-fA-F]+",
+  // hex
+  "\\d+(\\.\\d+)?",
+  // float
+  // identifiers
+  "[\\p{L}_][\\p{L}\\d_]*",
+  // single char
+  "[+\\-*/=()&^%$#@!<>?:~,|]",
+  "[\\[\\]{}]",
+  "[\\n;]",
+  "\\."
+].join("|"), "gu");
+const keywordSet = /* @__PURE__ */ new Set(["new", "const", "if", "else", "while", "continue", "break", "for", "in", "of", "function", "return", "import", "class", "extends", "inst", "internal", "try", "catch", "finally", "do", "switch", "case", "default"]);
+const separatorSet = /* @__PURE__ */ new Set(["\n", ",", "	", ";"]);
+const operatorSet = /* @__PURE__ */ new Set([
+  "...",
+  "??",
+  "&&",
+  "||",
+  "{",
+  "}",
+  "[",
+  "]",
+  "!=",
+  "<=",
+  ">=",
+  "==",
+  "-=",
+  "+=",
+  "++",
+  "/=",
+  "*=",
+  "--",
+  "&=",
+  "|=",
+  "^=",
+  "<<=",
+  ">>=",
+  ">>>=",
+  ">>>",
+  ">>",
+  "<<",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "=",
+  "(",
+  ")",
+  "&",
+  "^",
+  "!",
+  "<",
+  ">",
+  "?",
+  ":",
+  "~",
+  ".",
+  "|"
+]);
+function getType(code) {
+  if (keywordSet.has(code))
+    return "Keyword";
+  if (separatorSet.has(code))
+    return "Separator";
+  if (operatorSet.has(code))
+    return "Operator";
+  if (/^["'`]/.test(code))
+    return "StringLiteral";
+  if (/^\d/.test(code))
+    return "Literal";
+  return "Identifier";
+}
+function tokenizer(code) {
+  const tokens = [];
+  const uid = Math.random().toString(36).slice(2);
+  const stringMeta = /* @__PURE__ */ new Map();
+  const out = [];
+  let row = 1;
+  let column = 1;
+  let i = 0;
+  let stringIndex = 0;
+  while (i < code.length) {
+    const character = code[i];
+    if (character === "#") {
+      while (i < code.length && code[i] !== "\n")
+        i++;
+      continue;
+    }
+    if (character === "/" && code[i + 1] === "*") {
+      while (i < code.length && !(code[i] === "*" && code[i + 1] === "/")) {
+        if (code[i] === "\n") {
+          row++;
+          column = 1;
+        }
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    if ((character === '"' || character === "\u201C" || character === "'" || character === "\u2018" || character === "`") && (i === 0 || !/[\p{L}\d]/u.test(code[i - 1]))) {
+      const quote = character === "\u201C" ? "\u201D" : character === "\u2018" ? "\u2019" : character;
+      const stringRow = row;
+      const stringColumn = column;
+      const start = i;
+      i++;
+      column++;
+      while (i < code.length && code[i] !== quote) {
+        const type = quote === "\u201D" ? "double" : "single";
+        const opening = type === "double" ? "\u201C" : "\u2018";
+        if (code[i] === "\u201C" && quote === "\u201D" || code[i] === "\u2018" && quote === "\u2019") {
+          const quoteCrimesMessage = quote_crimes.QuoteCrimesMessage(quote_crimes.incrementQuoteCrimes() - 1, opening) + " ";
+          throw new import_errors.Tokenizer(
+            quoteCrimesMessage + `Found: ${opening}...${opening}. Tip: Either match them or just use normal ${type} quotes`,
+            row,
+            column
+          );
+        }
+        if (code[i] === "\\") {
+          i += 2;
+          column += 2;
+        } else {
+          if (code[i] === "\n") {
+            row++;
+            column = 1;
+          } else
+            column++;
+          i++;
+        }
+      }
+      i++;
+      column++;
+      const raw = code.slice(start, i);
+      const placeholder = `__STRING${uid}_${stringIndex++}__`;
+      stringMeta.set(
+        placeholder,
+        {
+          value: raw.slice(1, -1).replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r"),
+          row: stringRow,
+          column: stringColumn
+        }
+      );
+      out.push(placeholder);
+      continue;
+    }
+    if (character === "\n") {
+      row++;
+      column = 1;
+    } else
+      column++;
+    out.push(character);
+    i++;
+  }
+  const processed = out.join("");
+  row = 1;
+  column = 1;
+  let commented = false;
+  const matches = processed.matchAll(REGEX);
+  for (const match of matches) {
+    const value = match[0];
+    if (value === "\n") {
+      row++;
+      column = 1;
+      commented = false;
+      continue;
+    }
+    if (value === "#") {
+      commented = true;
+      continue;
+    }
+    if (commented || value === "	") {
+      column += value.length;
+      continue;
+    }
+    if (value === ",") {
+      tokens.push(
+        {
+          type: "Separator",
+          value,
+          row,
+          column
+        }
+      );
+      column += value.length;
+      continue;
+    }
+    if (stringMeta.has(value)) {
+      const meta = stringMeta.get(value);
+      tokens.push(
+        {
+          type: "StringLiteral",
+          value: meta.value,
+          row: meta.row,
+          column: meta.column
+        }
+      );
+      column += value.length;
+      continue;
+    }
+    const lines = value.split("\n");
+    if (lines.length > 1) {
+      row += lines.length - 1;
+      column = lines[lines.length - 1].length + 1;
+    }
+    tokens.push(
+      {
+        type: getType(value),
+        value,
+        row,
+        column
+      }
+    );
+    if (lines.length === 1)
+      column += value.length;
+  }
+  return tokens;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tokenizer
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pure-dango",
-    "version": "1.8.3",
+    "version": "1.8.4",
     "type": "module",
     "description": "A simple programming language built in JavaScript",
     "license": "MIT",

package/src/index.ts

@@ -38,7 +38,7 @@ const
 const packageJson =
 {
     name:        typeof PACKAGE_NAME        !== "undefined" ? PACKAGE_NAME        : "pure-dango",
-    version:     typeof PACKAGE_VERSION     !== "undefined" ? PACKAGE_VERSION     : "1.8.2",
+    version:     typeof PACKAGE_VERSION     !== "undefined" ? PACKAGE_VERSION     : "1.8.3",
     description: typeof PACKAGE_DESCRIPTION !== "undefined" ? PACKAGE_DESCRIPTION : "A simple programming language built in JavaScript"
 };