narrat 2.0.0-test-4 → 2.0.2

package/dist/types/character-types.d.ts

@@ -0,0 +1,27 @@
+export interface CharactersConfigFile {
+    config: {
+        imagesPath: string;
+    };
+    characters: {
+        [key: string]: CharacterData;
+    };
+}
+export interface CharacterData {
+    sprites?: {
+        [key: string]: string;
+    };
+    name: string;
+    style?: DialogStyle;
+}
+export interface DialogStyle {
+    color?: string;
+    boxCss?: {
+        [key: string]: any;
+    };
+    nameCss?: {
+        [key: string]: any;
+    };
+    textCss?: {
+        [key: string]: any;
+    };
+}

package/dist/types/dialog-box-types.d.ts

@@ -0,0 +1,10 @@
+import { DialogChoice } from '../stores/dialog-store';
+export interface DialogBoxParameters {
+    title: string;
+    text: string;
+    styleId: string;
+    choices: DialogChoice[];
+    textField?: boolean;
+    old: boolean;
+    interactive: boolean;
+}

package/dist/types/game-save.d.ts

@@ -0,0 +1,21 @@
+import { AudioSave } from '../stores/audio-store';
+import { DialogSave } from '../stores/dialog-store';
+import { HudSave } from '../stores/hud-stats-store';
+import { InventorySave } from '../stores/inventory-store';
+import { MainSaveData } from '../stores/main-store';
+import { QuestLogSave } from '../stores/quest-log';
+import { ScreenSave } from '../stores/screens-store';
+import { SkillsSave } from '../stores/skills';
+import { VMSave } from '../stores/vm-store';
+export declare type GameSave = {
+    version: string;
+    skills: SkillsSave;
+    screen: ScreenSave;
+    main: MainSaveData;
+    dialog: DialogSave;
+    vm: VMSave;
+    audio: AudioSave;
+    hud: HudSave;
+    inventory: InventorySave;
+    quests: QuestLogSave;
+};

package/dist/types/parser.d.ts

@@ -0,0 +1,92 @@
+export declare namespace Parser {
+    type Primitive = string | number | boolean;
+    type Expression = Array<Primitive | Expression>;
+    interface IfOptions {
+        condition: string;
+        success: Branch;
+        failure?: Branch;
+    }
+    interface ChoiceOptions {
+        prompt: ParsedExpression;
+        choices: ChoicePrompt[];
+    }
+    interface ChoicePrompt {
+        choice: string;
+        branch: Branch;
+        condition?: string;
+        skillCheck?: SkillCheckOptions;
+        index: number;
+    }
+    interface PlayOptions {
+        mode: 'sound' | 'music';
+        audio: string;
+    }
+    interface StopOptions {
+        mode: 'sound' | 'music';
+        audio?: string;
+    }
+    interface SkillCheckOptions {
+        id: string;
+        skill: string;
+        value: number;
+        hideAfterRoll: boolean;
+        success: Branch;
+        failure: Branch;
+    }
+    interface JumpOptions {
+        label: string;
+    }
+    interface WaitOptions {
+        duration: number;
+    }
+    interface TextOptions {
+        text: string;
+    }
+    interface SetScreenOption {
+        screen: string;
+    }
+    interface EmptyOptions {
+    }
+    type DefaultArg = {
+        [key: string]: Arg;
+    };
+    type CommandOptions<T = DefaultArg> = T;
+    interface Command<Options = CommandOptions, StaticOptions = {}> {
+        args: Arg[];
+        commandType: string;
+        options: Options;
+        code: string;
+        staticOptions: StaticOptions;
+        operator: string;
+        line: number;
+        fileName: string;
+    }
+    type Arg = ParsedExpression | Primitive;
+    interface ParsedExpression<Options = CommandOptions, StaticOptions = {}> {
+        code: string;
+        command: {
+            commandType: string;
+            operator: string;
+            args: Arg[];
+            options: Options;
+            staticOptions: StaticOptions;
+        };
+        fileName: string;
+        line: number;
+    }
+    type Branch = ParsedExpression[];
+    interface ParsedScript {
+        [key: string]: ParsedLabel;
+    }
+    interface ParsedLabel {
+        branch: Parser.Branch;
+        args?: string[];
+    }
+    interface Line {
+        code: string;
+        indentation: number;
+        line: number;
+        expression: Expression;
+        branch?: Line[];
+    }
+}

package/dist/types/state.d.ts

@@ -0,0 +1,3 @@
+export interface Vue {
+    $mq: 'sm' | 'md' | 'lg';
+}

package/dist/utils/ajax.d.ts

@@ -0,0 +1 @@
+export declare function getFile(url: string): Promise<string>;

