@jhlagado/azm 0.1.0

package/dist/src/formats/writeAsm80.js

@@ -0,0 +1,86 @@
+import { formatLoweredImmExpr, formatLoweredNumber } from '../lowering/loweredFormat.js';
+const toHexByte = (value) => value.toString(16).toUpperCase().padStart(2, '0');
+function formatEaExpr(expr) {
+    switch (expr.kind) {
+        case 'name':
+            return expr.name;
+        case 'imm':
+            return formatLoweredImmExpr(expr.expr);
+        case 'add':
+            return `${formatEaExpr(expr.base)}+${formatLoweredImmExpr(expr.offset)}`;
+        case 'sub':
+            return `${formatEaExpr(expr.base)}-${formatLoweredImmExpr(expr.offset)}`;
+        case 'field':
+        case 'index':
+        case 'layoutCast':
+            throw new Error(`ASM80 emitter cannot format lowered EA kind "${expr.kind}".`);
+    }
+}
+function formatOperand(op) {
+    switch (op.kind) {
+        case 'reg':
+            return op.name.toLowerCase();
+        case 'imm':
+            return formatLoweredImmExpr(op.expr);
+        case 'ea':
+            return formatEaExpr(op.expr);
+        case 'mem':
+            return `(${formatEaExpr(op.expr)})`;
+        case 'portImm8':
+            return `(${formatLoweredImmExpr(op.expr)})`;
+        case 'portC':
+            return '(c)';
+    }
+}
+function formatItem(item) {
+    switch (item.kind) {
+        case 'label':
+            return [`${item.name}:`];
+        case 'const':
+            return [`${item.name} EQU ${formatLoweredImmExpr(item.value)}`];
+        case 'comment':
+            if (!item.text.trim())
+                return [];
+            if (item.origin === 'user')
+                return [`; ${item.text}`];
+            return [`; AZM: ${item.text}`];
+        case 'db':
+            return [`DB ${item.values.map(formatLoweredImmExpr).join(', ')}`];
+        case 'dw':
+            return [`DW ${item.values.map(formatLoweredImmExpr).join(', ')}`];
+        case 'ds':
+            return [
+                item.fill === undefined
+                    ? `DS ${formatLoweredImmExpr(item.size)}`
+                    : `DS ${formatLoweredImmExpr(item.size)}, ${formatLoweredImmExpr(item.fill)}`,
+            ];
+        case 'instr': {
+            if (item.head === '@raw') {
+                const bytes = item.bytes ?? [];
+                if (bytes.length === 0)
+                    return [];
+                const parts = bytes.map((b) => `$${toHexByte(b & 0xff)}`);
+                return [`DB ${parts.join(', ')}`];
+            }
+            const head = item.head.toLowerCase();
+            const ops = item.operands.map(formatOperand);
+            return [ops.length ? `${head} ${ops.join(', ')}` : head];
+        }
+    }
+}
+/**
+ * Emit ASM80-compatible source from a placed lowered assembly program.
+ */
+export function writeAsm80(program, opts) {
+    const lineEnding = opts?.lineEnding ?? '\n';
+    const lines = [];
+    lines.push('; AZM lowered ASM80 output');
+    for (const block of program.blocks) {
+        lines.push('');
+        lines.push(`ORG ${formatLoweredNumber(block.origin)}`);
+        for (const item of block.items) {
+            lines.push(...formatItem(item));
+        }
+    }
+    return { kind: 'asm80', text: lines.join(lineEnding) + lineEnding };
+}

package/dist/src/formats/writeBin.d.ts

@@ -0,0 +1,7 @@
+import type { BinArtifact, EmittedByteMap, SymbolEntry, WriteBinOptions } from './types.js';
+/**
+ * Create a flat binary artifact from an emitted address->byte map.
+ *
+ * Bytes are emitted for the computed written range; unwritten addresses inside the range are `0x00`.
+ */
+export declare function writeBin(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteBinOptions): BinArtifact;

package/dist/src/formats/writeBin.js

