hzengine-core 0.1.2-dev

package/src/plugins/basic_command/audio.ts

@@ -0,0 +1,53 @@
+import { HZEngineCore } from "../../index.js";
+import Path from "../../utils/path.js";
+
+export function audio_command(core: HZEngineCore) {
+  // play command: play <channel> "<path>"
+  core.script.use((ctx, next) => {
+    if (
+      ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "play" &&
+      ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "queue"
+    )
+      return next();
+    if (ctx.slicedArgs.length !== 3)
+      throw `${ctx.slicedArgs[0].str.toUpperCase()} Command: incorrect amount of args`;
+    if (!ctx.slicedArgs[2].isQuoted)
+      throw `the third arg of ${ctx.slicedArgs[0].str} command should be quoted as string path`;
+
+    let channel_name = ctx.slicedArgs[1].str;
+    let path = ctx.slicedArgs[2].str;
+
+    core.debug.log(`Play Command: play ${channel_name} ${path}`);
+
+    let channel = core.audio.channels[channel_name];
+
+    if (!channel) {
+      throw `audio channel ${channel_name} not found`;
+    }
+
+    if (ctx.slicedArgs[0].str !== "queue") {
+      channel.stop();
+    }
+    channel.push({ path: Path.join(core.storage.projectRoot!, "audio", path) });
+    channel.play();
+  });
+
+  // stop command: stop <channel>
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "stop") {
+      return next();
+    }
+    if (ctx.slicedArgs.length !== 2) {
+      throw `Stop Command: incorrect amount of args`;
+    }
+
+    let channel_name = ctx.slicedArgs[1].str;
+
+    let channel = core.audio.channels[channel_name];
+
+    if (!channel) {
+      throw `audio channel ${channel_name} not found`;
+    }
+    channel.stop();
+  });
+}

package/src/plugins/basic_command/basic.ts

