dirvi-lib 0.8.1 → 0.9.0

package/dist/{tree-surfer-ui → input}/application/intent-to-effect.js

@@ -1,4 +1,5 @@
 import { parseCommand } from './parse-command.js';
+import { parseNormalCommand } from './parse-normal-command.js';
 export function createIntentToEffect(stateApi, cursorApi, treeNodeApi) {
     return (intent, state) => {
         switch (intent.intentType) {
@@ -7,7 +8,7 @@ export function createIntentToEffect(stateApi, cursorApi, treeNodeApi) {
             case 'normalRight':
                 return normalInteractRightToEffect(state, stateApi, cursorApi, treeNodeApi);
             case 'normalLeft':
-                return normalInteractLeftToEffect(state);
+                return normalInteractLeftToEffect(state, cursorApi);
             case 'normalDown':
                 return dispatchAction({
                     effectActionType: 'nextEntry',
@@ -51,45 +52,60 @@ export function createIntentToEffect(stateApi, cursorApi, treeNodeApi) {
         }
     };
 }
+// =============================================================================
+// Normal mode
+// =============================================================================
+function keepNormalBuffer(normalBuffer) {
+    return {
+        effectType: 'setInputState',
+        inputState: {
+            inputMode: 'normal',
+            normalBuffer,
+        },
+    };
+}
 function dispatchAction(action) {
     return {
         effectType: 'dispatchEffectAction',
         action,
     };
 }
-// Sets the buffer. Three possibilities:
-// - New command buffer is recognized as a motion, this dispatches the
-// "effect action". Consumer will know to reset the input state.
-// - Prefix of a possible motion, updates normal buffer.
-// - Not a prefix, clears the buffer.
+function clearBuffer() {
+    return {
+        effectType: 'setInputState',
+        inputState: {
+            inputMode: 'normal',
+            normalBuffer: '',
+        },
+    };
+}
+/**
+ * Sets the normal-mode command buffer.
+ *
+ * Three possibilities:
+ *
+ * - The buffer is a recognized motion: dispatch its effect action.
+ * - The buffer is a prefix of a possible motion: retain it.
+ * - The buffer is not a valid prefix: clear it.
+ */
 function normalBufferToEffectResult(updatedNormalBuffer) {
-    switch (updatedNormalBuffer) {
-        case 'z':
-            return {
-                effectType: 'setInputState',
-                inputState: {
-                    inputMode: 'normal',
-                    normalBuffer: updatedNormalBuffer,
-                },
-            };
-        case 'zc':
-            return dispatchAction({
-                effectActionType: 'fold',
-            });
-        case 'zo':
-            return dispatchAction({
-                effectActionType: 'unfold',
-            });
-        default:
-            return {
-                effectType: 'setInputState',
-                inputState: {
-                    inputMode: 'normal',
-                    normalBuffer: '',
-                },
-            };
+    const commandResult = parseNormalCommand(updatedNormalBuffer);
+    switch (commandResult.kind) {
+        case 'incomplete':
+            return keepNormalBuffer(updatedNormalBuffer);
+        case 'complete':
+            return dispatchAction(commandResult.action);
+        case 'invalid':
+            return clearBuffer();
     }
 }
+/**
+ * Handles normal-mode right interaction.
+ *
+ * - A closed branch requests loading its children.
+ * - An open branch dispatches an action that closes/unloads its children.
+ * - A leaf has no right-interaction effect.
+ */
 function normalInteractRightToEffect(state, stateApi, cursorApi, treeNodeApi) {
     const currentEntry = stateApi.getNodeAtCursor(state);
     if (currentEntry === undefined) {
@@ -99,23 +115,31 @@ function normalInteractRightToEffect(state, stateApi, cursorApi, treeNodeApi) {
     if (path === undefined) {
         return undefined;
     }
-    if (treeNodeApi.isBranch(currentEntry)) {
-        if (currentEntry.children === null) {
+    switch (treeNodeApi.kind(currentEntry)) {
+        case 'unloaded-branch':
             return {
                 effectType: 'loadBranchEntries',
                 path,
             };
-        }
-        return dispatchAction({
-            effectActionType: 'setBranchEntries',
-            path,
-            entries: null,
-        });
+        case 'loaded-branch':
+            return dispatchAction({
+                effectActionType: 'setBranchEntries',
+                path,
+                entries: null,
+            });
+        case 'leaf':
+            return undefined;
     }
-    return;
 }
-function normalInteractLeftToEffect(state) {
-    if (state.cursor.length === 0) {
+/**
+ * Handles normal-mode left interaction.
+ *
+ * Left from the root has no effect. Otherwise dispatch navigation to the
+ * parent entry.
+ */
+function normalInteractLeftToEffect(state, cursorApi) {
+    const path = cursorApi.getPath(state.cursor);
+    if (path === undefined || path.length === 0) {
         return undefined;
     }
     return dispatchAction({

package/dist/input/application/parse-command.d.ts

@@ -0,0 +1,14 @@
+import type { SerializableKey } from '../../trees/index.js';
+import type { Effect } from '../domain/index.js';
+/**
+ * Parses a command-line command into an application effect.
+ *
+ * Command parsing is independent of the concrete tree-node value type, but the
+ * generic parameters allow its result to compose with the application's
+ * Effect<Id, Value> pipeline.
+ *
+ * @typeParam Id - The sibling-unique tree-node ID type.
+ * @typeParam Value - Application-owned data stored in each tree node.
+ */
+export declare function parseCommand<Id extends SerializableKey, Value>(commandLine: string): Effect<Id, Value> | undefined;
+//# sourceMappingURL=parse-command.d.ts.map

package/dist/input/application/parse-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-command.d.ts","sourceRoot":"","sources":["../../../src/input/application/parse-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AA0CjD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EAC5D,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,SAAS,CAyD/B"}

package/dist/input/application/parse-command.js

@@ -0,0 +1,92 @@
+const DEFAULT_VIEW_NAME = 'default';
+function parseFoldCommand(commandArgs) {
+    const [subcommand, name] = commandArgs;
+    switch (subcommand) {
+        case 'list':
+            return commandArgs.length === 1
+                ? {
+                    effectType: 'listFolds',
+                }
+                : {
+                    effectType: 'unrecognizedCommand',
+                    commandLine: `fold ${commandArgs.join(' ')}`,
+                };
+        case 'create':
+            return name === undefined || commandArgs.length !== 2
+                ? {
+                    effectType: 'unrecognizedCommand',
+                    commandLine: `fold ${commandArgs.join(' ')}`,
+                }
+                : {
+                    effectType: 'dispatchEffectAction',
+                    action: {
+                        effectActionType: 'createFoldTree',
+                        name,
+                    },
+                };
+        default:
+            return {
+                effectType: 'unrecognizedCommand',
+                commandLine: `fold ${commandArgs.join(' ')}`,
+            };
+    }
+}
+/**
+ * Parses a command-line command into an application effect.
+ *
+ * Command parsing is independent of the concrete tree-node value type, but the
+ * generic parameters allow its result to compose with the application's
+ * Effect<Id, Value> pipeline.
+ *
+ * @typeParam Id - The sibling-unique tree-node ID type.
+ * @typeParam Value - Application-owned data stored in each tree node.
+ */
+export function parseCommand(commandLine) {
+    const command = commandLine.trim().replace(/^:/, '');
+    if (command === "") {
+        return undefined;
+    }
+    const [commandName, ...commandArgs] = command.split(/\s+/);
+    switch (commandName) {
+        case 'q':
+            return {
+                effectType: 'quit',
+                exitMessage: '',
+            };
+        case 'fold':
+            return parseFoldCommand(commandArgs);
+        case 'evlp':
+            return {
+                effectType: 'emitVisibleLeavesPaths',
+            };
+        case 'mkview!':
+            return {
+                effectType: 'saveView',
+                name: commandArgs[0] || DEFAULT_VIEW_NAME,
+                overwrite: true,
+            };
+        case 'loadview':
+            return {
+                effectType: 'loadView',
+                name: commandArgs[0] || DEFAULT_VIEW_NAME,
+            };
+        default:
+            return {
+                effectType: 'unrecognizedCommand',
+                commandLine,
+            };
+    }
+    /*
+     * Vim-style view commands:
+     *
+     *   :mkview!
+     *   :mkview! project
+     *   :loadview
+     *   :loadview project
+     *
+     * The name may contain spaces, so capture the remainder of the command
+     * instead of splitting on whitespace.
+     *
+     * TODO Later: mkview that checks if a same-named view already exists.
+     */
+}

package/dist/input/application/parse-normal-command.d.ts

@@ -0,0 +1,12 @@
+import type { SerializableKey } from '../../trees/index.js';
+import type { EffectAction } from '../domain/index.js';
+export type ParseNormalCommandResult<Id extends SerializableKey, Value> = {
+    kind: 'incomplete';
+} | {
+    kind: 'complete';
+    action: EffectAction<Id, Value>;
+} | {
+    kind: 'invalid';
+};
+export declare function parseNormalCommand<Id extends SerializableKey, Value>(normalBuffer: string): ParseNormalCommandResult<Id, Value>;
+//# sourceMappingURL=parse-normal-command.d.ts.map

package/dist/input/application/parse-normal-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-normal-command.d.ts","sourceRoot":"","sources":["../../../src/input/application/parse-normal-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAOvD,MAAM,MAAM,wBAAwB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAClE;IACE,IAAI,EAAE,YAAY,CAAC;CACpB,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;CACjC,GACD;IACE,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC;AAEN,wBAAgB,kBAAkB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EAClE,YAAY,EAAE,MAAM,GACnB,wBAAwB,CAAC,EAAE,EAAE,KAAK,CAAC,CAwCrC"}

package/dist/input/application/parse-normal-command.js

@@ -0,0 +1,89 @@
+import { tokenizeNormalCommand, } from './tokenize-normal-command.js';
+export function parseNormalCommand(normalBuffer) {
+    const tokens = tokenizeNormalCommand(normalBuffer);
+    if (tokens.some(isInvalidToken)) {
+        return {
+            kind: 'invalid',
+        };
+    }
+    const [firstToken, secondToken] = tokens;
+    if (firstToken === undefined) {
+        return {
+            kind: 'invalid',
+        };
+    }
+    if (firstToken.tokenType === 'validInteger') {
+        if (secondToken === undefined) {
+            return {
+                kind: 'incomplete',
+            };
+        }
+        if (tokens.length !== 2) {
+            return {
+                kind: 'invalid',
+            };
+        }
+        return tokenToResult(secondToken, firstToken.value);
+    }
+    if (tokens.length !== 1) {
+        return {
+            kind: 'invalid',
+        };
+    }
+    return tokenToResult(firstToken, 0);
+}
+function isInvalidToken(token) {
+    return (token.tokenType === 'invalidInteger' || token.tokenType === 'invalidCommand');
+}
+function tokenToResult(token, index) {
+    switch (token.tokenType) {
+        case 'partialCommand':
+            return {
+                kind: 'incomplete',
+            };
+        case 'foldCommand':
+            return {
+                kind: 'complete',
+                action: foldCommandToAction(token, index),
+            };
+        case 'validInteger':
+        case 'invalidInteger':
+        case 'invalidCommand':
+            return {
+                kind: 'invalid',
+            };
+    }
+}
+function foldCommandToAction(foldCommand, index) {
+    const foldTree = {
+        foldTreeReferenceType: 'index',
+        index,
+    };
+    switch (foldCommand.foldCommandType) {
+        case 'addToFoldTree':
+            return {
+                effectActionType: 'addToFoldTree',
+                foldTree,
+            };
+        case 'removeFromFoldTree':
+            return {
+                effectActionType: 'removeFromFoldTree',
+                foldTree,
+            };
+        case 'fold':
+            return {
+                effectActionType: 'fold',
+                foldTree,
+            };
+        case 'unfold':
+            return {
+                effectActionType: 'unfold',
+                foldTree,
+            };
+        case 'toggleFold':
+            return {
+                effectActionType: 'toggleFold',
+                foldTree,
+            };
+    }
+}

package/dist/input/application/tokenize-normal-command.d.ts

@@ -0,0 +1,24 @@
+export type ValidInteger = {
+    tokenType: 'validInteger';
+    value: number;
+};
+export type InvalidInteger = {
+    tokenType: 'invalidInteger';
+    value: string;
+};
+export type PartialCommand = {
+    tokenType: 'partialCommand';
+    commandType: 'fold';
+};
+export type FoldCommand = {
+    tokenType: 'foldCommand';
+    foldCommandType: 'addToFoldTree' | 'removeFromFoldTree' | 'fold' | 'unfold' | 'toggleFold';
+};
+export type InvalidCommand = {
+    tokenType: 'invalidCommand';
+    value: string;
+};
+export type Token = ValidInteger | InvalidInteger | PartialCommand | FoldCommand | InvalidCommand;
+export type Tokens = readonly Token[];
+export declare function tokenizeNormalCommand(normalBuffer: string): Tokens;
+//# sourceMappingURL=tokenize-normal-command.d.ts.map

package/dist/input/application/tokenize-normal-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize-normal-command.d.ts","sourceRoot":"","sources":["../../../src/input/application/tokenize-normal-command.ts"],"names":[],"mappings":"AAiCA,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,cAAc,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,aAAa,CAAC;IACzB,eAAe,EACX,eAAe,GACf,oBAAoB,GACpB,MAAM,GACN,QAAQ,GACR,YAAY,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,KAAK,GACb,YAAY,GACZ,cAAc,GACd,cAAc,GACd,WAAW,GACX,cAAc,CAAC;AAEnB,MAAM,MAAM,MAAM,GAAG,SAAS,KAAK,EAAE,CAAC;AAUtC,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAalE"}

package/dist/input/application/tokenize-normal-command.js

@@ -0,0 +1,110 @@
+function createNormalBufferReader(normalBuffer) {
+    return {
+        normalBuffer,
+        position: 0,
+    };
+}
+function peek(reader) {
+    return reader.normalBuffer.at(reader.position);
+}
+function consume(reader) {
+    const character = peek(reader);
+    if (character !== undefined) {
+        reader.position += 1;
+    }
+    return character;
+}
+function isDecimalDigit(character) {
+    if (character === undefined) {
+        return false;
+    }
+    return character >= '0' && character <= '9';
+}
+export function tokenizeNormalCommand(normalBuffer) {
+    const reader = createNormalBufferReader(normalBuffer);
+    const tokens = [];
+    while (peek(reader) !== undefined) {
+        if (isDecimalDigit(peek(reader))) {
+            tokens.push(tokenizeInteger(reader));
+        }
+        else {
+            tokens.push(tokenizeCommand(reader));
+        }
+    }
+    return tokens;
+}
+function tokenizeInteger(reader) {
+    let value = '';
+    while (true) {
+        const character = peek(reader);
+        if (!isDecimalDigit(character)) {
+            break;
+        }
+        consume(reader);
+        value += character;
+    }
+    const parsedValue = Number(value);
+    if (!Number.isSafeInteger(parsedValue)) {
+        return {
+            tokenType: 'invalidInteger',
+            value,
+        };
+    }
+    return {
+        tokenType: 'validInteger',
+        value: parsedValue,
+    };
+}
+function tokenizeCommand(reader) {
+    const character = consume(reader);
+    switch (character) {
+        case 'z':
+            return tokenizeFoldCommand(reader);
+        default:
+            return {
+                tokenType: 'invalidCommand',
+                value: character ?? '',
+            };
+    }
+}
+function tokenizeFoldCommand(reader) {
+    const character = consume(reader);
+    if (character === undefined) {
+        return {
+            tokenType: 'partialCommand',
+            commandType: 'fold',
+        };
+    }
+    switch (character) {
+        case 'f':
+            return {
+                tokenType: 'foldCommand',
+                foldCommandType: 'addToFoldTree',
+            };
+        case 'd':
+            return {
+                tokenType: 'foldCommand',
+                foldCommandType: 'removeFromFoldTree',
+            };
+        case 'c':
+            return {
+                tokenType: 'foldCommand',
+                foldCommandType: 'fold',
+            };
+        case 'o':
+            return {
+                tokenType: 'foldCommand',
+                foldCommandType: 'unfold',
+            };
+        case 'a':
+            return {
+                tokenType: 'foldCommand',
+                foldCommandType: 'toggleFold',
+            };
+        default:
+            return {
+                tokenType: 'invalidCommand',
+                value: `z${character}`,
+            };
+    }
+}

package/dist/{tree-surfer-ui → input}/application/user-input-to-intent.d.ts

@@ -1,9 +1,11 @@
 import { UserInput, InputModeState, Intent } from '../domain/index.js';
 /**
+ * Converts a user input, mode and mode's buffer into an intent.
+ *
  * By design "intent = input + mode + modeState", so it interprets the key
- * inputs depending on the mode and input so far. No context in terms of UI.
+ * inputs depending on the mode and mode's buffer. No other context.
  *
- * @param userInput - the key user input.
+ * @param userInput - the user input pressed now.
  * @param inputModeState - the current mode and the user inputs so far.
  * @returns The user's intent.
  */

package/dist/input/application/user-input-to-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-input-to-intent.d.ts","sourceRoot":"","sources":["../../../src/input/application/user-input-to-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,cAAc,GAC7B,MAAM,GAAG,SAAS,CAQpB"}

package/dist/{tree-surfer-ui → input}/application/user-input-to-intent.js

@@ -1,8 +1,10 @@
 /**
+ * Converts a user input, mode and mode's buffer into an intent.
+ *
  * By design "intent = input + mode + modeState", so it interprets the key
- * inputs depending on the mode and input so far. No context in terms of UI.
+ * inputs depending on the mode and mode's buffer. No other context.
  *
- * @param userInput - the key user input.
+ * @param userInput - the user input pressed now.
  * @param inputModeState - the current mode and the user inputs so far.
  * @returns The user's intent.
  */
@@ -15,6 +17,7 @@ export function userInputToIntent(userInput, inputModeState) {
     }
 }
 function normalUserInputToIntent(userInput, normalBuffer) {
+    // Esc cancels of current key sequence
     if (userInput.userInputType === 'esc') {
         return {
             intentType: 'setNormalBuffer',
@@ -46,10 +49,6 @@ function normalUserInputToIntent(userInput, normalBuffer) {
 function normalCharacterToIntent(character, normalBuffer) {
     if (normalBuffer === '') {
         switch (character) {
-            case 'l':
-                return {
-                    intentType: 'normalRight',
-                };
             case 'h':
                 return {
                     intentType: 'normalLeft',
@@ -62,6 +61,10 @@ function normalCharacterToIntent(character, normalBuffer) {
                 return {
                     intentType: 'normalUp',
                 };
+            case 'l':
+                return {
+                    intentType: 'normalRight',
+                };
             case ':':
                 return {
                     intentType: 'enterCommandLineMode',

package/dist/input/application/user-input-to-intent.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-input-to-intent.test.d.ts","sourceRoot":"","sources":["../../../src/input/application/user-input-to-intent.test.ts"],"names":[],"mappings":""}

package/dist/input/domain/effect.d.ts

@@ -0,0 +1,84 @@
+import type { InputModeState } from './input-mode-state.js';
+import type { SerializableKey, TreeNode } from '../../trees/index.js';
+/**
+ * An effect produced by interpreting an intent against the current state.
+ *
+ * @typeParam Id - The sibling-unique tree-node ID type.
+ * @typeParam Value - Application-owned data stored in each tree node.
+ */
+export type Effect<Id extends SerializableKey, Value> = Readonly<{
+    effectType: 'dispatchEffectAction';
+    action: EffectAction<Id, Value>;
+}> | Readonly<{
+    effectType: 'loadBranchEntries';
+    path: readonly Id[];
+}> | Readonly<{
+    effectType: 'saveView';
+    name: string;
+    overwrite: boolean;
+}> | Readonly<{
+    effectType: 'loadView';
+    name: string;
+}> | Readonly<{
+    effectType: 'emitVisibleLeavesPaths';
+}> | Readonly<{
+    effectType: 'listFolds';
+}> | Readonly<{
+    effectType: 'quit';
+    exitMessage: string;
+}> | Readonly<{
+    effectType: 'setInputState';
+    inputState: InputModeState;
+}> | Readonly<{
+    effectType: 'unrecognizedCommand';
+    commandLine: string;
+}>;
+/**
+ * A user-facing reference to a fold tree.
+ *
+ * Indexes are local to a view and may be reused after deletion. Names are
+ * durable references intended for command-line use.
+ */
+export type FoldTreeReference = Readonly<{
+    foldTreeReferenceType: 'index';
+    index: number;
+}> | Readonly<{
+    foldTreeReferenceType: 'name';
+    name: string;
+}>;
+/**
+ * An action interpreted by the state reducer.
+ *
+ * @typeParam Id - The sibling-unique tree-node ID type.
+ * @typeParam Value - Application-owned data stored in each tree node.
+ */
+export type EffectAction<Id extends SerializableKey, Value> = Readonly<{
+    effectActionType: 'nextEntry';
+}> | Readonly<{
+    effectActionType: 'prevEntry';
+}> | Readonly<{
+    effectActionType: 'setBranchEntries';
+    path: readonly Id[];
+    entries: readonly TreeNode<Id, Value>[] | null;
+}> | Readonly<{
+    effectActionType: 'navigateToParent';
+}> | Readonly<{
+    effectActionType: 'addToFoldTree';
+    foldTree: FoldTreeReference;
+}> | Readonly<{
+    effectActionType: 'removeFromFoldTree';
+    foldTree: FoldTreeReference;
+}> | Readonly<{
+    effectActionType: 'fold';
+    foldTree: FoldTreeReference;
+}> | Readonly<{
+    effectActionType: 'unfold';
+    foldTree: FoldTreeReference;
+}> | Readonly<{
+    effectActionType: 'toggleFold';
+    foldTree: FoldTreeReference;
+}> | Readonly<{
+    effectActionType: 'createFoldTree';
+    name: string;
+}>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/input/domain/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../src/input/domain/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAChD,QAAQ,CAAC;IACP,UAAU,EAAE,sBAAsB,CAAC;IACnC,MAAM,EAAE,YAAY,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;CACjC,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,mBAAmB,CAAC;IAChC,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC;CACrB,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,UAAU,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,UAAU,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,wBAAwB,CAAC;CACtC,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,EAAE,cAAc,CAAC;CAC5B,CAAC,GACF,QAAQ,CAAC;IACP,UAAU,EAAE,qBAAqB,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC,CAAC;AAEP;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GACzB,QAAQ,CAAC;IACP,qBAAqB,EAAE,OAAO,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,GACF,QAAQ,CAAC;IACP,qBAAqB,EAAE,MAAM,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAEP;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IACtD,QAAQ,CAAC;IACP,gBAAgB,EAAE,WAAW,CAAC;CAC/B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,WAAW,CAAC;CAC/B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,kBAAkB,CAAC;IACrC,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,SAAS,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC;CAChD,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,kBAAkB,CAAC;CACtC,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,eAAe,CAAC;IAClC,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,YAAY,CAAC;IAC/B,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAC,GACF,QAAQ,CAAC;IACP,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC"}

package/dist/input/domain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/input/domain/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}

package/dist/input/domain/input-mode-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-mode-state.d.ts","sourceRoot":"","sources":["../../../src/input/domain/input-mode-state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GACtB;IACE,SAAS,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,GACD;IACE,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/input/domain/intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../../src/input/domain/intent.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAE1D,MAAM,MAAM,gBAAgB,GACxB;IACE,UAAU,EAAE,aAAa,CAAC;CAC3B,GACD;IACE,UAAU,EAAE,YAAY,CAAC;CAC1B,GACD;IACE,UAAU,EAAE,YAAY,CAAC;CAC1B,GACD;IACE,UAAU,EAAE,UAAU,CAAC;CACxB,GACD;IACE,UAAU,EAAE,iBAAiB,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN,MAAM,MAAM,iBAAiB,GACzB;IACE,UAAU,EAAE,sBAAsB,CAAC;CACpC,GACD;IACE,UAAU,EAAE,gBAAgB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,UAAU,EAAE,oBAAoB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,UAAU,EAAE,qBAAqB,CAAC;CACnC,CAAC"}