@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/lowering/fixupEmission.js

@@ -1,199 +0,0 @@
-import { formatAbs16FixupAsm, formatAbs16FixupEdAsm, formatAbs16FixupPrefixedAsm, } from './traceFormat.js';
-export function createFixupEmissionHelpers(ctx) {
-    const recordLoweredInstr = (bytes, asmText, span) => {
-        ctx.recordLoweredInstr?.(bytes, asmText, span);
-    };
-    const emitAbs16Bytes = (bytes, patchOffsetFromStart, baseLower, addend, span, asmText) => {
-        const start = ctx.getCodeOffset();
-        for (let index = 0; index < bytes.length; index++) {
-            ctx.setCodeByte(start + index, bytes[index]);
-        }
-        ctx.setCodeOffset(start + bytes.length);
-        ctx.recordCodeSourceRange(start, start + bytes.length);
-        ctx.pushFixup({ offset: start + patchOffsetFromStart, baseLower, addend, file: span.file });
-        ctx.traceInstruction(start, bytes, asmText);
-        recordLoweredInstr(bytes, asmText, span);
-    };
-    const emitAbs16Fixup = (opcode, baseLower, addend, span, asmText) => {
-        const bytes = Uint8Array.of(opcode, 0x00, 0x00);
-        const text = asmText ?? formatAbs16FixupAsm(opcode, baseLower, addend);
-        emitAbs16Bytes(bytes, 1, baseLower, addend, span, text);
-    };
-    const emitAbs16FixupEd = (opcode2, baseLower, addend, span, asmText) => {
-        const bytes = Uint8Array.of(0xed, opcode2, 0x00, 0x00);
-        const text = asmText ?? formatAbs16FixupEdAsm(opcode2, baseLower, addend);
-        emitAbs16Bytes(bytes, 2, baseLower, addend, span, text);
-    };
-    const emitAbs16FixupPrefixed = (prefix, opcode2, baseLower, addend, span, asmText) => {
-        const bytes = Uint8Array.of(prefix, opcode2, 0x00, 0x00);
-        const text = asmText ?? formatAbs16FixupPrefixedAsm(prefix, opcode2, baseLower, addend);
-        emitAbs16Bytes(bytes, 2, baseLower, addend, span, text);
-    };
-    const emitRel8Fixup = (opcode, baseLower, addend, span, mnemonic, asmText) => {
-        const start = ctx.getCodeOffset();
-        ctx.setCodeByte(start, opcode);
-        ctx.setCodeByte(start + 1, 0x00);
-        ctx.setCodeOffset(start + 2);
-        ctx.recordCodeSourceRange(start, start + 2);
-        ctx.pushRel8Fixup({
-            offset: start + 1,
-            origin: start + 2,
-            baseLower,
-            addend,
-            file: span.file,
-            mnemonic,
-        });
-        const bytes = Uint8Array.of(opcode, 0x00);
-        const text = asmText ?? `${mnemonic} ${baseLower}`;
-        ctx.traceInstruction(start, bytes, text);
-        recordLoweredInstr(bytes, text, span);
-    };
-    const conditionOpcodeFromName = (nameRaw) => {
-        const asName = nameRaw.toUpperCase();
-        switch (asName) {
-            case 'NZ':
-                return 0xc2;
-            case 'Z':
-                return 0xca;
-            case 'NC':
-                return 0xd2;
-            case 'C':
-                return 0xda;
-            case 'PO':
-                return 0xe2;
-            case 'PE':
-                return 0xea;
-            case 'P':
-                return 0xf2;
-            case 'M':
-                return 0xfa;
-            default:
-                return undefined;
-        }
-    };
-    const conditionNameFromOpcode = (opcode) => {
-        switch (opcode) {
-            case 0xc2:
-                return 'NZ';
-            case 0xca:
-                return 'Z';
-            case 0xd2:
-                return 'NC';
-            case 0xda:
-                return 'C';
-            case 0xe2:
-                return 'PO';
-            case 0xea:
-                return 'PE';
-            case 0xf2:
-                return 'P';
-            case 0xfa:
-                return 'M';
-            default:
-                return undefined;
-        }
-    };
-    const callConditionOpcodeFromName = (nameRaw) => {
-        switch (nameRaw.toUpperCase()) {
-            case 'NZ':
-                return 0xc4;
-            case 'Z':
-                return 0xcc;
-            case 'NC':
-                return 0xd4;
-            case 'C':
-                return 0xdc;
-            case 'PO':
-                return 0xe4;
-            case 'PE':
-                return 0xec;
-            case 'P':
-                return 0xf4;
-            case 'M':
-                return 0xfc;
-            default:
-                return undefined;
-        }
-    };
-    const symbolicTargetFromExpr = (expr) => {
-        if (expr.kind === 'ImmName')
-            return { baseLower: expr.name.toLowerCase(), addend: 0 };
-        if (expr.kind !== 'ImmBinary')
-            return undefined;
-        if (expr.op !== '+' && expr.op !== '-')
-            return undefined;
-        const leftName = expr.left.kind === 'ImmName' ? expr.left.name.toLowerCase() : undefined;
-        const rightName = expr.right.kind === 'ImmName' ? expr.right.name.toLowerCase() : undefined;
-        if (leftName) {
-            const right = ctx.evalImmExpr(expr.right);
-            if (right === undefined)
-                return undefined;
-            return { baseLower: leftName, addend: expr.op === '+' ? right : -right };
-        }
-        if (expr.op === '+' && rightName) {
-            const left = ctx.evalImmExpr(expr.left);
-            if (left === undefined)
-                return undefined;
-            return { baseLower: rightName, addend: left };
-        }
-        return undefined;
-    };
-    const jrConditionOpcodeFromName = (nameRaw) => {
-        switch (nameRaw.toUpperCase()) {
-            case 'NZ':
-                return 0x20;
-            case 'Z':
-                return 0x28;
-            case 'NC':
-                return 0x30;
-            case 'C':
-                return 0x38;
-            default:
-                return undefined;
-        }
-    };
-    const conditionOpcode = (op) => {
-        const asName = op.kind === 'Imm' && op.expr.kind === 'ImmName'
-            ? op.expr.name
-            : op.kind === 'Reg'
-                ? op.name
-                : undefined;
-        return asName ? conditionOpcodeFromName(asName) : undefined;
-    };
-    const inverseConditionName = (nameRaw) => {
-        const name = nameRaw.toUpperCase();
-        switch (name) {
-            case 'NZ':
-                return 'Z';
-            case 'Z':
-                return 'NZ';
-            case 'NC':
-                return 'C';
-            case 'C':
-                return 'NC';
-            case 'PO':
-                return 'PE';
-            case 'PE':
-                return 'PO';
-            case 'P':
-                return 'M';
-            case 'M':
-                return 'P';
-            default:
-                return undefined;
-        }
-    };
-    return {
-        callConditionOpcodeFromName,
-        conditionNameFromOpcode,
-        conditionOpcode,
-        conditionOpcodeFromName,
-        emitAbs16Fixup,
-        emitAbs16FixupEd,
-        emitAbs16FixupPrefixed,
-        emitRel8Fixup,
-        inverseConditionName,
-        jrConditionOpcodeFromName,
-        symbolicTargetFromExpr,
-    };
-}