@@ -0,0 +1,145 @@
+import { HZEngineCore, UI } from "../../index.js";
+
+export function basic_commands(core: HZEngineCore) {
+  // jump command
+  core.script.use((ctx, next) => {
+    let strArr = ctx.rawtext.trim().split(/ +/);
+    if (strArr.length === 0 || strArr[0].toLowerCase() !== "jump")
+      return next();
+    if (strArr.length !== 2) throw "Jump Command: incorrect amount of args";
+    core.debug.log(`Jump Command: jump to label [${strArr[1]}]`);
+    core.script.jumpLabel(strArr[1]);
+  });
+
+  // call command
+  core.script.use((ctx, next) => {
+    let strArr = ctx.rawtext.trim().split(/ +/);
+    if (strArr.length === 0 || strArr[0].toLowerCase() !== "call")
+      return next();
+    if (strArr.length !== 2) throw "Call Command: incorrect amount of args";
+    core.debug.log(`Call Command: call label [${strArr[1]}]`);
+    core.script.callLabel(strArr[1]);
+  });
+
+  // return command
+  core.script.use((ctx, next) => {
+    let strArr = ctx.rawtext.trim().split(/ +/);
+    if (strArr.length === 0 || strArr[0].toLowerCase() !== "return")
+      return next();
+    if (strArr.length !== 1)
+      throw "Return Command: this command can not have args";
+    core.debug.log(`Return Command: return`);
+    core.script.return();
+  });
+
+  // (debug) echo command
+  core.script.use((ctx, next) => {
+    let str = ctx.rawtext.trim();
+    if (!str.startsWith("echo")) return next();
+    core.debug.log(`[ECHO] ${core.script.parseString(str.slice(4).trim())}`);
+  });
+
+  // say command
+  core.script.use((ctx, next) => {
+    if (!ctx.rawtext.trim().startsWith('"')) return next();
+
+    function parseSayCommandArgs() {
+      if (
+        ctx.slicedArgs.length > 0 &&
+        ctx.slicedArgs[ctx.slicedArgs.length - 1].str === "nowait"
+      ) {
+        ctx.slicedArgs = ctx.slicedArgs.slice(0, ctx.slicedArgs.length - 1);
+        return {
+          wait: false,
+        };
+      } else {
+        return {
+          wait: true,
+        };
+      }
+    }
+
+    let parsed = parseSayCommandArgs();
+
+    if (ctx.slicedArgs.length > 2 || ctx.slicedArgs.length < 1) {
+      throw `Say Command: incorrect amount of args`;
+    }
+
+    if (ctx.slicedArgs.length === 1) {
+      core.debug.log(`[SAY] ${ctx.slicedArgs[0].str}`);
+      sayAction(core, "", ctx.slicedArgs[0].str, parsed.wait);
+    } else {
+      if (!ctx.slicedArgs[1].isQuoted)
+        throw `Say Command: second arg should be quoted`;
+      core.debug.log(`[SAY] ${ctx.slicedArgs[0].str}: ${ctx.slicedArgs[1].str}`);
+      sayAction(
+        core,
+        ctx.slicedArgs[0].str,
+        ctx.slicedArgs[1].str,
+        parsed.wait
+      );
+    }
+
+    // if (parsed?.wait) core.system.pause();
+  });
+
+  // pause command
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "pause")
+      return next();
+    if (ctx.slicedArgs.length > 2)
+      throw `Pause Command: incorrect amount of args`;
+    if (ctx.slicedArgs.length === 2) {
+      if (
+        ctx.slicedArgs[1].isQuoted ||
+        !isFinite(Number(ctx.slicedArgs[1].str))
+      )
+        throw `Pause Command: the second arg must be a number`;
+      core.system.pause(Number(ctx.slicedArgs[1].str) * 1000);
+    } else core.system.pause();
+  });
+}
+
+export function sayAction(
+  core: HZEngineCore,
+  who: string,
+  what: string,
+  wait: boolean
+) {
+  const say_view_tag = "hzengine.say";
+  const say_view_name = "say";
+  what = core.script.parseString(what);
+  let message = {
+    who,
+    what,
+  };
+  let router = core.ui.getRouter(say_view_tag);
+  if (!router) {
+    core.ui.addRouter(say_view_tag, "ct");
+    router = core.ui.getRouter(say_view_tag)!;
+  }
+  if (!router.length) {
+    // @ts-ignore
+    router.push<UI.Message>(say_view_name, message);
+  } else {
+    // @ts-ignore
+    router.update<UI.Message>(message);
+  }
+
+  if (wait) {
+    
+    if (core.config.getConfig("game.autoplay.enable")) {
+      let delay =
+        (core.config.getConfig("game.autoplay.extra_delay") as number) +
+        (core.config.getConfig("game.autoplay.ms_per_char") as number) *
+          what.length;
+      
+      if (isNaN(delay) || !isFinite(delay) || delay < 0) {
+        throw `Say Action: AutoPlay Delay Error: ${delay} ms`;
+      }
+      core.system.pause(delay);
+    } else {
+      core.system.pause();
+    }
+  }
+}

package/src/plugins/basic_command/character.ts

