@razdolbai/merls 0.1.0

package/dist/test/cli-contract.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCliContractTest = runCliContractTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+async function runCliContractTest() {
+    const packageJsonPath = node_path_1.default.resolve(process.cwd(), "package.json");
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, "utf8"));
+    strict_1.default.equal(packageJson.bin?.merls, "dist/src/cli.js");
+    const cliPath = node_path_1.default.resolve(__dirname, "../src/cli.js");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [cliPath, "--stdio"], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    const response = new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+            const separator = stdout.indexOf("\r\n\r\n");
+            if (separator === -1) {
+                return;
+            }
+            const header = stdout.slice(0, separator);
+            const match = /Content-Length: (\d+)/i.exec(header);
+            if (!match) {
+                reject(new Error(`Missing Content-Length header in response: ${stdout}`));
+                return;
+            }
+            const length = Number(match[1]);
+            const body = stdout.slice(separator + 4);
+            if (Buffer.byteLength(body, "utf8") < length) {
+                return;
+            }
+            resolve(JSON.parse(body.slice(0, length)));
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            reject(new Error(`CLI exited before initialize response. code=${code}, stderr=${stderr}`));
+        });
+    });
+    child.stdin.write(encodeMessage({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "initialize",
+        params: {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: null
+        }
+    }));
+    try {
+        const message = await response;
+        strict_1.default.equal(message.id, 1);
+        strict_1.default.equal(message.jsonrpc, "2.0");
+        strict_1.default.equal(typeof message.result?.capabilities, "object");
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/coc-config.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCocConfigTest = runCocConfigTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function runCocConfigTest() {
+    const settingsPath = node_path_1.default.resolve(process.cwd(), "examples/coc-settings.json");
+    const settings = JSON.parse(node_fs_1.default.readFileSync(settingsPath, "utf8"));
+    const serverConfig = settings.languageserver?.merls;
+    strict_1.default.equal(serverConfig?.command, "node");
+    strict_1.default.deepEqual(serverConfig?.args, [
+        "C:/Users/alexe/Projects/merls/dist/src/cli.js",
+        "--stdio"
+    ]);
+    strict_1.default.deepEqual(serverConfig?.filetypes, ["asm"]);
+    strict_1.default.deepEqual(serverConfig?.rootPatterns, [".git", "package.json"]);
+}

package/dist/test/completion.test.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCompletionTest = runCompletionTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+function decodeMessages(streamBuffer) {
+    const messages = [];
+    let buffer = streamBuffer;
+    for (;;) {
+        const separator = buffer.indexOf("\r\n\r\n");
+        if (separator === -1) {
+            return { messages, rest: buffer };
+        }
+        const header = buffer.slice(0, separator);
+        const match = /Content-Length: (\d+)/i.exec(header);
+        if (!match) {
+            throw new Error(`Missing Content-Length header: ${header}`);
+        }
+        const length = Number(match[1]);
+        const body = buffer.slice(separator + 4);
+        if (Buffer.byteLength(body, "utf8") < length) {
+            return { messages, rest: buffer };
+        }
+        messages.push(JSON.parse(body.slice(0, length)));
+        buffer = body.slice(length);
+    }
+}
+function positionOf(text, needle) {
+    const index = text.indexOf(needle);
+    strict_1.default.notEqual(index, -1, `expected to find ${needle}`);
+    const prefix = text.slice(0, index);
+    const lines = prefix.split("\n");
+    return {
+        line: lines.length - 1,
+        character: lines.at(-1)?.length ?? 0
+    };
+}
+async function runCompletionTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const mainPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const mainUri = `file://${mainPath.replace(/\\/g, "/")}`;
+    const text = `${node_fs_1.default.readFileSync(mainPath, "utf8")}\n        ld\n        du\n        bpl G`;
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let nextId = 1;
+    const pending = new Map();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        const decoded = decodeMessages(stdout);
+        stdout = decoded.rest;
+        for (const message of decoded.messages) {
+            if (message.id !== undefined) {
+                pending.get(message.id)?.(message);
+                pending.delete(message.id);
+            }
+        }
+    });
+    function sendRequest(method, params) {
+        const id = nextId++;
+        child.stdin.write(encodeMessage({
+            id,
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+        return new Promise((resolve) => {
+            pending.set(id, resolve);
+        });
+    }
+    function sendNotification(method, params) {
+        child.stdin.write(encodeMessage({
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+    }
+    try {
+        await sendRequest("initialize", {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: `file://${node_path_1.default.resolve(process.cwd()).replace(/\\/g, "/")}`
+        });
+        sendNotification("initialized", {});
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: mainUri,
+                languageId: "asm",
+                version: 1,
+                text
+            }
+        });
+        const opcodeResponse = await sendRequest("textDocument/completion", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "        ld")
+        });
+        const opcodeItems = opcodeResponse.result;
+        strict_1.default.equal(opcodeItems.some((item) => item.label === "lda"), true);
+        const directiveResponse = await sendRequest("textDocument/completion", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "        du")
+        });
+        const directiveItems = directiveResponse.result;
+        strict_1.default.equal(directiveItems.some((item) => item.label === "dum"), true);
+        const symbolResponse = await sendRequest("textDocument/completion", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "        bpl G")
+        });
+        const symbolItems = symbolResponse.result;
+        strict_1.default.equal(symbolItems.some((item) => item.label === "GetKey"), true);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/definition-references.test.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDefinitionReferencesTest = runDefinitionReferencesTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+function decodeMessages(streamBuffer) {
+    const messages = [];
+    let buffer = streamBuffer;
+    for (;;) {
+        const separator = buffer.indexOf("\r\n\r\n");
+        if (separator === -1) {
+            return { messages, rest: buffer };
+        }
+        const header = buffer.slice(0, separator);
+        const match = /Content-Length: (\d+)/i.exec(header);
+        if (!match) {
+            throw new Error(`Missing Content-Length header: ${header}`);
+        }
+        const length = Number(match[1]);
+        const body = buffer.slice(separator + 4);
+        if (Buffer.byteLength(body, "utf8") < length) {
+            return { messages, rest: buffer };
+        }
+        messages.push(JSON.parse(body.slice(0, length)));
+        buffer = body.slice(length);
+    }
+}
+function positionOf(text, needle) {
+    const index = text.indexOf(needle);
+    strict_1.default.notEqual(index, -1, `expected to find ${needle}`);
+    const prefix = text.slice(0, index);
+    const lines = prefix.split("\n");
+    return {
+        line: lines.length - 1,
+        character: lines.at(-1)?.length ?? 0
+    };
+}
+async function runDefinitionReferencesTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const mainPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const mainUri = `file://${mainPath.replace(/\\/g, "/")}`;
+    const text = node_fs_1.default.readFileSync(mainPath, "utf8");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let nextId = 1;
+    const pending = new Map();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        const decoded = decodeMessages(stdout);
+        stdout = decoded.rest;
+        for (const message of decoded.messages) {
+            if (message.id !== undefined) {
+                pending.get(message.id)?.(message);
+                pending.delete(message.id);
+            }
+        }
+    });
+    function sendRequest(method, params) {
+        const id = nextId++;
+        child.stdin.write(encodeMessage({
+            id,
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+        return new Promise((resolve) => {
+            pending.set(id, resolve);
+        });
+    }
+    function sendNotification(method, params) {
+        child.stdin.write(encodeMessage({
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+    }
+    try {
+        await sendRequest("initialize", {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: `file://${node_path_1.default.resolve(process.cwd()).replace(/\\/g, "/")}`
+        });
+        sendNotification("initialized", {});
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: mainUri,
+                languageId: "asm",
+                version: 1,
+                text
+            }
+        });
+        const definitionResponse = await sendRequest("textDocument/definition", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "bpl GetKey")
+        });
+        const definition = definitionResponse.result;
+        strict_1.default.equal(definition.uri, mainUri);
+        strict_1.default.equal(definition.range.start.line, 69);
+        const referencesResponse = await sendRequest("textDocument/references", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "GetKey  ldx"),
+            context: {
+                includeDeclaration: true
+            }
+        });
+        const references = referencesResponse.result;
+        strict_1.default.equal(Array.isArray(references), true);
+        strict_1.default.equal(references.some((reference) => reference.uri === mainUri && reference.range.start.line === 69), true);
+        strict_1.default.equal(references.some((reference) => reference.uri === mainUri && reference.range.start.line === 70), true);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/diagnostics.test.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDiagnosticsTest = runDiagnosticsTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const document_1 = require("../src/asm/document");
+const diagnostics_1 = require("../src/asm/diagnostics");
+function runDiagnosticsTest() {
+    const duplicateSource = [
+        "dup     equ 1",
+        "        lda missing",
+        "dup     equ 2",
+        "        adc (",
+        "        dsk ../build/WORLD",
+        "        typ BIN",
+        "        typ BLAH",
+        "        end BLAH"
+    ].join("\n");
+    const bankOpsPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/invalid/65816-bank-ops.asm");
+    const longPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/invalid/65816-long-addressing.asm");
+    const diagnostics = (0, diagnostics_1.collectWorkspaceDiagnostics)([
+        {
+            filePath: "<memory>",
+            document: (0, document_1.parseDocument)(duplicateSource)
+        },
+        {
+            filePath: bankOpsPath,
+            document: (0, document_1.parseDocument)(node_fs_1.default.readFileSync(bankOpsPath, "utf8"))
+        },
+        {
+            filePath: longPath,
+            document: (0, document_1.parseDocument)(node_fs_1.default.readFileSync(longPath, "utf8"))
+        }
+    ]);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "duplicate-symbol" &&
+        diagnostic.line === 2), true);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "unresolved-reference" &&
+        diagnostic.line === 1 &&
+        diagnostic.message.includes("missing")), true);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "unresolved-reference" &&
+        (diagnostic.line === 4 || diagnostic.line === 5)), false);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "unresolved-reference" &&
+        diagnostic.line === 6 &&
+        diagnostic.message.includes("BLAH")), true);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "malformed-line" &&
+        diagnostic.line === 3), true);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "malformed-line" &&
+        diagnostic.line === 7 &&
+        diagnostic.message === "unexpected operand for end"), true);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === bankOpsPath &&
+        diagnostic.code === "unsupported-65816" &&
+        diagnostic.message.includes("mvn")), true);
+    strict_1.default.equal(diagnostics.some((diagnostic) => diagnostic.filePath === longPath &&
+        diagnostic.code === "unsupported-65816" &&
+        diagnostic.message.includes("^")), true);
+}

