pure-dango 1.8.2 → 1.8.3

package/dist/PureDango.cjs

@@ -4200,7 +4200,7 @@ var typeMap = /* @__PURE__ */ new Map([
           (parameter) => ({
             name: parameter.name,
             rest: parameter.rest,
-            default: parameter.defauslt ? parseObject(parameter.default, [], true) : null,
+            default: parameter.default ? parseObject(parameter.default, [], true) : null,
             typeAnnotation: parameter.typeAnnotation ?? null
           })
         );
@@ -9308,7 +9308,7 @@ var {
 } = utils_exports;
 var packageJson = {
   name: true ? "pure-dango" : "pure-dango",
-  version: true ? "1.8.0" : "1.8.0",
+  version: true ? "1.8.2" : "1.8.2",
   description: true ? "A simple programming language built in JavaScript" : "A simple programming language built in JavaScript"
 };
 function pause(code = 0) {
@@ -9409,7 +9409,6 @@ process.on(
     console.log(`
 Pure dango program exited after: ${state.time.toFixed(3)} milliseconds...`);
   } catch (error) {
-    console.error(error);
     console.error(`
 ${error.message}`);
     console.log(`Pure dango program exited after: ${state.time.toFixed(3)} milliseconds...`);

package/package.json

@@ -1,12 +1,14 @@
 {
     "name": "pure-dango",
-    "version": "1.8.2",
+    "version": "1.8.3",
     "type": "module",
     "description": "A simple programming language built in JavaScript",
     "license": "MIT",
     "files": [
         "src/core",
         "src/runtime",
+        "src/types.d.ts",
+        "src/globals.d.ts",
         "dist"
     ],
     "bin": {

package/src/globals.d.ts

@@ -0,0 +1,15 @@
+declare namespace NodeJS
+{
+    interface Process
+    {
+        pkg?:
+        {
+            entrypoint: string;
+            defaultEntryPoint: string;
+        };
+    }
+}
+
+declare const PACKAGE_NAME:          string | undefined;
+declare const PACKAGE_VERSION:       string | undefined;
+declare const PACKAGE_DESCRIPTION:   string | undefined;

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.1",
+    version:     typeof PACKAGE_VERSION     !== "undefined" ? PACKAGE_VERSION     : "1.8.2",
     description: typeof PACKAGE_DESCRIPTION !== "undefined" ? PACKAGE_DESCRIPTION : "A simple programming language built in JavaScript"
 };
 

package/src/types.d.ts

@@ -0,0 +1,102 @@
+type BaseToken =
+{
+    type   : string
+    value  : string
+    row    : number
+    column : number
+}
+
+type ParserToken =
+{
+    type : string,
+    
+    argument? : ParserToken | null | undefined,
+    name?     : any,
+    value?    : any,
+    object?   : any,
+    property? : any,
+
+    constant?       : boolean,
+    typeAnnotation? : boolean,
+
+    operator? : string,
+    left?     : any,
+    right?    : any,
+
+    condition? : ParserToken,
+
+    args? : 
+    (
+        ParserToken | 
+        {
+            type: string;
+            argument: ParserToken;
+            row: number;
+            column: number;
+        }
+    )[],
+
+    index? : ParserToken,
+
+    initial? : ParserToken | null,
+    update?  : ParserToken,
+
+    parameters? : {name: string, default: ParserToken | null, rest: boolean}[],
+    methods?    : ParserToken[], 
+
+    body?       : ParserToken | ParserToken[],
+    returnType? : string | null,
+    then?       : ParserToken,
+    else?       : ParserToken | ParserToken[] | null,
+
+    tryBlock?: ParserToken[],
+    catchBlock?: ParserToken[],
+    finallyBlock?: ParserToken[] | null,
+
+    names?: string[],
+
+    discriminant?: ParserToken | null,
+    cases?: any[],
+    defaultCase?: any,
+
+    isDeclaration?: boolean,
+
+    errorVariable?: string,
+
+    elements? : ParserToken[],
+
+    className?    : string,
+    variableName? : string,
+
+    path? : string,
+
+    superclass? : string | null,
+
+    row    : number,
+    column : number
+}
+
+type AST = 
+{
+    type : "Program",
+    body : ParserToken[]
+}
+
+type Operator =
+{
+    prec  : number, 
+    assoc : string, 
+    type  : string, 
+    fix?  : string
+}
+
+type Operators =  Record<string, Operator>;
+
+type Tokens = BaseToken[];
+
+type State = 
+{
+    time      : number, 
+    position  : number,
+    lastToken : BaseToken | null
+}

package/dist/lib/parser/main.js

@@ -1,481 +0,0 @@
-"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

@@ -1,298 +0,0 @@
-"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
-});