narrat 3.2.2 → 3.2.4

package/dist/utils/skillchecks.d.ts

@@ -1,26 +1,26 @@
-import { SkillCheckParams } from '../vm/vm-helpers';
-import { SkillCheckOptionsConfig } from '../config/skillchecks-config';
-export type Roll = {
-    unmodified: number;
-    modified: number;
-};
-export type DiceRoll = Roll[];
-export declare function getSkillCheckDifficultyScore(value: number, level: number): number;
-export declare function getSkillCheckDifficultyText(value: number, level: number): string;
-export declare function getSkillCheckText({ skill, skillCheckId, value, }: {
-    skill: string;
-    skillCheckId: string;
-    value: number;
-}): {
-    difficultyText: string;
-    allowed: boolean;
-};
-export declare function getPassiveSkillCheckText(success: boolean, params: SkillCheckParams): string;
-export declare function calculateSkillCheckRoll(skill: string): {
-    roll: number;
-    rolls: DiceRoll;
-};
-export declare function rollAllDice(options: SkillCheckOptionsConfig, skill: string): DiceRoll;
-export declare function rollDice(diceRange: [number, number]): number;
-export declare function resolveSkillCheck(params: SkillCheckParams): boolean;
-export declare function checkIfRollSucceeded(roll: number, value: number): boolean;
+import { SkillCheckParams } from '../vm/vm-helpers';
+import { SkillCheckOptionsConfig } from '../config/skillchecks-config';
+export type Roll = {
+    unmodified: number;
+    modified: number;
+};
+export type DiceRoll = Roll[];
+export declare function getSkillCheckDifficultyScore(value: number, level: number): number;
+export declare function getSkillCheckDifficultyText(value: number, level: number): string;
+export declare function getSkillCheckText({ skill, skillCheckId, value, }: {
+    skill: string;
+    skillCheckId: string;
+    value: number;
+}): {
+    difficultyText: string;
+    allowed: boolean;
+};
+export declare function getPassiveSkillCheckText(success: boolean, params: SkillCheckParams): string;
+export declare function calculateSkillCheckRoll(skill: string): {
+    roll: number;
+    rolls: DiceRoll;
+};
+export declare function rollAllDice(options: SkillCheckOptionsConfig, skill: string): DiceRoll;
+export declare function rollDice(diceRange: [number, number]): number;
+export declare function resolveSkillCheck(params: SkillCheckParams): boolean;
+export declare function checkIfRollSucceeded(roll: number, value: number): boolean;

package/dist/utils/skillchecks.test.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/utils/string-helpers.d.ts

@@ -1,5 +1,5 @@
-export declare function processText(text: string): string;
-export declare function findVariable(text: string): any;
-export declare const stringRegex: RegExp;
-export declare const isParsedTokenString: (arg: any) => boolean;
-export declare function findAllHtmlTags(txt: string): RegExpExecArray[];
+export declare function processText(text: string): string;
+export declare function findVariable(text: string): any;
+export declare const stringRegex: RegExp;
+export declare const isParsedTokenString: (arg: any) => boolean;
+export declare function findAllHtmlTags(txt: string): RegExpExecArray[];

package/dist/utils/time-helpers.d.ts

@@ -1,2 +1,2 @@
-export declare function getPlayTime(startedAt: number, previousTime: number): number;
-export declare function toHHMMSS(time: number | string): string;
+export declare function getPlayTime(startedAt: number, previousTime: number): number;
+export declare function toHHMMSS(time: number | string): string;

package/dist/utils/tooltip-utils.d.ts

@@ -1,2 +1,2 @@
-export declare function processTooltipsInText(text: string): string;
-export declare function addTooltipToKeyword(_: string, $1: string): string;
+export declare function processTooltipsInText(text: string): string;
+export declare function addTooltipToKeyword(_: string, $1: string): string;

package/dist/utils/transition.d.ts