@@ -0,0 +1,23 @@
+import { getWrittenRange } from './range.js';
+const BINFROM_SYMBOL_NAME = '__azm_binfrom';
+const BINTO_SYMBOL_NAME = '__azm_binto';
+/**
+ * Create a flat binary artifact from an emitted address->byte map.
+ *
+ * Bytes are emitted for the computed written range; unwritten addresses inside the range are `0x00`.
+ */
+export function writeBin(map, symbols, opts) {
+    const { start: writtenStart, end } = getWrittenRange(map);
+    const optionStart = opts?.binFrom ??
+        opts?.startAddress;
+    const symbolStart = symbols.find((symbol) => symbol.kind === 'constant' && symbol.name === BINFROM_SYMBOL_NAME);
+    const symbolEnd = symbols.find((symbol) => symbol.kind === 'constant' && symbol.name === BINTO_SYMBOL_NAME);
+    const start = optionStart ?? (symbolStart?.kind === 'constant' ? symbolStart.value : writtenStart);
+    const exclusiveEnd = symbolEnd?.kind === 'constant' ? symbolEnd.value + 1 : end;
+    const out = new Uint8Array(Math.max(0, exclusiveEnd - start));
+    for (let i = 0; i < out.length; i++) {
+        const addr = start + i;
+        out[i] = map.bytes.get(addr) ?? 0;
+    }
+    return { kind: 'bin', bytes: out };
+}

package/dist/src/formats/writeD8m.d.ts

@@ -0,0 +1,9 @@
+import type { D8mArtifact, EmittedByteMap, SymbolEntry, WriteD8mOptions } from './types.js';
+/**
+ * Create a minimal D8 Debug Map (D8M) v1 JSON artifact.
+ *
+ * Implementation note:
+ * - Emits baseline contiguous written segments plus optional source-attributed per-file segments
+ *   when provided by lowering.
+ */
+export declare function writeD8m(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteD8mOptions): D8mArtifact;

package/dist/src/formats/writeD8m.js