package/dist/utils/audio-loader.d.ts

@@ -0,0 +1,13 @@
+import { Config, MusicConfig, AudioConfig } from '../config';
+import { Howl } from 'howler';
+export declare const audio: {
+    [key: string]: Howl;
+};
+export declare function loadAudioAssets(config: Config): Promise<void[]>;
+export declare function audioEvent(event: string): void;
+export declare function loadAudio(key: string, config: AudioConfig | MusicConfig): Promise<void>;
+export declare function changeMusic(newMusic: string): Promise<void>;
+export declare function playAudio(key: string): number | undefined;
+export declare function getAudio(key: string): Howl | undefined;
+export declare function stopAudio(key: string): void;
+export declare function pauseAudio(key: string): void;

package/dist/utils/characters.d.ts

@@ -0,0 +1,5 @@
+import { CharacterData, CharactersConfigFile, DialogStyle } from '../types/character-types';
+export declare function setCharactersConfig(data: CharactersConfigFile): void;
+export declare function getCharacterInfo(character: string): CharacterData;
+export declare function getCharacterPictureUrl(character: string, pose?: string): string | undefined;
+export declare function getCharacterStyle(character?: string): DialogStyle;

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

@@ -0,0 +1,19 @@
+export declare function findDataHelper<T>(sourceObj: any, path: string): [T, string];
+export declare function findDataHelperWithoutAutoCreate<T>(sourceObj: any, path: string): [T, string] | undefined;
+export declare function setDataHelper<T>(sourceObj: any, path: string, value: T): void;
+export declare function addDataHelper<T>(sourceObj: any, path: string, value: T): void;
+export declare function getModifiableDataPinia(): {
+    data: import("../stores/vm-store").DataState;
+    skills: import("../stores/skills").SkillsState;
+    buttons: import("../stores/screens-store").ButtonsState;
+    items: {
+        [key: string]: import("../stores/inventory-store").ItemState;
+    };
+    quests: {
+        [key: string]: import("../stores/quest-log").QuestState;
+    };
+    stats: import("../stores/hud-stats-store").HudStatsState;
+    scope: {
+        [key: string]: any;
+    };
+};

package/dist/utils/debounce.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A function that emits a side effect.
+ */
+export declare type Procedure = (...args: any[]) => any;
+export declare type Options<TT> = {
+    isImmediate?: boolean;
+    maxWait?: number;
+    callback?: (data: TT) => void;
+};
+export interface DebouncedFunction<F extends Procedure> {
+    (this: ThisParameterType<F>, ...args: Parameters<F>): Promise<ReturnType<F>>;
+    cancel: (reason?: any) => void;
+}
+export declare function debounce<F extends Procedure>(func: F, waitMilliseconds?: number, options?: Options<ReturnType<F>>): DebouncedFunction<F>;

package/dist/utils/error-handling.d.ts

@@ -0,0 +1,3 @@
+import { ParserContext } from '../vm/vm-parser';
+export declare function parserError(ctx: ParserContext, line: number, text: string): void;
+export declare function error(text: string): void;

package/dist/utils/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function aspectRatioFit(screenWidth: number, screenHeight: number, gameWidth: number, gameHeight: number): number;
+export declare function screenToCanvas(x: number, y: number, element: HTMLCanvasElement): {
+    x: number;
+    y: number;
+};
+export declare function aabb(ax: number, ay: number, aw: number, ah: number, bx: number, by: number, bw: number, bh: number): boolean;

package/dist/utils/images-loader.d.ts

@@ -0,0 +1,6 @@
+import { Config } from '../config';
+export declare const images: {
+    [key: string]: HTMLImageElement;
+};
+export declare function loadImages(config: Config): Promise<void>;
+export declare function loadImage(key: string, path: string, resolver: any, rejecter: any): void;

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+export declare class LogManager {
+    debug: boolean;
+    logger: {
+        [key: string]: (...args: any[]) => void;
+    };
+    setupDebugger(debug: boolean): void;
+}
+export declare const logManager: LogManager;
+export declare const logger: {
+    [key: string]: (...args: any[]) => void;
+};

package/dist/utils/object-iterators.d.ts

@@ -0,0 +1,8 @@
+export declare const everyObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => boolean;
+export declare const someObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => true | undefined;
+export declare const mapObject: <T, U>(object: T, mapper: (value: T[keyof T]) => U) => {
+    [key: string]: U;
+};
+export declare const filterObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => {
+    [key: string]: T[keyof T];
+};

package/dist/utils/promises.d.ts

@@ -0,0 +1 @@
+export declare function timeout(durationMs: number): Promise<unknown>;

package/dist/utils/randomId.d.ts