@@ -1,21 +1,21 @@
-export interface TransitionState extends AddTransition {
-    oldScreen?: string | null;
-    duration: number;
-    resolve: () => void;
-}
-export type TransitionMode = 'screen' | 'button';
-export declare function isTransitionMode(mode: any): mode is TransitionMode;
-export interface TransitionSettings {
-    delay?: number;
-    duration?: number;
-}
-export declare const transitionSettings: {
-    [key: string]: TransitionSettings;
-};
-export declare function getTransitionSettings(name: string): TransitionSettings;
-export declare function generateTransitionState(transition: AddTransition, oldScreen: string | null, resolve: () => void): TransitionState;
-export type AddTransition = {
-    transition: string;
-    duration?: number;
-    delay?: number;
-};
+export interface TransitionState extends AddTransition {
+    oldScreen?: string | null;
+    duration: number;
+    resolve: () => void;
+}
+export type TransitionMode = 'screen' | 'button';
+export declare function isTransitionMode(mode: any): mode is TransitionMode;
+export interface TransitionSettings {
+    delay?: number;
+    duration?: number;
+}
+export declare const transitionSettings: {
+    [key: string]: TransitionSettings;
+};
+export declare function getTransitionSettings(name: string): TransitionSettings;
+export declare function generateTransitionState(transition: AddTransition, oldScreen: string | null, resolve: () => void): TransitionState;
+export type AddTransition = {
+    transition: string;
+    duration?: number;
+    delay?: number;
+};

package/dist/utils/type-utils.d.ts

@@ -1,2 +1,2 @@
-export declare const generateObjectFromList: <T extends readonly string[]>(list: T) => { [K in T[number]]: K; };
-export declare const isPromise: <T>(value: any) => value is Promise<T>;
+export declare const generateObjectFromList: <T extends readonly string[]>(list: T) => { [K in T[number]]: K; };
+export declare const isPromise: <T>(value: any) => value is Promise<T>;

package/dist/utils/typed-emitter.d.ts

@@ -1,18 +1,18 @@
-export interface InputEvents {
-    keydown: (event: KeyboardEvent) => void;
-}
-export type EventsList<List> = {
-    [key in keyof List]: (...args: any[]) => void;
-};
-export type EventsMap<List extends EventsList<List>> = {
-    [key in keyof List]: Set<List[key]>;
-};
-export declare class TypedEmitter<List extends EventsList<List>> {
-    listeners: EventsMap<List>;
-    on<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
-    off<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
-    once<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
-    emit<Event extends keyof List>(event: Event, ...args: any[]): void;
-    clear(): void;
-    private addEventToMap;
-}
+export interface InputEvents {
+    keydown: (event: KeyboardEvent) => void;
+}
+export type EventsList<List> = {
+    [key in keyof List]: (...args: any[]) => void;
+};
+export type EventsMap<List extends EventsList<List>> = {
+    [key in keyof List]: Set<List[key]>;
+};
+export declare class TypedEmitter<List extends EventsList<List>> {
+    listeners: EventsMap<List>;
+    on<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
+    off<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
+    once<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
+    emit<Event extends keyof List>(event: Event, ...args: any[]): void;
+    clear(): void;
+    private addEventToMap;
+}

package/dist/utils/viewport-utils.d.ts

@@ -1,3 +1,3 @@
-import { ButtonConfig } from '../config/buttons-config';
-import { ScreenObjectState } from '../stores/screen-objects-store';
-export declare function isViewportElementClickable(conf: ButtonConfig | ScreenObjectState): boolean | undefined;
+import { ButtonConfig } from '../config/buttons-config';
+import { ScreenObjectState } from '../stores/screen-objects-store';
+export declare function isViewportElementClickable(conf: ButtonConfig | ScreenObjectState): boolean | undefined;

package/dist/utils/vue-directives.d.ts

@@ -1,2 +1,2 @@
-import { App } from 'vue';
-export declare function addDirectives(vue: App): void;
+import { App } from 'vue';
+export declare function addDirectives(vue: App): void;

package/dist/vm/commands/achievements-commands.d.ts

@@ -1,6 +1,6 @@
-import { CommandPlugin } from './command-plugin';
-export type AchievementIdArg = {
-    id: string;
-};
-export declare const unlockAchievement: CommandPlugin<AchievementIdArg, {}>;
-export declare const hasAchievementPlugin: CommandPlugin<AchievementIdArg, {}>;
+import { CommandPlugin } from './command-plugin';
+export type AchievementIdArg = {
+    id: string;
+};
+export declare const unlockAchievement: CommandPlugin<AchievementIdArg, {}>;
+export declare const hasAchievementPlugin: CommandPlugin<AchievementIdArg, {}>;