package/dist/test/document-model.test.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDocumentModelTest = runDocumentModelTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const document_1 = require("../src/asm/document");
+function runDocumentModelTest() {
+    const source = [
+        "TEXT    =   $FB39",
+        "        adc (",
+        "        lda #1",
+        "",
+        "; trailing note"
+    ].join("\n");
+    const document = (0, document_1.parseDocument)(source);
+    strict_1.default.equal(document.lines.length, 5);
+    strict_1.default.equal(document.errors.length, 1);
+    strict_1.default.deepEqual(document.errors[0], {
+        line: 1,
+        text: "        adc (",
+        message: "expected expression token"
+    });
+    strict_1.default.equal(document.lines[0]?.node.shape, "equate");
+    strict_1.default.equal(document.lines[1]?.node.shape, "malformed");
+    strict_1.default.equal(document.lines[2]?.node.shape, "instruction");
+    strict_1.default.equal(document.lines[3]?.node.shape, "empty");
+    strict_1.default.equal(document.lines[4]?.node.shape, "commentOnly");
+}

package/dist/test/document-symbol.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDocumentSymbolTest = runDocumentSymbolTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+function decodeMessages(streamBuffer) {
+    const messages = [];
+    let buffer = streamBuffer;
+    for (;;) {
+        const separator = buffer.indexOf("\r\n\r\n");
+        if (separator === -1) {
+            return { messages, rest: buffer };
+        }
+        const header = buffer.slice(0, separator);
+        const match = /Content-Length: (\d+)/i.exec(header);
+        if (!match) {
+            throw new Error(`Missing Content-Length header: ${header}`);
+        }
+        const length = Number(match[1]);
+        const body = buffer.slice(separator + 4);
+        if (Buffer.byteLength(body, "utf8") < length) {
+            return { messages, rest: buffer };
+        }
+        messages.push(JSON.parse(body.slice(0, length)));
+        buffer = body.slice(length);
+    }
+}
+async function runDocumentSymbolTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const fixturePath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const uri = `file://${fixturePath.replace(/\\/g, "/")}`;
+    const text = node_fs_1.default.readFileSync(fixturePath, "utf8");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let nextId = 1;
+    const pending = new Map();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        const decoded = decodeMessages(stdout);
+        stdout = decoded.rest;
+        for (const message of decoded.messages) {
+            if (message.id !== undefined) {
+                pending.get(message.id)?.(message);
+                pending.delete(message.id);
+            }
+        }
+    });
+    function sendRequest(method, params) {
+        const id = nextId++;
+        child.stdin.write(encodeMessage({
+            id,
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+        return new Promise((resolve) => {
+            pending.set(id, resolve);
+        });
+    }
+    function sendNotification(method, params) {
+        child.stdin.write(encodeMessage({
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+    }
+    try {
+        const initialize = await sendRequest("initialize", {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: null
+        });
+        strict_1.default.equal(initialize.id, 1);
+        sendNotification("initialized", {});
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri,
+                languageId: "asm",
+                version: 1,
+                text
+            }
+        });
+        const response = await sendRequest("textDocument/documentSymbol", {
+            textDocument: { uri }
+        });
+        const symbols = response.result;
+        strict_1.default.equal(Array.isArray(symbols), true);
+        strict_1.default.equal(symbols.some((symbol) => symbol.name === "TEXT" && symbol.kind === 13), true);
+        strict_1.default.equal(symbols.some((symbol) => symbol.name === "TEST_START" && symbol.kind === 6), true);
+        strict_1.default.equal(symbols.some((symbol) => symbol.name === "dum0" && symbol.kind === 8), true);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/expression.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runExpressionTest = runExpressionTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const lexer_1 = require("../src/asm/lexer");
+const expression_1 = require("../src/asm/expression");
+function summarizeExpression(expression) {
+    switch (expression.kind) {
+        case "binary":
+            return {
+                kind: expression.kind,
+                operator: expression.operator,
+                left: summarizeExpression(expression.left),
+                right: summarizeExpression(expression.right)
+            };
+        case "modifier":
+            return {
+                kind: expression.kind,
+                operator: expression.operator,
+                expression: summarizeExpression(expression.expression)
+            };
+        default:
+            return {
+                kind: expression.kind,
+                value: expression.value
+            };
+    }
+}
+function operandTokens(sourceLine) {
+    const line = (0, lexer_1.lexSource)(sourceLine).lines[0];
+    strict_1.default.ok(line, "expected a lexed line");
+    return line.tokens.slice(1);
+}
+function runExpressionTest() {
+    const arithmeticTokens = (0, lexer_1.lexSource)("_tmp+dum1+1").lines[0]?.tokens ?? [];
+    const arithmetic = (0, expression_1.parseExpression)(arithmeticTokens);
+    strict_1.default.equal(arithmetic.nextTokenIndex, arithmeticTokens.length);
+    strict_1.default.deepEqual(summarizeExpression(arithmetic.expression), {
+        kind: "binary",
+        operator: "+",
+        left: {
+            kind: "binary",
+            operator: "+",
+            left: { kind: "identifier", value: "_tmp" },
+            right: { kind: "identifier", value: "dum1" }
+        },
+        right: { kind: "numericLiteral", value: "1" }
+    });
+    const numericForms = ["$10", "%1010", "42"];
+    for (const numericForm of numericForms) {
+        const tokens = (0, lexer_1.lexSource)(numericForm).lines[0]?.tokens ?? [];
+        const parsed = (0, expression_1.parseExpression)(tokens);
+        strict_1.default.deepEqual(summarizeExpression(parsed.expression), {
+            kind: "numericLiteral",
+            value: numericForm
+        });
+    }
+    const modifierTokens = (0, lexer_1.lexSource)("<value+1").lines[0]?.tokens ?? [];
+    const modifier = (0, expression_1.parseExpression)(modifierTokens);
+    strict_1.default.deepEqual(summarizeExpression(modifier.expression), {
+        kind: "binary",
+        operator: "+",
+        left: {
+            kind: "modifier",
+            operator: "<",
+            expression: { kind: "identifier", value: "value" }
+        },
+        right: { kind: "numericLiteral", value: "1" }
+    });
+    const immediateOperand = (0, expression_1.parseOperand)(operandTokens("        ldx #_LFT"));
+    strict_1.default.equal(immediateOperand.operand.immediate, true);
+    strict_1.default.equal(immediateOperand.operand.indirect, false);
+    strict_1.default.equal(immediateOperand.operand.indexRegister, null);
+    strict_1.default.deepEqual(summarizeExpression(immediateOperand.operand.expression), {
+        kind: "identifier",
+        value: "_LFT"
+    });
+    const indexedOperand = (0, expression_1.parseOperand)(operandTokens("        sta TSTADDR+_num1+dum0,x"));
+    strict_1.default.equal(indexedOperand.operand.immediate, false);
+    strict_1.default.equal(indexedOperand.operand.indirect, false);
+    strict_1.default.equal(indexedOperand.operand.indexRegister, "x");
+    const indirectIndexedOperand = (0, expression_1.parseOperand)(operandTokens("        adc (_tmp+dum1+1,x)"));
+    strict_1.default.equal(indirectIndexedOperand.operand.immediate, false);
+    strict_1.default.equal(indirectIndexedOperand.operand.indirect, true);
+    strict_1.default.equal(indirectIndexedOperand.operand.indexRegister, "x");
+    strict_1.default.deepEqual(summarizeExpression(indirectIndexedOperand.operand.expression), {
+        kind: "binary",
+        operator: "+",
+        left: {
+            kind: "binary",
+            operator: "+",
+            left: { kind: "identifier", value: "_tmp" },
+            right: { kind: "identifier", value: "dum1" }
+        },
+        right: { kind: "numericLiteral", value: "1" }
+    });
+}