package/dist/legacy-root-azm/src/lowering/immMath.d.ts

@@ -1,2 +0,0 @@
-export declare function evalUnaryImmOp(op: '+' | '-' | '~', value: number): number;
-export declare function evalBinaryImmOp(op: '*' | '/' | '%' | '+' | '-' | '&' | '^' | '|' | '<<' | '>>', left: number, right: number): number | undefined;

package/dist/legacy-root-azm/src/lowering/immMath.js

@@ -1,34 +0,0 @@
-export function evalUnaryImmOp(op, value) {
-    switch (op) {
-        case '+':
-            return +value;
-        case '-':
-            return -value;
-        case '~':
-            return ~value;
-    }
-}
-export function evalBinaryImmOp(op, left, right) {
-    switch (op) {
-        case '*':
-            return left * right;
-        case '/':
-            return right === 0 ? undefined : Math.trunc(left / right);
-        case '%':
-            return right === 0 ? undefined : left % right;
-        case '+':
-            return left + right;
-        case '-':
-            return left - right;
-        case '&':
-            return left & right;
-        case '^':
-            return left ^ right;
-        case '|':
-            return left | right;
-        case '<<':
-            return left << right;
-        case '>>':
-            return left >> right;
-    }
-}

package/dist/legacy-root-azm/src/lowering/inputAssets.d.ts