package/dist/vm/commands/arithmetic-commands.d.ts

@@ -1,23 +1,23 @@
-import { CommandPlugin } from './command-plugin';
-export declare const additionPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
-export declare const substractionPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
-export declare const negPlugin: CommandPlugin<{
-    a: number;
-}, {}>;
-export declare const absPlugin: CommandPlugin<{
-    a: number;
-}, {}>;
-export declare const multiplicationPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
-export declare const divisionPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const additionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const substractionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const negPlugin: CommandPlugin<{
+    a: number;
+}, {}>;
+export declare const absPlugin: CommandPlugin<{
+    a: number;
+}, {}>;
+export declare const multiplicationPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const divisionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;

package/dist/vm/commands/array-commands.d.ts

@@ -1,42 +1,42 @@
-import { CommandPlugin } from './command-plugin';
-export declare const shuffleCommand: CommandPlugin<{
-    array: any[];
-}, {}>;
-export declare const pushCommand: CommandPlugin<{
-    array: any[];
-    value: any;
-}, {}>;
-export declare const popCommand: CommandPlugin<{
-    array: any[];
-}, {}>;
-export declare const shiftCommand: CommandPlugin<{
-    array: any[];
-}, {}>;
-export declare const joinCommand: CommandPlugin<{
-    array: any[];
-    separator?: string | undefined;
-}, {}>;
-export declare const concatCommand: CommandPlugin<{
-    array: any[];
-}, {}>;
-export declare const includesCommand: CommandPlugin<{
-    array: any[];
-    searchElement: any;
-}, {}>;
-export declare const reverseCommand: CommandPlugin<{
-    array: any[];
-}, {}>;
-export declare const sliceCommand: CommandPlugin<{
-    array: any[];
-    start: number;
-    end?: number | undefined;
-}, {}>;
-export declare const spliceCommand: CommandPlugin<{
-    array: any[];
-    start: number;
-    end?: number | undefined;
-}, {}>;
-export declare const arrayFindIndexCommand: CommandPlugin<{
-    array: any[];
-    predicateLabel: string;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const shuffleCommand: CommandPlugin<{
+    array: any[];
+}, {}>;
+export declare const pushCommand: CommandPlugin<{
+    array: any[];
+    value: any;
+}, {}>;
+export declare const popCommand: CommandPlugin<{
+    array: any[];
+}, {}>;
+export declare const shiftCommand: CommandPlugin<{
+    array: any[];
+}, {}>;
+export declare const joinCommand: CommandPlugin<{
+    array: any[];
+    separator?: string | undefined;
+}, {}>;
+export declare const concatCommand: CommandPlugin<{
+    array: any[];
+}, {}>;
+export declare const includesCommand: CommandPlugin<{
+    array: any[];
+    searchElement: any;
+}, {}>;
+export declare const reverseCommand: CommandPlugin<{
+    array: any[];
+}, {}>;
+export declare const sliceCommand: CommandPlugin<{
+    array: any[];
+    start: number;
+    end?: number | undefined;
+}, {}>;
+export declare const spliceCommand: CommandPlugin<{
+    array: any[];
+    start: number;
+    end?: number | undefined;
+}, {}>;
+export declare const arrayFindIndexCommand: CommandPlugin<{
+    array: any[];
+    predicateLabel: string;
+}, {}>;

package/dist/vm/commands/audio-commands.d.ts

@@ -1,19 +1,19 @@
-import { CommandPlugin } from './command-plugin';
-export interface PlayCommandArgs {
-    mode: string;
-    audio: string;
-    channel?: number;
-}
-export declare const playCommand: CommandPlugin<PlayCommandArgs, {}>;
-export declare const resumeCommand: CommandPlugin<{
-    mode: string;
-    channel?: number | undefined;
-}, {}>;
-export declare const pauseCommand: CommandPlugin<{
-    mode: string;
-    channel?: number | undefined;
-}, {}>;
-export declare const stopCommand: CommandPlugin<{
-    mode: string;
-    channel?: number | undefined;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export interface PlayCommandArgs {
+    mode: string;
+    audio: string;
+    channel?: number;
+}
+export declare const playCommand: CommandPlugin<PlayCommandArgs, {}>;
+export declare const resumeCommand: CommandPlugin<{
+    mode: string;
+    channel?: number | undefined;
+}, {}>;
+export declare const pauseCommand: CommandPlugin<{
+    mode: string;
+    channel?: number | undefined;
+}, {}>;
+export declare const stopCommand: CommandPlugin<{
+    mode: string;
+    channel?: number | undefined;
+}, {}>;

package/dist/vm/commands/choice.d.ts

@@ -1,35 +1,35 @@
-import { SkillCheckParams } from '../../vm/vm-helpers';
-import { CommandParserFunction, CommandParsingContext, CommandPlugin, CommandRunner } from './command-plugin';
-import { Parser } from '../../types/parser';
-export declare const runChoice: CommandRunner<ChoiceOptions, StaticChoiceOptions>;
-export declare function parseChoiceOption(ctx: CommandParsingContext, choice: Parser.Line): BranchingChoiceInfo;
-export interface BranchingChoiceInfo {
-    prompt: Parser.ParsedExpression;
-    branch?: Parser.Branch;
-    skillBranches?: {
-        success: Parser.Branch;
-        failure: Parser.Branch;
-    };
-}
-export interface StaticChoiceOptions {
-    choices: BranchingChoiceInfo[];
-    prompt: Parser.ParsedExpression;
-}
-export interface ChoiceOptions {
-}
-export declare const choiceParser: CommandParserFunction<ChoiceOptions, StaticChoiceOptions>;
-export declare const choicePlugin: CommandPlugin<ChoiceOptions, StaticChoiceOptions>;
-export interface ChoicePromptOptions {
-    promptText: string;
-    condition: boolean;
-}
-export interface ChoicePromptReturnValue {
-    text: string | null;
-    skillCheck?: {
-        allowed?: boolean;
-        options: SkillCheckParams;
-    };
-}
-export type ChoicePromptReturn = ChoicePromptReturnValue;
-/** Custom "fake" instruction generated on choice prompts to process their optional conditions */
-export declare const choicePromptCommandPlugin: CommandPlugin<ChoicePromptOptions, {}>;
+import { SkillCheckParams } from '../../vm/vm-helpers';
+import { CommandParserFunction, CommandParsingContext, CommandPlugin, CommandRunner } from './command-plugin';
+import { Parser } from '../../types/parser';
+export declare const runChoice: CommandRunner<ChoiceOptions, StaticChoiceOptions>;
+export declare function parseChoiceOption(ctx: CommandParsingContext, choice: Parser.Line): BranchingChoiceInfo;
+export interface BranchingChoiceInfo {
+    prompt: Parser.ParsedExpression;
+    branch?: Parser.Branch;
+    skillBranches?: {
+        success: Parser.Branch;
+        failure: Parser.Branch;
+    };
+}
+export interface StaticChoiceOptions {
+    choices: BranchingChoiceInfo[];
+    prompt: Parser.ParsedExpression;
+}
+export interface ChoiceOptions {
+}
+export declare const choiceParser: CommandParserFunction<ChoiceOptions, StaticChoiceOptions>;
+export declare const choicePlugin: CommandPlugin<ChoiceOptions, StaticChoiceOptions>;
+export interface ChoicePromptOptions {
+    promptText: string;
+    condition: boolean;
+}
+export interface ChoicePromptReturnValue {
+    text: string | null;
+    skillCheck?: {
+        allowed?: boolean;
+        options: SkillCheckParams;
+    };
+}
+export type ChoicePromptReturn = ChoicePromptReturnValue;
+/** Custom "fake" instruction generated on choice prompts to process their optional conditions */
+export declare const choicePromptCommandPlugin: CommandPlugin<ChoicePromptOptions, {}>;

package/dist/vm/commands/clear_dialog.d.ts

@@ -1,2 +1,2 @@
-import { CommandPlugin } from './command-plugin';
-export declare const clearDialogPlugin: CommandPlugin<{}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const clearDialogPlugin: CommandPlugin<{}, {}>;

package/dist/vm/commands/command-helpers.d.ts

@@ -1,3 +1,3 @@
-import { Parser } from '../../types/parser';
-export declare function commandRuntimeError(cmd: Parser.Command<any, any>, errorText: string): void;
-export declare function commandLog(cmd: Parser.Command<any, any>, ...log: any[]): void;
+import { Parser } from '../../types/parser';
+export declare function commandRuntimeError(cmd: Parser.Command<any, any>, errorText: string): void;
+export declare function commandLog(cmd: Parser.Command<any, any>, ...log: any[]): void;

package/dist/vm/commands/command-plugin.d.ts

@@ -1,43 +1,43 @@
-import { Parser } from '../../types/parser';
-import { ParserContext } from '../vm-parser';
-import { DialogChoice } from '../../stores/dialog-store';
-export type CommandRunner<Options, StaticOptions = {}> = (cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]) => Promise<any>;
-export type CommandParserFunction<Options, StaticOptions = {}> = (ctx: CommandParsingContext, command: Parser.ParsedExpression<Options, StaticOptions>) => {
-    newLine: number;
-};
-export type ProcessCommandsFunction = (ctx: ParserContext, lines: Parser.Line[], parentLine: Parser.Line | undefined) => Parser.Branch;
-export interface CommandParsingContext {
-    parserContext: ParserContext;
-    processCommandsFunction: ProcessCommandsFunction;
-    line: Parser.Line;
-    lines: Parser.Line[];
-    currentLine: number;
-}
-export type OnPlayerAnswered<Options, StaticOptions> = (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<any>;
-export interface CommandPluginOptions<Options, StaticOptions = {}> {
-    keyword: string;
-    argTypes: ArgTypes;
-    runner: CommandRunner<Options, StaticOptions>;
-    parser?: CommandParserFunction<Options, StaticOptions>;
-    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
-    returnAfterPlayerAnswer?: boolean;
-}
-export declare class CommandPlugin<Options, StaticOptions = {}> {
-    keyword: string;
-    runner: CommandRunner<Options, StaticOptions>;
-    argTypes: ArgTypes;
-    parser: CommandParserFunction<Options, StaticOptions>;
-    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
-    returnAfterPlayerAnswer: boolean;
-    constructor(keyword: string, argTypes: ArgTypes, runner: CommandRunner<Options, StaticOptions>, parser?: CommandParserFunction<Options, StaticOptions>);
-    run(cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]): Promise<any>;
-    processPlayerAnswer(cmd: Parser.Command<Options, StaticOptions>, choice: number | string): Promise<any>;
-    static FromOptions<Options, StaticOptions = {}>(options: CommandPluginOptions<Options, StaticOptions>): CommandPlugin<Options, StaticOptions>;
-}
-export type ArgTypes = ArgumentDescription[] | 'any';
-export interface ArgumentDescription {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'any' | 'rest';
-    optional?: boolean;
-}
-export declare function generateParser<Options, StaticOptions = {}>(keyword: string, argTypes: ArgTypes): CommandParserFunction<Options, StaticOptions>;
+import { Parser } from '../../types/parser';
+import { ParserContext } from '../vm-parser';
+import { DialogChoice } from '../../stores/dialog-store';
+export type CommandRunner<Options, StaticOptions = {}> = (cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]) => Promise<any>;
+export type CommandParserFunction<Options, StaticOptions = {}> = (ctx: CommandParsingContext, command: Parser.ParsedExpression<Options, StaticOptions>) => {
+    newLine: number;
+};
+export type ProcessCommandsFunction = (ctx: ParserContext, lines: Parser.Line[], parentLine: Parser.Line | undefined) => Parser.Branch;
+export interface CommandParsingContext {
+    parserContext: ParserContext;
+    processCommandsFunction: ProcessCommandsFunction;
+    line: Parser.Line;
+    lines: Parser.Line[];
+    currentLine: number;
+}
+export type OnPlayerAnswered<Options, StaticOptions> = (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<any>;
+export interface CommandPluginOptions<Options, StaticOptions = {}> {
+    keyword: string;
+    argTypes: ArgTypes;
+    runner: CommandRunner<Options, StaticOptions>;
+    parser?: CommandParserFunction<Options, StaticOptions>;
+    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
+    returnAfterPlayerAnswer?: boolean;
+}
+export declare class CommandPlugin<Options, StaticOptions = {}> {
+    keyword: string;
+    runner: CommandRunner<Options, StaticOptions>;
+    argTypes: ArgTypes;
+    parser: CommandParserFunction<Options, StaticOptions>;
+    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
+    returnAfterPlayerAnswer: boolean;
+    constructor(keyword: string, argTypes: ArgTypes, runner: CommandRunner<Options, StaticOptions>, parser?: CommandParserFunction<Options, StaticOptions>);
+    run(cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]): Promise<any>;
+    processPlayerAnswer(cmd: Parser.Command<Options, StaticOptions>, choice: number | string): Promise<any>;
+    static FromOptions<Options, StaticOptions = {}>(options: CommandPluginOptions<Options, StaticOptions>): CommandPlugin<Options, StaticOptions>;
+}
+export type ArgTypes = ArgumentDescription[] | 'any';
+export interface ArgumentDescription {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'any' | 'rest';
+    optional?: boolean;
+}
+export declare function generateParser<Options, StaticOptions = {}>(keyword: string, argTypes: ArgTypes): CommandParserFunction<Options, StaticOptions>;