@@ -0,0 +1,239 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+import { getWrittenRange, getWrittenSegments } from './range.js';
+function normalizeD8mPath(file, rootDir) {
+    const withSlashes = file.replace(/\\/g, '/');
+    if (!rootDir)
+        return withSlashes;
+    const absFile = resolve(file);
+    const absRoot = resolve(rootDir);
+    const rel = relative(absRoot, absFile);
+    if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
+        return absFile.replace(/\\/g, '/');
+    }
+    return rel.replace(/\\/g, '/');
+}
+function toSerializedSymbol(symbol) {
+    if (symbol.kind === 'constant') {
+        return {
+            name: symbol.name,
+            kind: 'constant',
+            value: symbol.value,
+            ...(symbol.file !== undefined ? { file: symbol.file } : {}),
+            ...(symbol.line !== undefined ? { line: symbol.line } : {}),
+            ...(symbol.scope !== undefined ? { scope: symbol.scope } : {}),
+        };
+    }
+    return {
+        name: symbol.name,
+        kind: symbol.kind,
+        address: symbol.address,
+        ...(symbol.file !== undefined ? { file: symbol.file } : {}),
+        ...(symbol.line !== undefined ? { line: symbol.line } : {}),
+        ...(symbol.scope !== undefined ? { scope: symbol.scope } : {}),
+        ...(symbol.size !== undefined ? { size: symbol.size } : {}),
+    };
+}
+function compareSerializedSymbols(a, b) {
+    const aClass = a.kind === 'constant' ? 1 : 0;
+    const bClass = b.kind === 'constant' ? 1 : 0;
+    if (aClass !== bClass)
+        return aClass - bClass;
+    const aAddress = a.kind === 'constant' ? a.value & 0xffff : a.address;
+    const bAddress = b.kind === 'constant' ? b.value & 0xffff : b.address;
+    if (aAddress !== bAddress)
+        return aAddress - bAddress;
+    const nameCmp = a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+    if (nameCmp !== 0)
+        return nameCmp;
+    const kindCmp = a.kind.localeCompare(b.kind);
+    if (kindCmp !== 0)
+        return kindCmp;
+    const fileCmp = (a.file ?? '').localeCompare(b.file ?? '');
+    if (fileCmp !== 0)
+        return fileCmp;
+    const lineCmp = (a.line ?? 0) - (b.line ?? 0);
+    if (lineCmp !== 0)
+        return lineCmp;
+    if (a.kind === 'constant' && b.kind === 'constant') {
+        return a.value - b.value;
+    }
+    const aSize = a.size ?? 0;
+    const bSize = b.size ?? 0;
+    return aSize - bSize;
+}
+function compareFileSymbols(a, b) {
+    const withFile = (symbol) => ({
+        ...symbol,
+    });
+    return compareSerializedSymbols(withFile(a), withFile(b));
+}
+function compareD8mSegments(a, b) {
+    if (a.start !== b.start)
+        return a.start - b.start;
+    if (a.end !== b.end)
+        return a.end - b.end;
+    if (a.lstLine !== b.lstLine)
+        return a.lstLine - b.lstLine;
+    const aLine = a.line ?? 0;
+    const bLine = b.line ?? 0;
+    if (aLine !== bLine)
+        return aLine - bLine;
+    const kindCmp = a.kind.localeCompare(b.kind);
+    if (kindCmp !== 0)
+        return kindCmp;
+    return a.confidence.localeCompare(b.confidence);
+}
+function rangesOverlap(a, b) {
+    return a.start < b.end && b.start < a.end;
+}
+function hasOverlappingSourceSegment(sourceSegmentsByFile, file, range) {
+    return (sourceSegmentsByFile.get(file) ?? []).some((segment) => rangesOverlap({ start: segment.start, end: segment.end }, range));
+}
+/**
+ * Create a minimal D8 Debug Map (D8M) v1 JSON artifact.
+ *
+ * Implementation note:
+ * - Emits baseline contiguous written segments plus optional source-attributed per-file segments
+ *   when provided by lowering.
+ */
+export function writeD8m(map, symbols, opts) {
+    const { start, end } = getWrittenRange(map);
+    const writtenSegments = getWrittenSegments(map);
+    const segments = writtenSegments.length > 0
+        ? writtenSegments
+        : start < end
+            ? [{ start, end }]
+            : [{ start: 0, end: 0 }];
+    const normalizedSymbols = symbols.map((s) => ({
+        ...s,
+        ...(s.file !== undefined ? { file: normalizeD8mPath(s.file, opts?.rootDir) } : {}),
+    }));
+    const normalizedSourceSegments = (map.sourceSegments ?? [])
+        .filter((segment) => segment.end > segment.start)
+        .map((segment) => ({
+        ...segment,
+        file: normalizeD8mPath(segment.file, opts?.rootDir),
+    }));
+    const fileSet = new Set(normalizedSymbols
+        .map((s) => s.file)
+        .filter((f) => typeof f === 'string' && f.length > 0));
+    for (const segment of normalizedSourceSegments) {
+        if (segment.file.length > 0)
+            fileSet.add(segment.file);
+    }
+    const fileList = Array.from(fileSet).sort((a, b) => a.localeCompare(b));
+    const serializedSymbols = normalizedSymbols
+        .map(toSerializedSymbol)
+        .sort(compareSerializedSymbols);
+    const fileEntries = new Map();
+    const ensureFileEntry = (path) => {
+        let entry = fileEntries.get(path);
+        if (!entry) {
+            entry = { symbols: [], segments: [] };
+            fileEntries.set(path, entry);
+        }
+        return entry;
+    };
+    for (const symbol of serializedSymbols) {
+        const key = symbol.file ?? '';
+        const entry = ensureFileEntry(key);
+        const { file: _file, ...withoutFile } = symbol;
+        entry.symbols.push(withoutFile);
+    }
+    for (const segment of normalizedSourceSegments) {
+        ensureFileEntry(segment.file).segments.push({
+            start: segment.start,
+            end: segment.end,
+            lstLine: segment.line,
+            line: segment.line,
+            kind: segment.kind,
+            confidence: segment.confidence,
+        });
+    }
+    const sourceSegmentsByFile = new Map();
+    for (const segment of normalizedSourceSegments) {
+        const entries = sourceSegmentsByFile.get(segment.file);
+        if (entries) {
+            entries.push(segment);
+        }
+        else {
+            sourceSegmentsByFile.set(segment.file, [segment]);
+        }
+    }
+    const symbolRangesByFile = new Map();
+    for (const symbol of serializedSymbols) {
+        if (symbol.kind === 'constant' || symbol.file === undefined)
+            continue;
+        const spanSize = symbol.size !== undefined && symbol.size > 0 ? symbol.size : 1;
+        const range = {
+            start: symbol.address,
+            end: Math.min(0x10000, symbol.address + spanSize),
+        };
+        const currentRanges = symbolRangesByFile.get(symbol.file);
+        if (currentRanges) {
+            currentRanges.push(range);
+        }
+        else {
+            symbolRangesByFile.set(symbol.file, [range]);
+        }
+    }
+    for (const ranges of symbolRangesByFile.values()) {
+        ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+    }
+    for (const segment of segments) {
+        const segmentRange = { start: segment.start, end: segment.end };
+        const fileKeys = Array.from(symbolRangesByFile.entries())
+            .filter(([, ranges]) => ranges.some((range) => rangesOverlap(range, segmentRange)))
+            .map(([path]) => path)
+            .sort((a, b) => a.localeCompare(b));
+        const targets = fileKeys.length > 0 ? fileKeys : [fileList[0] ?? ''];
+        for (const target of targets) {
+            if (hasOverlappingSourceSegment(sourceSegmentsByFile, target, segmentRange))
+                continue;
+            ensureFileEntry(target).segments.push({
+                start: segment.start,
+                end: segment.end,
+                // Synthetic file-attribution segments have no exact source line; use a valid fallback.
+                lstLine: 1,
+                kind: 'unknown',
+                confidence: 'low',
+            });
+        }
+    }
+    for (const entry of fileEntries.values()) {
+        entry.symbols.sort(compareFileSymbols);
+        entry.segments.sort(compareD8mSegments);
+    }
+    const files = Object.fromEntries(Array.from(fileEntries.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([path, entry]) => [
+        path,
+        {
+            ...(entry.segments.length > 0 ? { segments: entry.segments } : {}),
+            ...(entry.symbols.length > 0 ? { symbols: entry.symbols } : {}),
+        },
+    ]));
+    const json = {
+        format: 'd8-debug-map',
+        version: 1,
+        arch: 'z80',
+        addressWidth: 16,
+        endianness: 'little',
+        files,
+        segments,
+        ...(fileList.length > 0 ? { fileList } : {}),
+        symbols: serializedSymbols,
+        ...(opts?.entrySymbol !== undefined || opts?.entryAddress !== undefined
+            ? {
+                generator: {
+                    tool: 'azm',
+                    ...(opts.entrySymbol !== undefined ? { entrySymbol: opts.entrySymbol } : {}),
+                    ...(opts.entryAddress !== undefined
+                        ? { entryAddress: opts.entryAddress & 0xffff }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+    return { kind: 'd8m', json };
+}

package/dist/src/formats/writeHex.d.ts

@@ -0,0 +1,9 @@
+import type { EmittedByteMap, HexArtifact, SymbolEntry, WriteHexOptions } from './types.js';
+/**
+ * Create an Intel HEX artifact from an emitted address->byte map.
+ *
+ * PR1 implementation note:
+ * - Emits only type-00 data records and a type-01 EOF record.
+ * - Does not emit extended address records (assumes 16-bit address space).
+ */
+export declare function writeHex(map: EmittedByteMap, _symbols: SymbolEntry[], opts?: WriteHexOptions): HexArtifact;

package/dist/src/formats/writeHex.js

@@ -0,0 +1,39 @@
+import { getWrittenSegments } from './range.js';
+function toHexByte(n) {
+    return (n & 0xff).toString(16).toUpperCase().padStart(2, '0');
+}
+function checksum(bytes) {
+    const sum = bytes.reduce((acc, b) => acc + (b & 0xff), 0) & 0xff;
+    return ((0x100 - sum) & 0xff) >>> 0;
+}
+/**
+ * Create an Intel HEX artifact from an emitted address->byte map.
+ *
+ * PR1 implementation note:
+ * - Emits only type-00 data records and a type-01 EOF record.
+ * - Does not emit extended address records (assumes 16-bit address space).
+ */
+export function writeHex(map, _symbols, opts) {
+    const lineEnding = opts?.lineEnding ?? '\n';
+    const segments = getWrittenSegments(map);
+    const recordSize = 16;
+    const lines = [];
+    for (const segment of segments) {
+        for (let addr = segment.start; addr < segment.end; addr += recordSize) {
+            const count = Math.min(recordSize, segment.end - addr);
+            const data = [];
+            for (let i = 0; i < count; i++) {
+                data.push(map.bytes.get(addr + i) ?? 0);
+            }
+            const hi = (addr >> 8) & 0xff;
+            const lo = addr & 0xff;
+            const recType = 0x00;
+            const header = [count, hi, lo, recType, ...data];
+            const cs = checksum(header);
+            const hexData = data.map(toHexByte).join('');
+            lines.push(`:${toHexByte(count)}${toHexByte(hi)}${toHexByte(lo)}00${hexData}${toHexByte(cs)}`);
+        }
+    }
+    lines.push(':00000001FF');
+    return { kind: 'hex', text: lines.join(lineEnding) + lineEnding };
+}

package/dist/src/formats/writeListing.d.ts

@@ -0,0 +1,8 @@
+import type { EmittedByteMap, ListingArtifact, SymbolEntry, WriteListingOptions } from './types.js';
+/**
+ * Create a deterministic `.lst` listing artifact.
+ *
+ * Current implementation is a stable byte dump + symbol table. It does not yet include per-instruction
+ * source mapping; D8M should be used for debuggers.
+ */
+export declare function writeListing(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteListingOptions): ListingArtifact;

package/dist/src/formats/writeListing.js

@@ -0,0 +1,83 @@
+import { getWrittenRange, getWrittenSegments } from './range.js';
+function toHexByte(n) {
+    return (n & 0xff).toString(16).toUpperCase().padStart(2, '0');
+}
+function toHexWord(n) {
+    return (n & 0xffff).toString(16).toUpperCase().padStart(4, '0');
+}
+function toAsciiByte(n) {
+    const v = n & 0xff;
+    return v >= 0x20 && v <= 0x7e ? String.fromCharCode(v) : '.';
+}
+function formatSymbol(s) {
+    if (s.kind === 'constant') {
+        const value = s.value & 0xffff;
+        return `${s.kind} ${s.name} = $${toHexWord(value)} (${s.value})`;
+    }
+    return `${s.kind} ${s.name} = $${toHexWord(s.address)}`;
+}
+function sortSymbols(a, b) {
+    const aKey = a.kind === 'constant'
+        ? `1\n${toHexWord(a.value & 0xffff)}\n${a.name.toLowerCase()}`
+        : `0\n${toHexWord(a.address)}\n${a.name.toLowerCase()}`;
+    const bKey = b.kind === 'constant'
+        ? `1\n${toHexWord(b.value & 0xffff)}\n${b.name.toLowerCase()}`
+        : `0\n${toHexWord(b.address)}\n${b.name.toLowerCase()}`;
+    return aKey.localeCompare(bKey);
+}
+/**
+ * Create a deterministic `.lst` listing artifact.
+ *
+ * Current implementation is a stable byte dump + symbol table. It does not yet include per-instruction
+ * source mapping; D8M should be used for debuggers.
+ */
+export function writeListing(map, symbols, opts) {
+    const lineEnding = opts?.lineEnding ?? '\n';
+    const bytesPerLine = opts?.bytesPerLine ?? 16;
+    const { start, end } = getWrittenRange(map);
+    const segments = getWrittenSegments(map);
+    const lines = [];
+    lines.push('; AZM listing');
+    lines.push(`; range: $${toHexWord(start)}..$${toHexWord(end)} (end exclusive)`);
+    lines.push('');
+    const lineBaseSet = new Set();
+    for (const segment of segments) {
+        const first = segment.start - (segment.start % bytesPerLine);
+        const last = segment.end - 1 - ((segment.end - 1) % bytesPerLine);
+        for (let addr = first; addr <= last; addr += bytesPerLine) {
+            lineBaseSet.add(addr);
+        }
+    }
+    const lineBases = [...lineBaseSet].sort((a, b) => a - b);
+    let previousBase;
+    for (const addr of lineBases) {
+        if (previousBase !== undefined && addr > previousBase + bytesPerLine) {
+            const gapStart = previousBase + bytesPerLine;
+            const gapEndInclusive = addr - 1;
+            const gapLineCount = Math.ceil((addr - gapStart) / bytesPerLine);
+            lines.push(`; ... gap $${toHexWord(gapStart)}..$${toHexWord(gapEndInclusive)} (${gapLineCount} lines)`);
+        }
+        const count = Math.min(bytesPerLine, end - addr);
+        const hexBytes = [];
+        const asciiBytes = [];
+        for (let i = 0; i < count; i++) {
+            const byte = map.bytes.get(addr + i);
+            if (byte === undefined) {
+                hexBytes.push('..');
+                asciiBytes.push(' ');
+                continue;
+            }
+            hexBytes.push(toHexByte(byte));
+            asciiBytes.push(toAsciiByte(byte));
+        }
+        const paddedHex = hexBytes.join(' ').padEnd(bytesPerLine * 3 - 1, ' ');
+        lines.push(`${toHexWord(addr)}: ${paddedHex}  |${asciiBytes.join('')}|`);
+        previousBase = addr;
+    }
+    lines.push('');
+    lines.push('; symbols:');
+    for (const s of [...symbols].sort(sortSymbols)) {
+        lines.push(`; ${formatSymbol(s)}`);
+    }
+    return { kind: 'lst', text: lines.join(lineEnding) + lineEnding };
+}

package/dist/src/frontend/asm80/asmLine.d.ts

@@ -0,0 +1,39 @@
+import type { DirectiveAliasPolicy } from '../directiveAliases.js';
+type AsmLine = {
+    kind: 'label';
+    name: string;
+} | {
+    kind: 'equ';
+    name: string;
+    exprText: string;
+} | {
+    kind: 'org';
+    exprText: string;
+} | {
+    kind: 'align';
+    exprText: string;
+} | {
+    kind: 'binfrom';
+    exprText: string;
+} | {
+    kind: 'binto';
+    exprText: string;
+} | {
+    kind: 'end';
+} | {
+    kind: 'unsupportedDirective';
+    label?: string;
+    directive: string;
+} | {
+    kind: 'rawData';
+    label?: string;
+    directive: 'db' | 'dw' | 'ds' | 'cstr' | 'pstr' | 'istr';
+    valuesText: string;
+} | {
+    kind: 'instruction';
+    label?: string;
+    head: string;
+    operandText: string;
+};
+export declare function parseAsmLine(_filePath: string, text: string, _lineNo: number, _lineStartOffset: number, aliasPolicy?: DirectiveAliasPolicy): AsmLine | undefined;
+export {};

package/dist/src/frontend/asm80/asmLine.js

@@ -0,0 +1,89 @@
+import { resolveDirectiveAlias } from '../directiveAliases.js';
+import { advanceAsmQuoteScan, createAsmQuoteScanState } from './quoteScan.js';
+export function parseAsmLine(_filePath, text, _lineNo, _lineStartOffset, aliasPolicy) {
+    const stripped = stripAsm80Comment(text).trim();
+    if (stripped.length === 0)
+        return undefined;
+    const colonLabel = /^(@?[A-Za-z_][A-Za-z0-9_]*|\.[A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(stripped);
+    if (colonLabel) {
+        const label = colonLabel[1];
+        const rest = colonLabel[2].trim();
+        if (rest.length === 0)
+            return { kind: 'label', name: label };
+        return parseStatement(rest, aliasPolicy, label);
+    }
+    const equLabel = /^([A-Za-z_][A-Za-z0-9_]*)\s+([.]?[A-Za-z][A-Za-z0-9_]*)\b\s*(.+)$/i.exec(stripped);
+    if (equLabel && resolveDirectiveAlias(equLabel[2], aliasPolicy) === '.equ') {
+        return { kind: 'equ', name: equLabel[1], exprText: equLabel[3].trim() };
+    }
+    return parseStatement(stripped, aliasPolicy);
+}
+function stripAsm80Comment(text) {
+    const quoteState = createAsmQuoteScanState();
+    for (let i = 0; i < text.length; i++) {
+        if (advanceAsmQuoteScan(text, i, quoteState, {
+            singleQuoteStartsCharAt: (source, index) => index === 0 || !/[A-Za-z0-9_]/.test(source[index - 1]),
+        })) {
+            continue;
+        }
+        if (!quoteState.inString && !quoteState.inChar && text[i] === ';')
+            return text.slice(0, i);
+    }
+    return text;
+}
+function parseStatement(text, aliasPolicy, label) {
+    const maybeDirective = /^([.]?[A-Za-z][A-Za-z0-9_]*)\b\s*(.*)$/.exec(text);
+    if (maybeDirective) {
+        const canonical = resolveDirectiveAlias(maybeDirective[1], aliasPolicy);
+        if (canonical === '.equ' && label) {
+            return { kind: 'equ', name: label, exprText: maybeDirective[2].trim() };
+        }
+    }
+    const directive = /^([.]?[A-Za-z][A-Za-z0-9_]*)\b\s*(.*)$/.exec(text);
+    if (directive) {
+        const canonical = resolveDirectiveAlias(directive[1], aliasPolicy);
+        const name = canonical?.slice(1);
+        const payload = directive[2].trim();
+        if (name === 'org')
+            return { kind: 'org', exprText: payload };
+        if (name === 'align')
+            return { kind: 'align', exprText: payload };
+        if (name === 'binfrom')
+            return { kind: 'binfrom', exprText: payload };
+        if (name === 'binto')
+            return { kind: 'binto', exprText: payload };
+        if (name === 'end')
+            return { kind: 'end' };
+        if (name === 'db' ||
+            name === 'dw' ||
+            name === 'ds' ||
+            name === 'cstr' ||
+            name === 'pstr' ||
+            name === 'istr') {
+            return { kind: 'rawData', ...(label ? { label } : {}), directive: name, valuesText: payload };
+        }
+        if (text.trimStart().startsWith('.')) {
+            return {
+                kind: 'unsupportedDirective',
+                ...(label ? { label } : {}),
+                directive: directive[1].replace(/^\./, '').toLowerCase(),
+            };
+        }
+        if (name === 'macro' ||
+            name === 'rept' ||
+            name === 'endm' ||
+            name === 'block' ||
+            name === 'endblock') {
+            return { kind: 'unsupportedDirective', ...(label ? { label } : {}), directive: name };
+        }
+    }
+    const instruction = /^([A-Za-z][A-Za-z0-9_]*)(?:\s+(.*))?$/.exec(text);
+    if (!instruction)
+        return undefined;
+    return {
+        kind: 'instruction',
+        ...(label ? { label } : {}),
+        head: instruction[1].toLowerCase(),
+        operandText: instruction[2]?.trim() ?? '',
+    };
+}

package/dist/src/frontend/asm80/parseAsmRawValues.d.ts

@@ -0,0 +1,4 @@
+import type { Diagnostic } from '../../diagnosticTypes.js';
+import type { SourceSpan } from '../ast.js';
+export declare function parseAsmRawValues(path: string, valuesText: string, lineSpan: SourceSpan, diagnostics: Diagnostic[], stringEquates: Map<string, string>): unknown[];
+export declare function parseWholeQuotedString(text: string): string | undefined;