@@ -1,7 +0,0 @@
-type InputDiag = (file: string, message: string) => void;
-export declare function loadBinInput(fromFile: string, fromPath: string, includeDirs: readonly string[], report: InputDiag): Buffer | undefined;
-export declare function parseIntelHex(ownerFile: string, hexText: string, report: InputDiag): {
-    bytes: Map<number, number>;
-    minAddress: number;
-} | undefined;
-export {};

package/dist/legacy-root-azm/src/lowering/inputAssets.js

@@ -1,106 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-function resolveInputPath(fromFile, fromPath, includeDirs, report) {
-    const candidates = [];
-    candidates.push(resolve(dirname(fromFile), fromPath));
-    for (const inc of includeDirs)
-        candidates.push(resolve(inc, fromPath));
-    const seen = new Set();
-    for (const candidate of candidates) {
-        if (seen.has(candidate))
-            continue;
-        seen.add(candidate);
-        if (existsSync(candidate))
-            return candidate;
-    }
-    report(fromFile, `Failed to resolve input path "${fromPath}".`);
-    return undefined;
-}
-export function loadBinInput(fromFile, fromPath, includeDirs, report) {
-    const path = resolveInputPath(fromFile, fromPath, includeDirs, report);
-    if (!path)
-        return undefined;
-    try {
-        return readFileSync(path);
-    }
-    catch (err) {
-        report(fromFile, `Failed to read bin file "${path}": ${String(err)}`);
-        return undefined;
-    }
-}
-export function parseIntelHex(ownerFile, hexText, report) {
-    const out = new Map();
-    let minAddress = Number.POSITIVE_INFINITY;
-    const lines = hexText.split(/\r?\n/);
-    let sawData = false;
-    let sawEof = false;
-    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-        const raw = lines[lineIndex].trim();
-        if (raw.length === 0)
-            continue;
-        if (!raw.startsWith(':')) {
-            report(ownerFile, `Invalid Intel HEX record at line ${lineIndex + 1}.`);
-            return undefined;
-        }
-        const body = raw.slice(1);
-        if (body.length < 10 || body.length % 2 !== 0) {
-            report(ownerFile, `Malformed Intel HEX record at line ${lineIndex + 1}.`);
-            return undefined;
-        }
-        const bytesLine = [];
-        for (let i = 0; i < body.length; i += 2) {
-            const pair = body.slice(i, i + 2);
-            const value = Number.parseInt(pair, 16);
-            if (Number.isNaN(value)) {
-                report(ownerFile, `Invalid HEX byte "${pair}" at line ${lineIndex + 1}.`);
-                return undefined;
-            }
-            bytesLine.push(value & 0xff);
-        }
-        const len = bytesLine[0];
-        const addr = ((bytesLine[1] << 8) | bytesLine[2]) & 0xffff;
-        const type = bytesLine[3];
-        const data = bytesLine.slice(4, bytesLine.length - 1);
-        if (len !== data.length) {
-            report(ownerFile, `Intel HEX length mismatch at line ${lineIndex + 1}.`);
-            return undefined;
-        }
-        const sum = bytesLine.reduce((acc, byte) => (acc + byte) & 0xff, 0);
-        if (sum !== 0) {
-            report(ownerFile, `Intel HEX checksum mismatch at line ${lineIndex + 1}.`);
-            return undefined;
-        }
-        if (sawEof) {
-            report(ownerFile, `Intel HEX data found after EOF record.`);
-            return undefined;
-        }
-        if (type === 0x00) {
-            for (let i = 0; i < data.length; i++) {
-                const address = addr + i;
-                if (address < 0 || address > 0xffff) {
-                    report(ownerFile, `Intel HEX address out of range at line ${lineIndex + 1}.`);
-                    return undefined;
-                }
-                if (out.has(address)) {
-                    report(ownerFile, `Intel HEX overlaps itself at address ${address}.`);
-                    return undefined;
-                }
-                out.set(address, data[i]);
-                minAddress = Math.min(minAddress, address);
-            }
-            sawData = true;
-            continue;
-        }
-        if (type === 0x01) {
-            sawEof = true;
-            continue;
-        }
-        report(ownerFile, `Unsupported Intel HEX record type ${type.toString(16).padStart(2, '0')} at line ${lineIndex + 1}.`);
-        return undefined;
-    }
-    if (!sawData) {
-        report(ownerFile, `Intel HEX file has no data records.`);
-        return undefined;
-    }
-    return { bytes: out, minAddress };
-}