@@ -0,0 +1 @@
+export declare function randomId(): string;

package/dist/utils/skillchecks.d.ts

@@ -0,0 +1,17 @@
+import { SkillCheckParams } from '../vm/vm-helpers';
+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;
+    unmodifiedRoll: number;
+};
+export declare function resolveSkillCheck(params: SkillCheckParams): boolean;

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

@@ -0,0 +1,3 @@
+export declare function processText(text: string): string;
+export declare const stringRegex: RegExp;
+export declare const isParsedTokenString: (arg: any) => boolean;

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

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

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

@@ -0,0 +1,17 @@
+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 multiplicationPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const divisionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;

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

@@ -0,0 +1,8 @@
+import { CommandPlugin } from './command-plugin';
+export interface PlayCommandArgs {
+    mode: string;
+    audio: string;
+}
+export declare const playCommand: CommandPlugin<PlayCommandArgs, {}>;
+export declare const pauseCommand: CommandPlugin<PlayCommandArgs, {}>;
+export declare const stopCommand: CommandPlugin<PlayCommandArgs, {}>;

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

@@ -0,0 +1,37 @@
+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, index: number): 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;
+        skillId: string;
+        skillCheckId: string;
+        difficulty: number;
+        hideAfterRoll: boolean;
+    };
+}
+export declare 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

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

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

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

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

@@ -0,0 +1,30 @@
+import { Parser } from '../../types/parser';
+import { ParserContext } from '../vm-parser';
+import { DialogChoice } from '../../stores/dialog-store';
+export declare type CommandRunner<Options, StaticOptions = {}> = (cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]) => Promise<any>;
+export declare type CommandParserFunction<Options, StaticOptions = {}> = (ctx: CommandParsingContext, command: Parser.ParsedExpression<Options, StaticOptions>) => {
+    newLine: number;
+};
+export declare 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 declare class CommandPlugin<Options, StaticOptions = {}> {
+    keyword: string;
+    runner: CommandRunner<Options, StaticOptions>;
+    argTypes: ArgTypes;
+    parser: CommandParserFunction<Options, StaticOptions>;
+    onPlayerAnswered?: (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<void>;
+    constructor(keyword: string, argTypes: ArgTypes, runner: CommandRunner<Options, StaticOptions>, parser?: CommandParserFunction<Options, StaticOptions>);
+}
+export declare type ArgTypes = ArgumentDescription[] | 'any';
+export interface ArgumentDescription {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'any';
+    optional?: boolean;
+}
+export declare function generateParser<Options, StaticOptions = {}>(keyword: string, argTypes: ArgTypes): CommandParserFunction<Options, StaticOptions>;

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

@@ -0,0 +1,14 @@
+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;
+}, {}>;

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

@@ -0,0 +1,10 @@
+import { CommandPlugin } from './command-plugin';
+import { Parser } from '../../types/parser';
+export interface IfOptions {
+    condition: boolean;
+}
+export interface IfStaticOptions {
+    success: Parser.Branch;
+    failure?: Parser.Branch;
+}
+export declare const ifCommand: CommandPlugin<IfOptions, IfStaticOptions>;

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

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

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

@@ -0,0 +1,15 @@
+import { CommandPlugin } from './command-plugin';
+export interface InventoryChangeArgs {
+    id: string;
+    amount: number;
+}
+export declare const addItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const removeItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const hasItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const itemAmountPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const enableInteractionPlugin: CommandPlugin<{
+    tag: string;
+}, {}>;
+export declare const disableInteractionPlugin: CommandPlugin<{
+    tag: string;
+}, {}>;

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

@@ -0,0 +1,42 @@
+import { CommandPlugin } from './command-plugin';
+export declare const equalPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const greaterThanPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const lesserThanPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const greaterOrEqualPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const lesserOrEqualPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const notEqualPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const notPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const andPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const orPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const ternaryPlugin: CommandPlugin<{
+    a: boolean;
+    b: any;
+    c: any;
+}, {}>;

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

@@ -0,0 +1,4 @@
+import { CommandPlugin } from './command-plugin';
+export declare const notifyPlugin: CommandPlugin<{
+    text: string;
+}, {}>;

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