@@ -0,0 +1,144 @@
+import { HZEngineCore } from "../../index.js";
+import { sayAction } from "./basic.js";
+
+export function character_command(core: HZEngineCore) {
+  // character command
+  // Used to create a character, and save it to script field in archive storage,
+  // so that it can be used when the archive is loaded next time the game starts
+  // by loading the archive.
+  // syntax: character <short_name> <display_name>
+  // if the short name is conflict with an existing character, the script will throw an error
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "character")
+      return next();
+    if (ctx.slicedArgs.length > 3)
+      throw `Character Command: incorrect amount of args`;
+    if (ctx.slicedArgs.length === 1)
+      throw `Character Command: incorrect amount of args`;
+    if (ctx.slicedArgs.length === 2)
+      throw `Character Command: display name not specified`;
+    if (ctx.slicedArgs[1].isQuoted)
+      throw `Character Command: short name should not be quoted`;
+    // Check if the short name is conflict with an existing character
+    let short_name = ctx.slicedArgs[1].str;
+    let characterMap = getCharacterMap();
+    if (characterMap[short_name] != null) {
+      if (
+        characterMap[short_name].declare_info.path === ctx.currentPath &&
+        characterMap[short_name].declare_info.index === ctx.currentLineIndex
+      ) {
+      } else
+        throw `Character Command: short name [${short_name}] conflict, at file [${
+          characterMap[short_name].declare_info.path
+        }] line [${characterMap[short_name].declare_info.index + 1}] and `;
+    } else {
+      let display_name = ctx.slicedArgs[2].isQuoted
+        ? core.script.parseString(ctx.slicedArgs[2].str)
+        : ctx.slicedArgs[2].str;
+      characterMap[short_name] = buildCharacterInfo(short_name, display_name);
+    }
+
+    function buildCharacterInfo(
+      short_name: string,
+      display_name: string
+    ): CharacterInfo {
+      return {
+        short_name,
+        display_name,
+        declare_info: {
+          path: ctx.currentPath,
+          index: ctx.currentLineIndex,
+        },
+      };
+    }
+  });
+
+  function getCharacterMap(): Record<string, CharacterInfo> {
+    // // Check core.storage.archiveData
+    // if (typeof core.storage.archiveData == null)
+    //   throw `[HZEngine] ArchiveData is null`;
+    // if (typeof core.storage.archiveData != "object")
+    //   throw `[HZEngine] ArchiveData is not a object(Record or Array)`;
+    // if (Array.isArray(core.storage.archiveData))
+    //   throw `[HZEngine] ArchiveData is an Array`;
+    // // Check core.storage.archiveData.script
+    // if (core.storage.archiveData.script == null) {
+    //   console.log(`[HZEngine] ArchiveData.script is null, create it`);
+    //   core.storage.archiveData.script = {};
+    // }
+    // if (typeof core.storage.archiveData.script != "object")
+    //   throw `[HZEngine] ArchiveData.script is not a object(Record or Array)`;
+    // if (Array.isArray(core.storage.archiveData.script))
+    //   throw `[HZEngine] ArchiveData.script is an Array`;
+    // // Check core.storage.archiveData.script.characterMap
+    // if (core.storage.archiveData.script.characterMap == null) {
+    //   console.log(
+    //     `[HZEngine] ArchiveData.script.characterMap is null, create it`
+    //   );
+    //   core.storage.archiveData.script.characterMap = {};
+    // }
+    // if (typeof core.storage.archiveData.script.characterMap != "object")
+    //   throw `[HZEngine] ArchiveData.script.characterMap is not a object(Record or Array)`;
+    // if (Array.isArray(core.storage.archiveData.script.characterMap))
+    //   throw `[HZEngine] ArchiveData.script.characterMap is an Array`;
+    // return core.storage.archiveData.script.characterMap as any; // TODO
+    return core.storage.getSaveableData(
+      core.storage.archiveData,
+      true,
+      "script",
+      "characterMap"
+    ) as unknown as Record<string, CharacterInfo>;
+  }
+  interface CharacterInfo {
+    short_name: string;
+    display_name: string;
+    // debug
+    declare_info: {
+      path: string;
+      index: number;
+    };
+  }
+
+  // Gramma: %short_name% "{message}"
+  core.script.use((ctx, next) => {
+    if (ctx.slicedArgs[0].isQuoted) return next();
+    let characterMap = getCharacterMap();
+    let short_name = ctx.slicedArgs[0].str;
+    for (let key in characterMap) {
+      // console.log(`Character Say Command: key=${key} sn=${short_name}`);
+
+      function parseSayCommandArgs() {
+        if (
+          ctx.slicedArgs.length > 0 &&
+          ctx.slicedArgs[ctx.slicedArgs.length - 1].str === "nowait"
+        ) {
+          ctx.slicedArgs = ctx.slicedArgs.slice(0, ctx.slicedArgs.length - 1);
+          return {
+            wait: false,
+          };
+        } else {
+          return {
+            wait: true,
+          };
+        }
+      }
+  
+      let parsed = parseSayCommandArgs();
+
+      if (key === short_name) {
+        if (ctx.slicedArgs.length != 2)
+          throw `Character Say Command: incorrect amount of args`;
+        console.log(
+          "Character Say Command:",
+          short_name,
+          ctx.slicedArgs[1].str
+        );
+
+        sayAction(core, characterMap[key].display_name, ctx.slicedArgs[1].str, parsed.wait);
+        // if(parsed.wait) core.system.pause();
+        return;
+      }
+    }
+    return next();
+  });
+}

package/src/plugins/basic_command/conditional.ts