package/dist/vm/commands/flow-commands.d.ts

@@ -1,28 +1,28 @@
-import { CommandPlugin } from './command-plugin';
-export declare const jumpCommand: CommandPlugin<{
-    label: string;
-}, {}>;
-export declare const runLabelPlugin: CommandPlugin<{
-    label: string;
-}, {}>;
-export declare const defineVariablePlugin: CommandPlugin<{
-    name: string;
-    value: any;
-}, {}>;
-export declare const returnPlugin: CommandPlugin<{
-    value: any;
-}, {}>;
-export declare const logPlugin: CommandPlugin<{
-    value: any;
-}, {}>;
-export declare const returnMainMenuPlugin: CommandPlugin<{}, {}>;
-export declare const savePlugin: CommandPlugin<{
-    name?: string | undefined;
-}, {}>;
-export declare const savePromptPlugin: CommandPlugin<{
-    name?: string | undefined;
-}, {}>;
-export declare const resetGlobalPlugin: CommandPlugin<{}, {}>;
-export declare const newCommandPlugin: CommandPlugin<{
-    name?: string | undefined;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const jumpCommand: CommandPlugin<{
+    label: string;
+}, {}>;
+export declare const runLabelPlugin: CommandPlugin<{
+    label: string;
+}, {}>;
+export declare const defineVariablePlugin: CommandPlugin<{
+    name: string;
+    value: any;
+}, {}>;
+export declare const returnPlugin: CommandPlugin<{
+    value: any;
+}, {}>;
+export declare const logPlugin: CommandPlugin<{
+    value: any;
+}, {}>;
+export declare const returnMainMenuPlugin: CommandPlugin<{}, {}>;
+export declare const savePlugin: CommandPlugin<{
+    name?: string | undefined;
+}, {}>;
+export declare const savePromptPlugin: CommandPlugin<{
+    name?: string | undefined;
+}, {}>;
+export declare const resetGlobalPlugin: CommandPlugin<{}, {}>;
+export declare const newCommandPlugin: CommandPlugin<{
+    name?: string | undefined;
+}, {}>;

package/dist/vm/commands/if.d.ts

@@ -1,15 +1,15 @@
-import { CommandPlugin } from './command-plugin';
-import { Parser } from '../../types/parser';
-export interface IfOptions {
-    condition: boolean;
-}
-export interface ElseIfOptions {
-    branch: Parser.Branch;
-    condition: Parser.ParsedExpression;
-}
-export interface IfStaticOptions {
-    success: Parser.Branch;
-    elseifs: ElseIfOptions[];
-    failure?: Parser.Branch;
-}
-export declare const ifCommand: CommandPlugin<IfOptions, IfStaticOptions>;
+import { CommandPlugin } from './command-plugin';
+import { Parser } from '../../types/parser';
+export interface IfOptions {
+    condition: boolean;
+}
+export interface ElseIfOptions {
+    branch: Parser.Branch;
+    condition: Parser.ParsedExpression;
+}
+export interface IfStaticOptions {
+    success: Parser.Branch;
+    elseifs: ElseIfOptions[];
+    failure?: Parser.Branch;
+}
+export declare const ifCommand: CommandPlugin<IfOptions, IfStaticOptions>;

package/dist/vm/commands/index.d.ts

@@ -1,2 +1,2 @@
-import { VM } from '../vm';
-export declare function registerBaseCommands(vm: VM): void;
+import { VM } from '../vm';
+export declare function registerBaseCommands(vm: VM): void;