@@ -0,0 +1,30 @@
+import { CommandPlugin } from './command-plugin';
+export declare const startQuestPlugin: CommandPlugin<{
+    questId: string;
+}, {}>;
+export declare const startObjectivePlugin: CommandPlugin<{
+    questId: string;
+    objectiveId: string;
+}, {}>;
+export declare const completeObjectivePlugin: CommandPlugin<{
+    questId: string;
+    objectiveId: string;
+}, {}>;
+export declare const completeQuestPlugin: CommandPlugin<{
+    questId: string;
+    ending?: string | undefined;
+}, {}>;
+export declare const questCompletedPlugin: CommandPlugin<{
+    questId: string;
+}, {}>;
+export declare const objectiveCompletedPlugin: CommandPlugin<{
+    questId: string;
+    objectiveId: string;
+}, {}>;
+export declare const questStartedPlugin: CommandPlugin<{
+    questId: string;
+}, {}>;
+export declare const objectiveStartedPlugin: CommandPlugin<{
+    questId: string;
+    objectiveId: string;
+}, {}>;

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

@@ -0,0 +1,8 @@
+import { CommandPlugin } from './command-plugin';
+export declare const setScreenCommand: CommandPlugin<{
+    screen: string;
+}, {}>;
+export declare const setButtonCommand: CommandPlugin<{
+    buttonId: string;
+    enabled: boolean;
+}, {}>;

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

@@ -0,0 +1,6 @@
+import { CommandPlugin } from './command-plugin';
+export declare const setCommand: CommandPlugin<any, {}>;
+export declare const addPlugin: CommandPlugin<{
+    key: any;
+    value: number;
+}, {}>;

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

@@ -0,0 +1,33 @@
+import { Parser } from '../../types/parser';
+import { CommandPlugin } from './command-plugin';
+export interface AddLevelArgs {
+    skillKey: string;
+    amount: number;
+}
+export declare const addLevelPlugin: CommandPlugin<AddLevelArgs, {}>;
+export interface AddXpArgs {
+    xpKey: string;
+    xpToAdd: number;
+}
+export declare const addXpPlugin: CommandPlugin<AddXpArgs, {}>;
+export interface SkillCheckOptions {
+    id: string;
+    skill: string;
+    value: number;
+    hideAfterRoll: boolean;
+    success: {
+        text: string;
+        branch: Parser.Branch;
+    };
+    failure: {
+        text: string;
+        branch?: Parser.Branch;
+    };
+}
+export interface RollArgs {
+    id: string;
+    skill: string;
+    value: number;
+    hideAfterRoll?: boolean;
+}
+export declare const rollPlugin: CommandPlugin<RollArgs, {}>;

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

@@ -0,0 +1,12 @@
+import { CommandPlugin } from './command-plugin';
+export declare const addStatPlugin: CommandPlugin<{
+    statKey: string;
+    amountToAdd: number;
+}, {}>;
+export declare const setStatPlugin: CommandPlugin<{
+    statKey: string;
+    value: number;
+}, {}>;
+export declare const getStatPlugin: CommandPlugin<{
+    statKey: string;
+}, {}>;

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

@@ -0,0 +1,9 @@
+import { CommandPlugin } from './command-plugin';
+export declare const stringConcatPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const stringJoinPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;

package/dist/vm/commands/text-field.d.ts

@@ -0,0 +1,7 @@
+import { CommandPlugin } from './command-plugin';
+export declare const textFieldPlugin: CommandPlugin<{
+    prompt: string;
+}, {}>;
+export declare const textFieldPromptPlugin: CommandPlugin<{
+    prompt: string;
+}, {}>;

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

@@ -0,0 +1,13 @@
+import { CommandParserFunction, CommandPlugin } from './command-plugin';
+export interface TalkArgs {
+    speaker: string;
+    pose: string;
+    text: string;
+}
+export declare const talkCommand: CommandPlugin<TalkArgs, {}>;
+export declare const textParser: () => CommandParserFunction<{}, {
+    text: string;
+}>;
+export declare const textCommandPlugin: CommandPlugin<{}, {
+    text: string;
+}>;

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

@@ -0,0 +1,4 @@
+import { CommandPlugin } from './command-plugin';
+export declare const waitCommand: CommandPlugin<{
+    duration: number;
+}, {}>;

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

@@ -0,0 +1,16 @@
+import { AddDialogParams } from '../stores/dialog-store';
+import { SkillCheckState } from '../stores/skills';
+import { Parser } from '../types/parser';
+import { IfOptions, IfStaticOptions } from './commands/if';
+export interface SkillCheckParams {
+    skill: string;
+    value: number;
+    id: string;
+    hideAfterRoll?: boolean;
+}
+export declare function runSkillCheck(params: SkillCheckParams): SkillCheckState;
+export declare function runConditionCommand(command: Parser.Command<IfOptions, IfStaticOptions>): Parser.Branch | undefined;
+export declare function isExpression(arg: Parser.Arg): arg is Parser.ParsedExpression;
+export declare function writeText(text: string): void;
+export declare function textCommand(dialog: AddDialogParams): Promise<void>;
+export declare function getLine(lines: Parser.Line[], index: number): Parser.Line | undefined;