@@ -0,0 +1,349 @@
+import { HZEngineCore } from "../../index.js";
+
+export function conditional(core: HZEngineCore) {
+  // if ... [elif] ... [else] ... end if
+  // syntax:
+  // if <expression>
+  // <code>
+  // [elif <expression>]
+  // <code>
+  // [else]
+  // <code>
+  // end if
+
+  // if statement start
+  core.script.use((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "if"
+    ) {
+      return next();
+    }
+    let data = ctx.startStatement("if") as unknown as IfStatementData;
+    // console.log(`if data=${JSON.stringify(data)}`);
+
+    let if_expression_res: unknown = core.script.evalExpression(
+      data.if_expression
+    );
+    if (typeof if_expression_res !== "boolean") {
+      throw `If statement: if expression must return boolean, at file [${data.start_position[0]}] line [${data.start_position[1]}]`;
+    }
+    if (if_expression_res) {
+      // continue to execute next line
+      return;
+    }
+
+    // analyse elif
+    for (let i = 0; i < data.elif_list.length; i++) {
+      let item = data.elif_list[i];
+      let elif_expression_res = core.script.evalExpression(item.expression);
+      if (typeof elif_expression_res !== "boolean") {
+        throw `If statement: elif expression must return boolean, at file [${item.position[0]}] line [${item.position[1]}]`;
+      }
+      if (elif_expression_res) {
+        // jump to next line of elif statement
+        core.script.jump(item.position[0], item.position[1] + 1);
+        return;
+      }
+    }
+
+    // analyse else
+    if (data.else_position) {
+      core.script.jump(data.else_position[0], data.else_position[1] + 1);
+      return;
+    }
+
+    // the expressions are all false
+    // jump to the end of if statement
+    core.script.jump(data.end_position[0], data.end_position[1]);
+  });
+  // elif statement
+  // when come across next elif statement, jump to "end if" statement to stop execute.
+  core.script.use((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "elif"
+    ) {
+      return next();
+    }
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "if"
+    ) {
+      throw `If statement: elif statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    let data = ctx.statementStack[
+      ctx.statementStack.length - 1
+    ][2] as unknown as IfStatementData;
+    // check if this elif statement belong to the closest if statement
+    for (let i = 0; i < data.elif_list.length; i++) {
+      let item = data.elif_list[i];
+      if (
+        item.position[0] === ctx.currentPath &&
+        item.position[1] === ctx.currentLineIndex
+      ) {
+        // jump to the "end if" statement
+        core.script.jump(data.end_position[0], data.end_position[1]);
+        return;
+      }
+    }
+    // the elif statement is not belong to the closest if statement, so throw error
+    throw `If statement: elif statement not belong to the closest if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+  });
+  // else statement
+  core.script.use((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "else"
+    ) {
+      return next();
+    }
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "if"
+    ) {
+      throw `If statement: else statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    let data = ctx.statementStack[
+      ctx.statementStack.length - 1
+    ][2] as unknown as IfStatementData;
+    // check if this else statement belong to the closest if statement
+    if (data.else_position) {
+      if (
+        data.else_position[0] === ctx.currentPath &&
+        data.else_position[1] === ctx.currentLineIndex
+      ) {
+        // jump to the "end if" statement
+        core.script.jump(data.end_position[0], data.end_position[1]);
+        return;
+      }
+    }
+    // the else statement is not belong to the closest if statement, so throw error
+    throw `If statement: else statement not belong to the closest if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+  });
+  // end if statement
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end if") {
+      return next();
+    }
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "if"
+    ) {
+      throw `If statement: end if statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    ctx.endStatement("if");
+  });
+
+  // analyse statement
+  // if statement
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "if"
+    ) {
+      return next();
+    }
+    if (ctx.slicedArgs.length < 2) {
+      throw `If statement: no expression specified, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    ctx.startStatement("if", {
+      start_position: [ctx.currentPath, ctx.currentLineIndex],
+      if_expression: ctx.rawtext.trim().slice(2).trim(),
+      elif_list: [],
+      else_position: null,
+    });
+  });
+  // elif statement
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "elif"
+    ) {
+      return next();
+    }
+    if (ctx.slicedArgs.length < 2) {
+      throw `If statement: no expression specified, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    // check if the closest statement is if statement
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "if"
+    ) {
+      throw `If statement: elif statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    let data = ctx.statementStack[
+      ctx.statementStack.length - 1
+    ][2] as unknown as IfStatementData;
+    data.elif_list.push({
+      position: [ctx.currentPath, ctx.currentLineIndex],
+      expression: ctx.rawtext.trim().slice(4).trim(),
+    });
+  });
+  // else statement
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "else"
+    ) {
+      return next();
+    }
+    // check if the closest statement is if statement
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "if"
+    ) {
+      throw `If statement: else statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    let data = ctx.statementStack[
+      ctx.statementStack.length - 1
+    ][2] as unknown as IfStatementData;
+    data.else_position = [ctx.currentPath, ctx.currentLineIndex];
+  });
+  // end if statement
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end if") {
+      return next();
+    }
+    let data = ctx.endStatement("if") as unknown as IfStatementData;
+    data.end_position = [ctx.currentPath, ctx.currentLineIndex];
+    ctx.setStatementData(data, [...data.start_position]);
+  });
+
+  // while ... end while
+
+  // while statement start
+  core.script.use((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "while"
+    ) {
+      return next();
+    }
+    let data = ctx.startStatement("while") as unknown as WhileStatementData;
+    // test if expression return boolean
+    let expression = data.while_expression;
+    let expression_res = core.script.evalExpression(expression);
+    if (typeof expression_res !== "boolean") {
+      throw `While statement: while expression must return boolean, at file [${data.start_position[0]}] line [${data.start_position[1]}]`;
+    }
+    if (!expression_res) {
+      ctx.endStatement("while");
+      core.script.jump(...data.end_position, false);
+      core.script.incrementNextPosition();
+    } else {
+      return;
+    }
+  });
+
+  // while statement end
+  core.script.use((ctx, next) => {
+    if (
+      ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end while"
+    ) {
+      return next();
+    }
+    // check if the closest statement is while statement
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "while"
+    ) {
+      throw `While statement: end while statement must come after while statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    // jump to while statement start line (loop)
+    let data = ctx.statementStack[
+      ctx.statementStack.length - 1
+    ][2] as unknown as WhileStatementData;
+    ctx.endStatement("while");
+    core.script.jump(...data.start_position, false);
+  });
+
+  // analyse while statement start
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "while"
+    ) {
+      return next();
+    }
+    let while_expression = ctx.rawtext.trim().slice(5).trim();
+    if (while_expression === "") {
+      throw `While statement: no expression specified, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+    ctx.startStatement("while", {
+      start_position: [ctx.currentPath, ctx.currentLineIndex],
+      while_expression,
+      end_position: [ctx.currentPath, ctx.currentLineIndex],
+    });
+  });
+
+  // analyse while statement end
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (
+      ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end while"
+    ) {
+      return next();
+    }
+    let data = ctx.endStatement("while") as unknown as WhileStatementData;
+    data.end_position = [ctx.currentPath, ctx.currentLineIndex];
+    ctx.setStatementData(data, [...data.start_position]);
+  });
+
+  // do ... end do until
+
+  // break command
+  core.script.use((ctx, next) => {
+    if (
+      ctx.slicedArgs[0].isQuoted ||
+      ctx.slicedArgs.length !== 1 ||
+      ctx.slicedArgs[0].str.toLowerCase() !== "break"
+    ) {
+      return next();
+    }
+
+    // find the closest breakable statement
+    // (currently only while statement is breakable)
+
+    //(debug) output stack
+    // console.log("Stack="+JSON.stringify(ctx.statementStack));
+
+    let resIndex = -1
+    for (let i = ctx.statementStack.length - 1; i >= 0; i--) {
+      if (ctx.statementStack[i][0] === "while") {
+        resIndex = i;
+        break;
+      }
+    }
+    if (resIndex === -1) {
+      throw `Break command: break statement must come after while statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    }
+
+    let data = ctx.statementStack[resIndex][2] as unknown as WhileStatementData;
+    core.debug.log(`Break command: break from ${ctx.statementStack[resIndex][0]} statement at file [${data.start_position[0]}] line [${data.start_position[1] + 1}]`);
+    core.script.jump(
+      ...data.end_position,
+      false
+    );
+    core.script.incrementNextPosition();
+
+    // clear statement stack from breakable statement
+    ctx.statementStack.splice(resIndex + 1, ctx.statementStack.length - resIndex - 1);
+  });
+}
+interface IfStatementData {
+  start_position: [path: string, index: number];
+  if_expression: string;
+  elif_list: ElifListItem[];
+  else_position: [path: string, index: number] | null;
+  end_position: [path: string, index: number];
+}
+interface ElifListItem {
+  position: [path: string, index: number];
+  expression: string;
+}
+
+interface WhileStatementData {
+  start_position: [path: string, index: number];
+  while_expression: string;
+  end_position: [path: string, index: number];
+}