package/dist/legacy-root-azm/src/lowering/ldEncoding.d.ts

@@ -1,15 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { SourceSpan } from '../frontend/ast.js';
-import type { LdForm } from './ldFormSelection.js';
-export type LdEncodingContext = {
-    diagAt: (diagnostics: Diagnostic[], span: SourceSpan, message: string) => void;
-    diagnostics: Diagnostic[];
-    emitAbs16Fixup: (opcode: number, target: string, addend: number, span: SourceSpan, asmText?: string) => void;
-    emitAbs16FixupEd: (opcode: number, target: string, addend: number, span: SourceSpan, asmText?: string) => void;
-    emitAbs16FixupPrefixed: (prefix: number, opcode: number, target: string, addend: number, span: SourceSpan, asmText?: string) => void;
-    reg8Code: ReadonlyMap<string, number>;
-    setSpTrackingInvalid: () => void;
-};
-export declare function createLdEncodingHelpers(ctx: LdEncodingContext): {
-    emitLdForm: (form: LdForm) => boolean;
-};

package/dist/legacy-root-azm/src/lowering/ldEncoding.js

@@ -1,12 +0,0 @@
-import { createLdEncodingRegMemHelpers } from './ldEncodingRegMemHelpers.js';
-export function createLdEncodingHelpers(ctx) {
-    const { emitLdRegMemForm } = createLdEncodingRegMemHelpers(ctx);
-    const emitLdForm = (form) => {
-        const regMemHandled = emitLdRegMemForm(form);
-        if (regMemHandled !== null) {
-            return regMemHandled;
-        }
-        return false;
-    };
-    return { emitLdForm };
-}

package/dist/legacy-root-azm/src/lowering/ldEncodingRegMemHelpers.d.ts

@@ -1,5 +0,0 @@
-import type { LdForm } from './ldFormSelection.js';
-import type { LdEncodingContext } from './ldEncoding.js';
-export declare function createLdEncodingRegMemHelpers(ctx: LdEncodingContext): {
-    emitLdRegMemForm: (form: LdForm) => boolean | null;
-};

package/dist/legacy-root-azm/src/lowering/ldEncodingRegMemHelpers.js

