@markw65/monkeyc-optimizer 1.1.26 → 1.1.28

package/build/chunk-MBTLUWXR.cjs

@@ -0,0 +1,375 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_MBTLUWXR_exports = {};
+__export(chunk_MBTLUWXR_exports, {
+  adjustLoc: () => adjustLoc,
+  cloneDeep: () => cloneDeep,
+  getLiteralNode: () => getLiteralNode,
+  getNodeValue: () => getNodeValue,
+  hasProperty: () => hasProperty,
+  init_ast: () => init_ast,
+  isExpression: () => isExpression,
+  isStatement: () => isStatement,
+  locRange: () => locRange,
+  makeIdentifier: () => makeIdentifier,
+  makeMemberExpression: () => makeMemberExpression,
+  makeScopedName: () => makeScopedName,
+  mayThrow: () => mayThrow,
+  traverseAst: () => traverseAst,
+  withLoc: () => withLoc,
+  withLocDeep: () => withLocDeep,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(chunk_MBTLUWXR_exports);
+var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
+var import_prettier_plugin_monkeyc = require("@markw65/prettier-plugin-monkeyc");
+function isMCTreeNode(node) {
+  return node ? typeof node === "object" && "type" in node : false;
+}
+function traverseAst(node, pre, post, parent) {
+  const nodes = pre && pre(node);
+  if (nodes === false)
+    return;
+  if (!mctreeTypeInfo[node.type]) {
+    throw new Error("what?");
+  }
+  for (const key of nodes || mctreeTypeInfo[node.type].keys) {
+    const value = node[key];
+    if (!value)
+      continue;
+    if (Array.isArray(value)) {
+      const values = value;
+      const deletions = values.reduce(
+        (state, obj, i) => {
+          if (isMCTreeNode(obj)) {
+            const repl = traverseAst(obj, pre, post, node);
+            if (repl === false) {
+              if (!state)
+                state = {};
+              state[i] = true;
+            } else if (repl != null) {
+              if (!state)
+                state = {};
+              values[i] = repl;
+            }
+          }
+          return state;
+        },
+        null
+      );
+      if (deletions) {
+        values.splice(
+          0,
+          values.length,
+          ...values.filter((obj, i) => deletions[i] !== true).flat(1)
+        );
+      }
+    } else if (isMCTreeNode(value)) {
+      let repl = traverseAst(value, pre, post, node);
+      if (repl === false) {
+        delete node[key];
+      } else if (repl != null) {
+        if (Array.isArray(repl)) {
+          if (isStatement(value) && repl.every((s) => isStatement(s))) {
+            repl = withLoc(
+              {
+                type: "BlockStatement",
+                body: repl
+              },
+              repl[0],
+              repl[repl.length - 1]
+            );
+          } else {
+            throw new Error("Array returned by traverseAst in Node context");
+          }
+        }
+        node[key] = repl;
+      }
+    }
+  }
+  return post && post(node, parent);
+}
+function isStatement(node) {
+  return hasProperty(mctreeTypeInfo[node.type], "stmt");
+}
+function isExpression(node) {
+  return hasProperty(mctreeTypeInfo[node.type], "expr");
+}
+function mayThrow(node) {
+  switch (node.type) {
+    case "BinaryExpression":
+    case "CallExpression":
+    case "NewExpression":
+    case "ThrowStatement":
+    case "UnaryExpression":
+    case "UpdateExpression":
+      return true;
+    default:
+      return false;
+  }
+}
+function hasProperty(obj, prop) {
+  return obj ? Object.prototype.hasOwnProperty.call(obj, prop) : false;
+}
+function withLoc(node, start, end) {
+  if (start && start.loc) {
+    node.start = start.start;
+    if (!node.end)
+      node.end = start.end;
+    node.loc = { ...node.loc || start.loc, start: start.loc.start };
+    if (end === start && start.origins) {
+      node.origins = start.origins;
+    }
+  }
+  if (end === false) {
+    if (node.loc) {
+      node.loc.end = node.loc.start;
+      node.end = node.start;
+    }
+  } else if (end && end.loc) {
+    node.end = end.end;
+    node.loc = { ...node.loc || end.loc, end: end.loc.end };
+  }
+  return node;
+}
+function withLocDeep(node, start, end, inplace) {
+  node = withLoc(inplace ? node : { ...node }, start, end);
+  if (!inplace && node.origins) {
+    node.origins = [...node.origins];
+  }
+  for (const key of mctreeTypeInfo[node.type].keys) {
+    const value = node[key];
+    if (!value)
+      continue;
+    const fix = (v) => isMCTreeNode(v) ? withLocDeep(v, start, end, inplace) : v;
+    const repl = Array.isArray(value) ? value.map(fix) : fix(value);
+    inplace || (node[key] = repl);
+  }
+  return node;
+}
+function cloneDeep(node) {
+  return withLocDeep(node, null);
+}
+function getNodeValue(node) {
+  if (node.type === "BinaryExpression" && node.operator === "as" && node.right.type === "TypeSpecList" && node.right.ts.length === 1 && typeof node.right.ts[0] === "string") {
+    return getNodeValue(node.left);
+  }
+  if (node.type !== "Literal") {
+    return [null, null];
+  }
+  if (node.value === null) {
+    return [node, "Null"];
+  }
+  const type = typeof node.value;
+  if (type === "number") {
+    const match = import_prettier_plugin_monkeyc.LiteralIntegerRe.exec(node.raw);
+    if (match) {
+      return match[2] === "l" || match[2] === "L" ? [node, "Long"] : [node, "Number"];
+    }
+    return [node, node.raw.endsWith("d") ? "Double" : "Float"];
+  }
+  if (type === "bigint") {
+    return [node, "Long"];
+  }
+  if (type === "string") {
+    return node.raw.startsWith("'") ? [node, "Char"] : [node, "String"];
+  }
+  if (type === "boolean") {
+    return [node, "Boolean"];
+  }
+  throw new Error(`Literal has unknown type '${type}'`);
+}
+function wrap(node, loc) {
+  if (loc) {
+    node.loc = loc;
+    node.start = loc.start.offset;
+    node.end = loc.end.offset;
+  }
+  return node;
+}
+function locRange(start, end) {
+  return {
+    source: start.source || end.source,
+    start: start.start,
+    end: end.end
+  };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+  return {
+    source: loc.source,
+    start: {
+      offset: loc.start.offset + start,
+      line: loc.start.line,
+      column: loc.start.column + start
+    },
+    end: {
+      offset: loc.end.offset + end,
+      line: loc.end.line,
+      column: loc.end.column + end
+    }
+  };
+}
+function makeIdentifier(name, loc) {
+  return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+  return wrap(
+    {
+      type: "MemberExpression",
+      object,
+      property,
+      computed: false
+    },
+    object.loc && locRange(object.loc, property.loc)
+  );
+}
+function makeScopedName(dotted, l) {
+  const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+  const result = dotted.split(/\s*\.\s*/).reduce(
+    ({ cur, offset }, next) => {
+      const id = makeIdentifier(
+        next,
+        loc && adjustLoc(loc, offset, offset + next.length)
+      );
+      if (!cur) {
+        cur = id;
+      } else {
+        cur = makeMemberExpression(cur, id);
+      }
+      offset += next.length + 1;
+      return { cur, offset };
+    },
+    { cur: null, offset: 0 }
+  ).cur;
+  if (!result)
+    throw new Error("Failed to make a ScopedName");
+  return result;
+}
+function getLiteralNode(node) {
+  if (node == null)
+    return null;
+  if (node.type === "Literal")
+    return node;
+  if (node.type === "BinaryExpression" && node.operator === "as") {
+    return getLiteralNode(node.left) && node;
+  }
+  if (node.type === "UnaryExpression") {
+    if (node.argument.type !== "Literal")
+      return null;
+    switch (node.operator) {
+      case "-": {
+        const [arg, type] = getNodeValue(node.argument);
+        if (type === "Number" || type === "Long") {
+          return { ...arg, value: -arg.value, raw: `-${arg.raw}` };
+        }
+      }
+    }
+  }
+  return null;
+}
+var mctreeTypeInfo;
+var init_ast = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/ast.ts"() {
+    "use strict";
+    mctreeTypeInfo = {
+      ArrayExpression: { keys: ["elements"], expr: true },
+      AssignmentExpression: { keys: ["left", "right"], expr: true },
+      AttributeList: { keys: ["attributes"] },
+      Attributes: { keys: ["elements"] },
+      BinaryExpression: { keys: ["left", "right"], expr: true },
+      Block: { keys: [] },
+      BlockStatement: { keys: ["body", "innerComments"], stmt: true },
+      BreakStatement: { keys: [], stmt: true },
+      CallExpression: { keys: ["callee", "arguments"], expr: true },
+      CatchClause: { keys: ["param", "body"] },
+      CatchClauses: { keys: ["catches"] },
+      ClassBody: { keys: ["body"] },
+      ClassDeclaration: { keys: ["attrs", "id", "superClass", "body"], stmt: true },
+      ClassElement: { keys: ["item"] },
+      ConditionalExpression: {
+        keys: ["test", "consequent", "alternate"],
+        expr: true
+      },
+      ContinueStatement: { keys: [], stmt: true },
+      DoWhileStatement: { keys: ["body", "test"], stmt: true },
+      EnumDeclaration: { keys: ["attrs", "id", "body"], stmt: true },
+      EnumStringBody: { keys: ["members"] },
+      EnumStringMember: { keys: ["id", "init"] },
+      ExpressionStatement: { keys: ["expression"], stmt: true },
+      ForStatement: { keys: ["init", "test", "body", "update"], stmt: true },
+      FunctionDeclaration: {
+        keys: ["attrs", "id", "params", "returnType", "body"],
+        stmt: true
+      },
+      Identifier: { keys: [], expr: true },
+      IfStatement: { keys: ["test", "consequent", "alternate"], stmt: true },
+      ImportModule: { keys: ["id"] },
+      InstanceOfCase: { keys: ["id"] },
+      Line: { keys: [] },
+      Literal: { keys: [], expr: true },
+      LogicalExpression: { keys: ["left", "right"], expr: true },
+      MemberExpression: { keys: ["object", "property"], expr: true },
+      MethodDefinition: { keys: ["params", "returnType"] },
+      ModuleDeclaration: { keys: ["attrs", "id", "body"], stmt: true },
+      MultiLine: { keys: [] },
+      NewExpression: { keys: ["callee", "arguments"], expr: true },
+      ObjectExpression: { keys: ["properties"], expr: true },
+      ParenthesizedExpression: { keys: ["expression"], expr: true },
+      Program: { keys: ["body", "comments"] },
+      Property: { keys: ["key", "value"] },
+      ReturnStatement: { keys: ["argument"], stmt: true },
+      SequenceExpression: { keys: ["expressions"], expr: true },
+      SizedArrayExpression: { keys: ["size", "ts"], expr: true },
+      SwitchCase: { keys: ["test", "consequent"] },
+      SwitchStatement: { keys: ["discriminant", "cases"], stmt: true },
+      ThisExpression: { keys: [], expr: true },
+      ThrowStatement: { keys: ["argument"], stmt: true },
+      TryStatement: { keys: ["block", "handler", "finalizer"], stmt: true },
+      TypedefDeclaration: { keys: ["attrs", "id", "ts"], stmt: true },
+      TypeSpecList: { keys: ["ts"] },
+      TypeSpecPart: { keys: ["name", "body", "callspec", "generics"] },
+      UnaryExpression: { keys: ["argument"], expr: true },
+      UpdateExpression: { keys: ["argument"], expr: true },
+      Using: { keys: ["id", "as"] },
+      VariableDeclaration: { keys: ["attrs", "declarations"], stmt: true },
+      VariableDeclarator: { keys: ["id", "init"] },
+      WhileStatement: { keys: ["test", "body"], stmt: true }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  adjustLoc,
+  cloneDeep,
+  getLiteralNode,
+  getNodeValue,
+  hasProperty,
+  init_ast,
+  isExpression,
+  isStatement,
+  locRange,
+  makeIdentifier,
+  makeMemberExpression,
+  makeScopedName,
+  mayThrow,
+  traverseAst,
+  withLoc,
+  withLocDeep,
+  wrap
+});