@@ -1,124 +0,0 @@
-export function createLdEncodingRegMemHelpers(ctx) {
-    const { emitAbs16Fixup, emitAbs16FixupEd, emitAbs16FixupPrefixed, reg8Code, setSpTrackingInvalid, } = ctx;
-    const emitRegFromMem = (form) => {
-        const { dst, src, inst, srcResolved } = form;
-        if (dst.kind !== 'Reg' || src.kind !== 'Mem')
-            return false;
-        if (form.srcHasRegisterLikeEaBase)
-            return false;
-        if (form.srcIsIxIyDispMem && reg8Code.has(dst.name.toUpperCase()))
-            return false;
-        if (form.srcIsEaNameHL)
-            return false;
-        if (dst.name.toUpperCase() === 'A' && form.srcIsEaNameBCorDE)
-            return false;
-        if (dst.name.toUpperCase() === 'A' && srcResolved?.kind === 'abs') {
-            emitAbs16Fixup(0x3a, srcResolved.baseLower, srcResolved.addend, inst.span);
-            return true;
-        }
-        const regUp = dst.name.toUpperCase();
-        if (reg8Code.has(regUp)) {
-            return false;
-        }
-        const r16 = dst.name.toUpperCase();
-        if (r16 === 'HL') {
-            if (srcResolved?.kind === 'abs') {
-                emitAbs16Fixup(0x2a, srcResolved.baseLower, srcResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        if (r16 === 'DE') {
-            if (srcResolved?.kind === 'abs') {
-                emitAbs16FixupEd(0x5b, srcResolved.baseLower, srcResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        if (r16 === 'BC') {
-            if (srcResolved?.kind === 'abs') {
-                emitAbs16FixupEd(0x4b, srcResolved.baseLower, srcResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        if (r16 === 'SP' && srcResolved?.kind === 'abs') {
-            emitAbs16FixupEd(0x7b, srcResolved.baseLower, srcResolved.addend, inst.span);
-            setSpTrackingInvalid();
-            return true;
-        }
-        if (r16 === 'IX' || r16 === 'IY') {
-            if (srcResolved?.kind === 'abs') {
-                emitAbs16FixupPrefixed(r16 === 'IX' ? 0xdd : 0xfd, 0x2a, srcResolved.baseLower, srcResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        return false;
-    };
-    const emitMemFromReg = (form) => {
-        const { dst, src, inst, dstResolved } = form;
-        if (dst.kind !== 'Mem' || src.kind !== 'Reg')
-            return false;
-        if (form.dstHasRegisterLikeEaBase)
-            return false;
-        if (form.dstIsIxIyDispMem && reg8Code.has(src.name.toUpperCase()))
-            return false;
-        if (form.dstIsEaNameHL)
-            return false;
-        if (src.name.toUpperCase() === 'A' && form.dstIsEaNameBCorDE)
-            return false;
-        if (src.name.toUpperCase() === 'A' && dstResolved?.kind === 'abs') {
-            emitAbs16Fixup(0x32, dstResolved.baseLower, dstResolved.addend, inst.span);
-            return true;
-        }
-        const regUp = src.name.toUpperCase();
-        if (reg8Code.has(regUp)) {
-            return false;
-        }
-        const r16 = src.name.toUpperCase();
-        if (r16 === 'HL') {
-            if (dstResolved?.kind === 'abs') {
-                emitAbs16Fixup(0x22, dstResolved.baseLower, dstResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        if (r16 === 'DE') {
-            if (dstResolved?.kind === 'abs') {
-                emitAbs16FixupEd(0x53, dstResolved.baseLower, dstResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        if (r16 === 'BC') {
-            if (dstResolved?.kind === 'abs') {
-                emitAbs16FixupEd(0x43, dstResolved.baseLower, dstResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        if (r16 === 'SP' && dstResolved?.kind === 'abs') {
-            emitAbs16FixupEd(0x73, dstResolved.baseLower, dstResolved.addend, inst.span);
-            return true;
-        }
-        if (r16 === 'IX' || r16 === 'IY') {
-            if (dstResolved?.kind === 'abs') {
-                emitAbs16FixupPrefixed(r16 === 'IX' ? 0xdd : 0xfd, 0x22, dstResolved.baseLower, dstResolved.addend, inst.span);
-                return true;
-            }
-            return false;
-        }
-        return false;
-    };
-    const emitLdRegMemForm = (form) => {
-        if (form.dst.kind === 'Reg' && form.src.kind === 'Mem') {
-            return emitRegFromMem(form);
-        }
-        if (form.dst.kind === 'Mem' && form.src.kind === 'Reg') {
-            return emitMemFromReg(form);
-        }
-        return null;
-    };
-    return { emitLdRegMemForm };
-}

package/dist/legacy-root-azm/src/lowering/ldFormSelection.d.ts

@@ -1,26 +0,0 @@
-import type { AsmInstructionNode, AsmOperandNode, EaExprNode } from '../frontend/ast.js';
-import type { SourceSpan } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { EaResolution } from './eaResolution.js';
-export type LdForm = {
-    inst: AsmInstructionNode;
-    dst: AsmOperandNode;
-    src: AsmOperandNode;
-    dstResolved: EaResolution | undefined;
-    srcResolved: EaResolution | undefined;
-    srcHasRegisterLikeEaBase: boolean;
-    dstHasRegisterLikeEaBase: boolean;
-    srcIsIxIyDispMem: boolean;
-    dstIsIxIyDispMem: boolean;
-    srcIsEaNameHL: boolean;
-    dstIsEaNameHL: boolean;
-    srcIsEaNameBCorDE: boolean;
-    dstIsEaNameBCorDE: boolean;
-};
-export type LdFormSelectionContext = {
-    env: CompileEnv;
-    resolveEa: (ea: EaExprNode, span: SourceSpan) => EaResolution | undefined;
-};
-export declare function createLdFormSelectionHelpers(ctx: LdFormSelectionContext): {
-    analyzeLdInstruction: (inst: AsmInstructionNode) => LdForm | null;
-};

package/dist/legacy-root-azm/src/lowering/ldFormSelection.js

@@ -1,92 +0,0 @@
-export function createLdFormSelectionHelpers(ctx) {
-    const { env, resolveEa } = ctx;
-    const coerceValueOperand = (op) => {
-        if (op.kind === 'Reg') {
-            const lower = op.name.toLowerCase();
-            if (env.equates.has(lower)) {
-                return {
-                    kind: 'Mem',
-                    span: op.span,
-                    expr: { kind: 'EaName', span: op.span, name: op.name },
-                };
-            }
-        }
-        return op;
-    };
-    const isRegisterToken = (name) => {
-        const token = name.toUpperCase();
-        return (token === 'A' ||
-            token === 'B' ||
-            token === 'C' ||
-            token === 'D' ||
-            token === 'E' ||
-            token === 'H' ||
-            token === 'L' ||
-            token === 'AF' ||
-            token === 'BC' ||
-            token === 'DE' ||
-            token === 'HL' ||
-            token === 'SP' ||
-            token === 'IX' ||
-            token === 'IY' ||
-            token === 'IXH' ||
-            token === 'IXL' ||
-            token === 'IYH' ||
-            token === 'IYL');
-    };
-    const isBoundEaName = (name) => {
-        const lower = name.toLowerCase();
-        return env.equates.has(lower);
-    };
-    const hasRegisterLikeEaBase = (ea) => {
-        switch (ea.kind) {
-            case 'EaName':
-                return isRegisterToken(ea.name) && !isBoundEaName(ea.name);
-            case 'EaImm':
-                return false;
-            case 'EaLayoutCast':
-                return false;
-            case 'EaField':
-                return hasRegisterLikeEaBase(ea.base);
-            case 'EaIndex':
-                return hasRegisterLikeEaBase(ea.base);
-            case 'EaAdd':
-            case 'EaSub':
-                return hasRegisterLikeEaBase(ea.base);
-        }
-    };
-    const isEaNameHL = (ea) => ea.kind === 'EaName' && ea.name.toUpperCase() === 'HL';
-    const isEaNameBCorDE = (ea) => ea.kind === 'EaName' && (ea.name.toUpperCase() === 'BC' || ea.name.toUpperCase() === 'DE');
-    const isIxIyBaseEa = (ea) => ea.kind === 'EaName' && (ea.name.toUpperCase() === 'IX' || ea.name.toUpperCase() === 'IY');
-    const isIxIyDispMem = (op) => op.kind === 'Mem' &&
-        (isIxIyBaseEa(op.expr) ||
-            (op.expr.kind === 'EaIndex' &&
-                isIxIyBaseEa(op.expr.base) &&
-                op.expr.index.kind === 'IndexImm') ||
-            ((op.expr.kind === 'EaAdd' || op.expr.kind === 'EaSub') && isIxIyBaseEa(op.expr.base)));
-    const analyzeLdInstruction = (inst) => {
-        const head = inst.head.toLowerCase();
-        if (head !== 'ld' || inst.operands.length !== 2)
-            return null;
-        const dst = coerceValueOperand(inst.operands[0]);
-        const src = coerceValueOperand(inst.operands[1]);
-        const dstResolved = dst.kind === 'Mem' ? resolveEa(dst.expr, inst.span) : undefined;
-        const srcResolved = src.kind === 'Mem' ? resolveEa(src.expr, inst.span) : undefined;
-        return {
-            inst,
-            dst,
-            src,
-            dstResolved,
-            srcResolved,
-            srcHasRegisterLikeEaBase: src.kind === 'Mem' ? hasRegisterLikeEaBase(src.expr) : false,
-            dstHasRegisterLikeEaBase: dst.kind === 'Mem' ? hasRegisterLikeEaBase(dst.expr) : false,
-            srcIsIxIyDispMem: isIxIyDispMem(src),
-            dstIsIxIyDispMem: isIxIyDispMem(dst),
-            srcIsEaNameHL: src.kind === 'Mem' ? isEaNameHL(src.expr) : false,
-            dstIsEaNameHL: dst.kind === 'Mem' ? isEaNameHL(dst.expr) : false,
-            srcIsEaNameBCorDE: src.kind === 'Mem' ? isEaNameBCorDE(src.expr) : false,
-            dstIsEaNameBCorDE: dst.kind === 'Mem' ? isEaNameBCorDE(dst.expr) : false,
-        };
-    };
-    return { analyzeLdInstruction };
-}

package/dist/legacy-root-azm/src/lowering/ldLowering.d.ts

@@ -1,7 +0,0 @@
-import type { LdEncodingContext } from './ldEncoding.js';
-import type { LdFormSelectionContext } from './ldFormSelection.js';
-type LdLoweringContext = LdFormSelectionContext & LdEncodingContext;
-export declare function createLdLoweringHelpers(ctx: LdLoweringContext): {
-    lowerLdWithEa: (inst: Parameters<(inst: import("../frontend/ast.js").AsmInstructionNode) => import("./ldFormSelection.js").LdForm | null>[0]) => boolean;
-};
-export {};

package/dist/legacy-root-azm/src/lowering/ldLowering.js

@@ -1,13 +0,0 @@
-import { createLdEncodingHelpers } from './ldEncoding.js';
-import { createLdFormSelectionHelpers } from './ldFormSelection.js';
-export function createLdLoweringHelpers(ctx) {
-    const { analyzeLdInstruction } = createLdFormSelectionHelpers(ctx);
-    const { emitLdForm } = createLdEncodingHelpers(ctx);
-    const lowerLdWithEa = (inst) => {
-        const form = analyzeLdInstruction(inst);
-        if (!form)
-            return false;
-        return emitLdForm(form);
-    };
-    return { lowerLdWithEa };
-}

package/dist/legacy-root-azm/src/lowering/loweredAsmByteEmission.d.ts

@@ -1,23 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { LoweredAsmProgram } from './loweredAsmTypes.js';
-type LoweredAsmByteEmissionContext = {
-    diagnostics: Diagnostic[];
-    diag: (diagnostics: Diagnostic[], file: string, message: string) => void;
-    primaryFile: string;
-    env: CompileEnv;
-};
-type LoweredAsmByteEmissionResult = {
-    codeBytes: Map<number, number>;
-    dataBytes: Map<number, number>;
-    blockSizesByKey: Map<string, number>;
-    maxAddress: number;
-};
-/**
- * After link-time fixups are applied to `finalBytes`, patch lowered `instr` byte arrays
- * (including `@raw` placeholders from abs16/rel8 fixups) so ASM80 listings match the
- * merged image.
- */
-export declare function syncLoweredAsmInstructionBytesFromFinalBytes(program: LoweredAsmProgram, finalBytes: Map<number, number>, env: CompileEnv): void;
-export declare function emitLoweredAsmProgramBytes(program: LoweredAsmProgram, ctx: LoweredAsmByteEmissionContext): LoweredAsmByteEmissionResult;
-export {};