@gaialabs/core 0.1.19 → 0.2.1

package/dist/index.js

@@ -1,3977 +0,0 @@
-'use strict';
-
-var shared = require('@gaialabs/shared');
-
-// src/rom/state.ts
-var RomState = class _RomState {
-  constructor() {
-    // Basic memory buffers
-    this.cgram = new Uint8Array(512);
-    // Color palette RAM
-    this.vram = new Uint8Array(65536);
-  }
-  // Video RAM
-  /**
-   * Create ROM state from scene metadata.
-   * Parameters are currently unused but kept for future implementation.
-   */
-  static async fromScene(_baseDir, _root, _metaFile, _id) {
-    return new _RomState();
-  }
-};
-var RomStateUtils = class {
-  /** Create an empty ROM state */
-  static createEmpty() {
-    return new RomState();
-  }
-  /** Clear all data in the given ROM state */
-  static clear(state) {
-    state.cgram.fill(0);
-    state.vram.fill(0);
-  }
-};
-
-// src/rom/extraction/processor.ts
-var ProcessorStateManager = class {
-  constructor() {
-    this.accumulatorFlags = /* @__PURE__ */ new Map();
-    this.indexFlags = /* @__PURE__ */ new Map();
-    this.bankNotes = /* @__PURE__ */ new Map();
-    this.stackPositions = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Hydrate processor registers with stored state
-   * Uses Registers from gaia-core/assembly for processor state management
-   */
-  hydrateRegisters(position, reg) {
-    const acc = this.accumulatorFlags.get(position);
-    if (acc !== void 0) {
-      reg.accumulatorFlag = acc ?? void 0;
-    }
-    const ind = this.indexFlags.get(position);
-    if (ind !== void 0) {
-      reg.indexFlag = ind ?? void 0;
-    }
-    const bnk = this.bankNotes.get(position);
-    if (bnk !== void 0) {
-      reg.dataBank = bnk ?? void 0;
-    }
-    const stack = this.stackPositions.get(position);
-    if (stack !== void 0) {
-      reg.stack.location = stack;
-    }
-  }
-  // Accumulator flag methods
-  getAccumulatorFlag(location) {
-    return this.accumulatorFlags.get(location);
-  }
-  setAccumulatorFlag(location, value) {
-    this.accumulatorFlags.set(location, value);
-  }
-  tryAddAccumulatorFlag(location, value) {
-    if (this.accumulatorFlags.has(location)) {
-      return false;
-    }
-    this.accumulatorFlags.set(location, value);
-    return true;
-  }
-  // Index flag methods
-  getIndexFlag(location) {
-    return this.indexFlags.get(location);
-  }
-  setIndexFlag(location, value) {
-    this.indexFlags.set(location, value);
-  }
-  tryAddIndexFlag(location, value) {
-    if (this.indexFlags.has(location)) {
-      return false;
-    }
-    this.indexFlags.set(location, value);
-    return true;
-  }
-  // Bank note methods
-  getBankNote(location) {
-    return this.bankNotes.get(location);
-  }
-  setBankNote(location, value) {
-    this.bankNotes.set(location, value);
-  }
-  // Stack position methods
-  getStackPosition(location) {
-    return this.stackPositions.get(location);
-  }
-  setStackPosition(location, value) {
-    this.stackPositions.set(location, value);
-  }
-  tryAddStackPosition(location, value) {
-    if (this.stackPositions.has(location)) {
-      return false;
-    }
-    this.stackPositions.set(location, value);
-    return true;
-  }
-};
-
-// src/rom/extraction/reader.ts
-var RomDataReader = class {
-  constructor(romData) {
-    if (!romData) {
-      throw new Error("romData cannot be null");
-    }
-    this.romData = romData;
-    this.position = 0;
-  }
-  readByte() {
-    return this.romData[this.position++];
-  }
-  readSByte() {
-    const value = this.readByte();
-    return value > 127 ? value - 256 : value;
-  }
-  readUShort() {
-    return this.readByte() | this.readByte() << 8;
-  }
-  readShort() {
-    const value = this.readUShort();
-    return value > 32767 ? value - 65536 : value;
-  }
-  readAddress() {
-    return this.readByte() | this.readByte() << 8 | this.readByte() << 16;
-  }
-  readInt() {
-    return this.readByte() | this.readByte() << 8 | this.readByte() << 16 | this.readByte() << 24;
-  }
-  peekByte() {
-    return this.romData[this.position];
-  }
-  peekShort() {
-    return this.romData[this.position] | this.romData[this.position + 1] << 8;
-  }
-  peekAddress() {
-    return this.romData[this.position] | this.romData[this.position + 1] << 8 | this.romData[this.position + 2] << 16;
-  }
-};
-var ReferenceManager = class {
-  constructor(root) {
-    this.structTable = /* @__PURE__ */ new Map();
-    this.markerTable = /* @__PURE__ */ new Map();
-    this.nameTable = /* @__PURE__ */ new Map();
-    if (!root) {
-      throw new Error("root cannot be null");
-    }
-    this.root = root;
-  }
-  // Struct management
-  tryGetStruct(location) {
-    const chunkType = this.structTable.get(location);
-    return { found: chunkType !== void 0, chunkType };
-  }
-  tryAddStruct(location, chunkType) {
-    if (this.structTable.has(location)) {
-      return false;
-    }
-    this.structTable.set(location, chunkType);
-    return true;
-  }
-  containsStruct(location) {
-    return this.structTable.has(location);
-  }
-  // Name management
-  tryGetName(location) {
-    const referenceName = this.nameTable.get(location);
-    return { found: referenceName !== void 0, referenceName };
-  }
-  tryAddName(location, referenceName) {
-    if (this.nameTable.has(location)) {
-      return false;
-    }
-    this.nameTable.set(location, referenceName);
-    return true;
-  }
-  // Marker management
-  tryGetMarker(location) {
-    const offset = this.markerTable.get(location);
-    return { found: offset !== void 0, offset };
-  }
-  setMarker(location, offset) {
-    this.markerTable.set(location, offset);
-  }
-  // Label creation
-  createBranchLabel(location) {
-    const name = `loc_${location.toString(16).toUpperCase().padStart(6, "0")}`;
-    this.nameTable.set(location, name);
-    return name;
-  }
-  createTypeName(type, location) {
-    let name = type.toLowerCase();
-    while (name.length > 0 && shared.BlockReaderConstants.POINTER_CHARACTERS.includes(name[0])) {
-      name = name.substring(1) + "_list";
-    }
-    return `${name}_${location.toString(16).toUpperCase().padStart(6, "0")}`;
-  }
-  createFallbackName(location) {
-    const fileMatch = this.root.files.find(
-      (x) => x.start <= location && x.end > location
-    );
-    if (fileMatch) {
-      const offset = location - fileMatch.start;
-      return fileMatch.name + (offset !== 0 ? `+${offset.toString(16).toUpperCase()}` : "");
-    }
-    return location.toString(16).toUpperCase().padStart(6, "0");
-  }
-  /**
-   * Finds a reference location by its assigned name.
-   */
-  findLocationByName(name) {
-    for (const [loc, refName] of this.nameTable) {
-      if (refName === name) {
-        return loc;
-      }
-    }
-    return void 0;
-  }
-  resolveName(location, type, isBranch) {
-    const prefix = shared.Address.codeFromType(type);
-    let name;
-    let label = null;
-    let resolvedLocation = location;
-    const rewrite = this.root.rewrites[location];
-    if (rewrite !== void 0) {
-      const result = this.processRewrite(location, rewrite);
-      resolvedLocation = result.location;
-      label = result.label;
-    }
-    const existingName = this.nameTable.get(resolvedLocation);
-    if (existingName) {
-      name = existingName;
-    } else {
-      name = isBranch ? this.createBranchLabel(resolvedLocation) : this.findClosestReference(resolvedLocation) || this.createFallbackName(resolvedLocation);
-    }
-    return `${prefix || ""}${name}${label || ""}`;
-  }
-  findClosestReference(location) {
-    let closestDistance = shared.BlockReaderConstants.REF_SEARCH_MAX_RANGE;
-    let closestName = null;
-    let closestLocation = null;
-    for (const [entryKey, entryValue] of this.nameTable) {
-      if (entryKey > location) {
-        continue;
-      }
-      const distance = location - entryKey;
-      if (distance >= closestDistance) {
-        continue;
-      }
-      closestDistance = distance;
-      closestName = entryValue;
-      closestLocation = entryKey;
-      if (closestDistance === 1) {
-        break;
-      }
-    }
-    return this.processClosestMatch(location, closestName, closestLocation, closestDistance);
-  }
-  processRewrite(location, rewrite) {
-    const offset = location - rewrite;
-    const cmd = offset < 0 ? "-" : "+";
-    const absOffset = Math.abs(offset);
-    let label = null;
-    const structType = this.structTable.get(rewrite);
-    if (structType === shared.BlockReaderConstants.WIDE_STRING_TYPE) {
-      this.markerTable.set(rewrite, absOffset);
-      this.markerTable.set(location, absOffset);
-      label = cmd === "-" ? shared.BlockReaderConstants.NEGATIVE_MARKER_FORMAT : shared.BlockReaderConstants.MARKER_FORMAT;
-    } else {
-      const formatString = cmd === "-" ? shared.BlockReaderConstants.NEGATIVE_OFFSET_FORMAT : shared.BlockReaderConstants.OFFSET_FORMAT;
-      label = formatString.replace("{0:X}", absOffset.toString(16).toUpperCase());
-    }
-    return { location: rewrite, label };
-  }
-  processClosestMatch(location, closestName, closestLocation, closestDistance) {
-    if (!closestName || closestLocation === null) {
-      return null;
-    }
-    let result = closestName;
-    const structType = this.structTable.get(closestLocation);
-    if (structType === shared.BlockReaderConstants.WIDE_STRING_TYPE) {
-      this.markerTable.set(closestLocation, closestDistance);
-      this.markerTable.set(location, closestDistance);
-      result += shared.BlockReaderConstants.MARKER_FORMAT;
-    } else {
-      result += `+${closestDistance.toString(16).toUpperCase()}`;
-    }
-    return result;
-  }
-};
-
-// src/rom/extraction/stack.ts
-var StackOperations = class {
-  constructor(registers, blockReader) {
-    this._registers = registers;
-    this._blockReader = blockReader;
-  }
-  handleStackOperation(mnemonic) {
-    switch (mnemonic) {
-      case "PHD":
-        this._registers.stack.push(this._registers.direct ?? 0);
-        break;
-      case "PLD":
-        this._registers.direct = this._registers.stack.popUInt16();
-        break;
-      case "PHK":
-        this._registers.stack.push(this._blockReader._romDataReader.position >> 16 | 128);
-        break;
-      case "PHB":
-        this._registers.stack.push(this._registers.dataBank ?? 129);
-        break;
-      case "PLB":
-        this._registers.dataBank = this._registers.stack.popByte();
-        break;
-      case "PHP":
-        this._registers.stack.push(this._registers.statusFlags);
-        break;
-      case "PLP":
-        this._registers.statusFlags = this._registers.stack.popByte();
-        break;
-      case "PHA":
-        this.handleAccumulatorPush();
-        break;
-      case "PLA":
-        this.handleAccumulatorPull();
-        break;
-      case "PHX":
-        this.handleXIndexPush();
-        break;
-      case "PLX":
-        this.handleXIndexPull();
-        break;
-      case "PHY":
-        this.handleYIndexPush();
-        break;
-      case "PLY":
-        this.handleYIndexPull();
-        break;
-      case "XBA":
-        this.handleExchangeBytes();
-        break;
-    }
-  }
-  handleAccumulatorPush() {
-    if (this._registers.accumulatorFlag === true) {
-      this._registers.stack.push((this._registers.accumulator ?? 0) & 255);
-    } else {
-      this._registers.stack.pushUInt16(this._registers.accumulator ?? 0);
-    }
-  }
-  handleAccumulatorPull() {
-    if (this._registers.accumulatorFlag === true) {
-      this._registers.accumulator = (this._registers.accumulator ?? 0) & 65280 | this._registers.stack.popByte();
-    } else {
-      this._registers.accumulator = this._registers.stack.popUInt16();
-    }
-  }
-  handleXIndexPush() {
-    if (this._registers.indexFlag === true) {
-      this._registers.stack.push((this._registers.xIndex ?? 0) & 255);
-    } else {
-      this._registers.stack.pushUInt16(this._registers.xIndex ?? 0);
-    }
-  }
-  handleXIndexPull() {
-    if (this._registers.indexFlag === true) {
-      this._registers.xIndex = (this._registers.xIndex ?? 0) & 65280 | this._registers.stack.popByte();
-    } else {
-      this._registers.xIndex = this._registers.stack.popUInt16();
-    }
-  }
-  handleYIndexPush() {
-    if (this._registers.indexFlag === true) {
-      this._registers.stack.push((this._registers.yIndex ?? 0) & 255);
-    } else {
-      this._registers.stack.pushUInt16(this._registers.yIndex ?? 0);
-    }
-  }
-  handleYIndexPull() {
-    if (this._registers.indexFlag === true) {
-      this._registers.yIndex = (this._registers.yIndex ?? 0) & 65280 | this._registers.stack.popByte();
-    } else {
-      this._registers.yIndex = this._registers.stack.popUInt16();
-    }
-  }
-  handleExchangeBytes() {
-    const acc = this._registers.accumulator ?? 0;
-    this._registers.accumulator = (acc >> 8 | acc << 8) & 65535;
-  }
-};
-var CopCommandProcessor = class {
-  constructor(blockReader) {
-    this._blockReader = blockReader;
-    this._romDataReader = blockReader._romDataReader;
-  }
-  /**
-   * Parses a COP command based on its definition
-   */
-  parseCopCommand(copDef, operands) {
-    for (const partStr of copDef.parts) {
-      const addrType = shared.Address.typeFromCode(partStr[0]);
-      const isPtr = addrType !== shared.AddressType.Unknown;
-      const referenceType = isPtr ? partStr.substring(1) : this._blockReader._currentAsmBlock.structName ?? "Binary";
-      const memberTypeName = isPtr ? addrType.toString() : partStr;
-      const memberType = this.tryParseMemberType(memberTypeName);
-      if (memberType === null) {
-        throw new Error("Cannot use structs in cop def");
-      }
-      const label = this._blockReader._root.labels[this._romDataReader.position];
-      if (label) {
-        this._romDataReader.position += this.getMemberTypeSize(memberType);
-        operands.push(label);
-      } else {
-        operands.push(this.readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType));
-      }
-    }
-  }
-  tryParseMemberType(memberTypeName) {
-    const upperName = memberTypeName.toUpperCase();
-    for (const [key, value] of Object.entries(shared.MemberType)) {
-      if (key.toUpperCase() === upperName) {
-        return value;
-      }
-    }
-    return null;
-  }
-  getMemberTypeSize(memberType) {
-    switch (memberType) {
-      case shared.MemberType.Byte:
-        return 1;
-      case shared.MemberType.Word:
-      case shared.MemberType.Offset:
-        return 2;
-      case shared.MemberType.Address:
-        return 3;
-      default:
-        throw new Error("Unsupported COP member type");
-    }
-  }
-  readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType) {
-    switch (memberType) {
-      case shared.MemberType.Byte:
-        return new shared.Byte(this._romDataReader.readByte());
-      case shared.MemberType.Word:
-        return new shared.Word(this._romDataReader.readUShort());
-      case shared.MemberType.Offset:
-        return this.createCopLocation(this._romDataReader.readUShort(), null, partStr, isPtr, referenceType, addrType);
-      case shared.MemberType.Address:
-        return this.createCopLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), partStr, isPtr, referenceType, addrType);
-      default:
-        throw new Error("Unsupported COP member type");
-    }
-  }
-  createCopLocation(offset, bank, partStr, isPtr, otherStr, type) {
-    if (bank === null && offset === 0) {
-      return new shared.Word(offset);
-    }
-    const addr = new shared.Address(bank ?? this._romDataReader.position >> 16, offset);
-    if (addr.space === shared.AddressSpace.ROM) {
-      const location = addr.toInt();
-      if (partStr !== "Address" && isPtr && !this._blockReader._root.rewrites[location]) {
-        this._blockReader.noteType(location, otherStr, true);
-      }
-      if (type === shared.AddressType.Unknown) {
-        type = this.tryParseAddressType(partStr) ?? shared.AddressType.Unknown;
-      }
-      return new shared.LocationWrapper(location, type);
-    }
-    return addr;
-  }
-  tryParseAddressType(addressTypeName) {
-    const upperName = addressTypeName.toUpperCase();
-    for (const [key, value] of Object.entries(shared.AddressType)) {
-      if (key.toUpperCase() === upperName) {
-        return value;
-      }
-    }
-    return null;
-  }
-};
-
-// src/rom/extraction/addressing.ts
-var OperationContext = class {
-  constructor() {
-    this.size = 0;
-    this.nextAddress = 0;
-    this.xForm1 = null;
-    this.xForm2 = null;
-    this.copDef = null;
-  }
-};
-var AddressingModeHandler = class {
-  constructor(blockReader, transformProcessor) {
-    this._blockReader = blockReader;
-    this._transformProcessor = transformProcessor;
-    this._copProcessor = new CopCommandProcessor(blockReader);
-    this._dataReader = blockReader._romDataReader;
-  }
-  processAddressingMode(code, context, reg) {
-    const operands = [];
-    switch (code.mode) {
-      case "Stack":
-      case "Implied":
-      case "Accumulator":
-        this.handleStackOrImpliedMode(code.mnem, reg);
-        break;
-      case "Immediate":
-        this.handleImmediateMode(code.mnem, context.size, operands, reg);
-        break;
-      case "AbsoluteIndexedIndirect":
-        this.handleAbsoluteMode(code.mnem, void 0, context.nextAddress, reg.dataBank, operands, reg, true);
-        break;
-      case "AbsoluteIndirect":
-      case "AbsoluteIndirectLong":
-      case "Absolute":
-      case "AbsoluteIndexedX":
-      case "AbsoluteIndexedY":
-        this.handleAbsoluteMode(code.mnem, void 0, context.nextAddress, reg.dataBank, operands, reg);
-        break;
-      case "AbsoluteLong":
-      case "AbsoluteLongIndexedX":
-        this.handleAbsoluteLongMode(code.mnem, operands, reg);
-        break;
-      case "BlockMove":
-        this.handleBlockMoveMode(operands, context);
-        break;
-      case "DirectPage":
-      case "DirectPageIndexedIndirectX":
-      case "DirectPageIndexedX":
-      case "DirectPageIndexedY":
-      case "DirectPageIndirect":
-      case "DirectPageIndirectIndexedY":
-      case "DirectPageIndirectLong":
-      case "DirectPageIndirectLongIndexedY":
-        this.handleDirectPageMode(operands);
-        break;
-      case "PCRelative":
-        this.handlePCRelativeMode(operands, context.nextAddress, reg, false);
-        break;
-      case "PCRelativeLong":
-        this.handlePCRelativeMode(operands, context.nextAddress, reg, true);
-        break;
-      case "StackRelative":
-      case "StackRelativeIndirectIndexedY":
-        this.handleStackRelativeMode(operands);
-        break;
-      case "StackInterrupt":
-        this.handleStackInterruptMode(code.mnem, operands, context);
-        break;
-      default:
-        throw new Error(`Unknown addressing mode: ${code}`);
-    }
-    return operands;
-  }
-  handleImmediateMode(mnemonic, size, operands, reg) {
-    const operand = this.readImmediateOperand(size);
-    operands.push(operand);
-    this.updateRegisterForImmediateInstruction(mnemonic, operand, reg);
-  }
-  readImmediateOperand(size) {
-    return size === 3 ? new shared.Word(this._dataReader.readUShort()) : new shared.Byte(this._dataReader.readByte());
-  }
-  updateRegisterForImmediateInstruction(mnemonic, operand, reg) {
-    const value = typeof operand === "number" ? operand : operand.value;
-    switch (mnemonic) {
-      case "LDA":
-        reg.accumulator = this.calculateRegisterValue(reg.accumulator, value);
-        break;
-      case "LDX":
-        reg.xIndex = this.calculateRegisterValue(reg.xIndex, value);
-        break;
-      case "LDY":
-        reg.yIndex = this.calculateRegisterValue(reg.yIndex, value);
-        break;
-      case "SEP":
-      case "REP":
-        this.updateStatusFlags(mnemonic, value);
-        break;
-    }
-  }
-  calculateRegisterValue(currentValue, operand) {
-    if (operand > 255) {
-      return operand;
-    } else {
-      return (currentValue ?? 0) & 65280 | operand;
-    }
-  }
-  updateStatusFlags(mnemonic, flagValue) {
-    const flag = flagValue;
-    const isSep = mnemonic === "SEP";
-    if (flag & shared.StatusFlags.AccumulatorMode) {
-      this._blockReader.AccumulatorFlags.set(this._dataReader.position, isSep);
-    }
-    if (flag & shared.StatusFlags.IndexMode) {
-      this._blockReader.IndexFlags.set(this._dataReader.position, isSep);
-    }
-  }
-  handleAbsoluteLongMode(mnemonic, operands, reg) {
-    const refLoc = this._dataReader.readUShort();
-    const bank = this._dataReader.readByte();
-    const address = new shared.Address(bank, refLoc);
-    if (address.space === shared.AddressSpace.ROM) {
-      const wrapper = new shared.LocationWrapper(address.toInt(), shared.AddressType.Address);
-      if (this.isJumpInstruction(mnemonic)) {
-        this._blockReader.noteType(wrapper.location, "Code", false, reg);
-      }
-      operands.push(wrapper);
-    } else {
-      operands.push(address);
-    }
-  }
-  handleBlockMoveMode(operands, context) {
-    operands.push(new shared.Byte(this._dataReader.readByte()));
-    context.xForm2 = this._transformProcessor.getTransform();
-    operands.push(new shared.Byte(this._dataReader.readByte()));
-  }
-  handleDirectPageMode(operands) {
-    operands.push(new shared.Byte(this._dataReader.readByte()));
-  }
-  handlePCRelativeMode(operands, nextAddress, reg, isLong) {
-    const relative = isLong ? nextAddress + this._dataReader.readShort() : nextAddress + this._dataReader.readSByte();
-    this._blockReader.noteType(relative, "Code", void 0, reg);
-    operands.push(new shared.LocationWrapper(relative, shared.AddressType.Relative));
-  }
-  handleStackRelativeMode(operands) {
-    operands.push(new shared.Byte(this._dataReader.readByte()));
-  }
-  handleStackInterruptMode(mnemonic, operands, context) {
-    const cmd = this._dataReader.readByte();
-    operands.push(new shared.Byte(cmd));
-    if (mnemonic === "COP") {
-      const copDef = this._blockReader._root.copDef[cmd];
-      if (!copDef) {
-        throw new Error("Unknown COP command");
-      }
-      context.copDef = copDef;
-      this._copProcessor.parseCopCommand(copDef, operands);
-    }
-  }
-  handleStackOrImpliedMode(mnemonic, reg) {
-    const stackOperations = new StackOperations(reg, this._blockReader);
-    stackOperations.handleStackOperation(mnemonic);
-  }
-  handleAbsoluteMode(mnemonic, xBank1, next, dataBank, operands, registers, isIndexedIndirect = false) {
-    let refLoc = this._dataReader.readUShort();
-    const isPush = this.isPushInstruction(mnemonic);
-    if (isPush) {
-      refLoc++;
-    }
-    const isJump = isPush || isIndexedIndirect || this.isJumpInstruction(mnemonic);
-    const bank = xBank1 ?? (isJump ? this._dataReader.position >> 16 : dataBank ?? 129);
-    const addr = new shared.Address(bank, refLoc);
-    if (addr.isROM) {
-      const wrapper = new shared.LocationWrapper(addr.toInt(), shared.AddressType.Offset);
-      if (isJump) {
-        const type = isIndexedIndirect ? "&Code" : "Code";
-        const name = this._blockReader.noteType(wrapper.location, type, isPush, registers);
-        if (isPush) {
-          operands.push(`&${name}-1`);
-          return;
-        }
-      }
-      operands.push(wrapper);
-    } else {
-      operands.push(addr);
-    }
-  }
-  isJumpInstruction(mnemonic) {
-    return mnemonic[0] === "J";
-  }
-  isPushInstruction(mnemonic) {
-    return mnemonic[0] === "P";
-  }
-};
-var TransformProcessor = class _TransformProcessor {
-  static {
-    // Location regex pattern: _([A-Fa-f0-9]{6})
-    this.LOCATION_REGEX = /_([A-Fa-f0-9]{6})/;
-  }
-  constructor(romReader) {
-    this._blockReader = romReader;
-    this._romDataReader = romReader._romDataReader;
-    this._referenceManager = romReader._referenceManager;
-    this._labelLookup = romReader._root.labels;
-  }
-  /**
-   * Retrieves transform information for the current ROM position
-   */
-  getTransform() {
-    const transform = this._labelLookup[this._romDataReader.position];
-    if (transform === "") {
-      return transform;
-    } else if (!transform) {
-      return null;
-    }
-    const transformName = this.cleanTransformName(transform);
-    const referenceLocation = this.resolveTransformReference(transformName);
-    if (referenceLocation !== null) {
-      this._blockReader.resolveInclude(referenceLocation, false);
-    }
-    return transform;
-  }
-  /**
-   * Applies transforms to operands
-   */
-  applyTransforms(op1Label, op2Label, operands) {
-    this.applyTransform(op1Label, 0, operands);
-    this.applyTransform(op2Label, 1, operands);
-  }
-  applyTransform(transform, operandIndex, operands) {
-    if (transform === null || transform === void 0 || operandIndex >= operands.length) {
-      return;
-    }
-    if (transform === "") {
-      this.applyDefaultTransform(operandIndex, operands);
-    } else {
-      operands[operandIndex] = transform;
-    }
-  }
-  applyDefaultTransform(operandIndex, operands) {
-    let value = this._romDataReader.position & 16711680;
-    const opnd = operands[operandIndex];
-    if (opnd && "value" in opnd) {
-      value |= opnd["value"];
-    } else {
-      value |= opnd;
-    }
-    const nameResult = this._referenceManager.tryGetName(value);
-    let referenceName;
-    if (!nameResult.found) {
-      referenceName = `loc_${value.toString(16).toUpperCase().padStart(6, "0")}`;
-      this._referenceManager.tryAddName(value, referenceName);
-    } else {
-      referenceName = nameResult.referenceName;
-    }
-    this._blockReader.resolveInclude(value, false);
-    operands[operandIndex] = `&${referenceName}`;
-  }
-  cleanTransformName(transform) {
-    let name = transform;
-    while (name.length > 0 && shared.RomProcessingConstants.ADDRESS_SPACE.includes(name[0])) {
-      name = name.substring(1);
-    }
-    let mathIndex = -1;
-    for (let i = 0; i < name.length; i++) {
-      if (shared.RomProcessingConstants.OPERATORS.includes(name[i])) {
-        mathIndex = i;
-        break;
-      }
-    }
-    if (mathIndex > 0) {
-      name = name.substring(0, mathIndex);
-    }
-    return name;
-  }
-  resolveTransformReference(transformName) {
-    const location = this._referenceManager.findLocationByName(transformName);
-    if (location !== void 0) {
-      return location;
-    }
-    const match = _TransformProcessor.LOCATION_REGEX.exec(transformName);
-    return match ? parseInt(match[1], 16) : null;
-  }
-};
-
-// src/utils/index.ts
-function indexOfAny(str, chars, startIndex = 0) {
-  for (let i = startIndex; i < str.length; i++) {
-    if (chars.includes(str[i])) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-// src/rom/extraction/strings.ts
-var StringReader = class _StringReader {
-  static {
-    this.STRING_REFERENCE_CHARACTERS = ["~", "^"];
-  }
-  constructor(blockReader) {
-    this._blockReader = blockReader;
-    this._romDataReader = blockReader._romDataReader;
-  }
-  resolveCommand(cmd, builder) {
-    if (cmd.types && cmd.types.length > 0) {
-      builder.push(`[${cmd.value}`);
-      let first = true;
-      for (const t of cmd.types) {
-        if (first) {
-          builder.push(":");
-          first = false;
-        } else {
-          builder.push(",");
-        }
-        switch (t) {
-          case shared.MemberType.Byte:
-            builder.push(this._romDataReader.readByte().toString(16).toUpperCase());
-            break;
-          case shared.MemberType.Word:
-            builder.push(this._romDataReader.readUShort().toString(16).toUpperCase());
-            break;
-          case shared.MemberType.Offset:
-            const loc = this._romDataReader.readUShort() | this._romDataReader.position & 4128768;
-            builder.push(`^${loc.toString(16).toUpperCase().padStart(6, "0")}`);
-            break;
-          case shared.MemberType.Address:
-            builder.push(`~${this._romDataReader.readAddress().toString(16).toUpperCase().padStart(6, "0")}`);
-            break;
-          case shared.MemberType.Binary:
-            let sfirst = true;
-            do {
-              const r = this._romDataReader.readByte();
-              if (cmd.delimiter !== void 0 && r === cmd.delimiter) {
-                break;
-              }
-              if (sfirst) {
-                sfirst = false;
-              } else {
-                builder.push(",");
-              }
-              builder.push(r.toString(16).toUpperCase());
-            } while (this._blockReader.partCanContinue());
-            break;
-          default:
-            throw new Error("Unsupported member type");
-        }
-      }
-      builder.push("]");
-    } else {
-      builder.push(`[${cmd.value}]`);
-    }
-  }
-  parseString(stringType) {
-    const dict = stringType.commands;
-    const builder = [];
-    const strLoc = this._romDataReader.position;
-    const map = stringType.characterMap;
-    const terminator = stringType.terminator;
-    do {
-      const c = this._romDataReader.readByte();
-      if (c === terminator) {
-        if (stringType.greedyTerminator) {
-          while (this._romDataReader.peekByte() === terminator && this._blockReader.partCanContinue()) {
-            this._romDataReader.position++;
-          }
-        }
-        break;
-      }
-      const cmd = dict[c];
-      if (cmd) {
-        this.resolveCommand(cmd, builder);
-        if (cmd.halt) {
-          break;
-        }
-      } else {
-        const index = this.shiftDown(c, stringType.shiftType);
-        if (index >= 0 && index < map.length) {
-          builder.push(map[index]);
-        } else {
-          builder.push(`[${c.toString(16).toUpperCase()}]`);
-        }
-      }
-    } while (this._blockReader.partCanContinue());
-    return {
-      string: builder.join(""),
-      type: stringType,
-      marker: 0,
-      location: strLoc
-    };
-  }
-  /**
-   * Handles character shifting based on string type
-   * This is a simplified implementation of the shift logic
-   */
-  shiftDown(c, shiftType) {
-    if (!shiftType) {
-      return c;
-    }
-    switch (shiftType) {
-      case "wh2":
-        return (c & 112) >> 1 | c & 7;
-      case "h2":
-        return (c & 224) >> 1 | c & 15;
-      default:
-        return c;
-    }
-  }
-  resolveString(sw, isBranch) {
-    let str = sw.string;
-    let ix = indexOfAny(str, _StringReader.STRING_REFERENCE_CHARACTERS);
-    while (ix >= 0) {
-      if (ix + 6 < str.length) {
-        const hexStr = str.substring(ix + 1, ix + 7);
-        const sloc = parseInt(hexStr, 16);
-        if (!isNaN(sloc)) {
-          const addrs = new shared.Address(sloc >> 16, sloc & 65535);
-          if (addrs.space === shared.AddressSpace.ROM) {
-            this._blockReader.resolveInclude(sloc, false);
-            const name = this._blockReader.resolveName(sloc, shared.AddressType.Unknown, false);
-            const opix = indexOfAny(name, shared.RomProcessingConstants.OPERATORS);
-            if (opix > 0) {
-              const offsetStr = name.substring(opix + 1);
-              let offset;
-              if (offsetStr === "M") {
-                offset = this._blockReader._referenceManager.markerTable.get(sloc) || 0;
-              } else {
-                offset = parseInt(offsetStr, 16) || 0;
-              }
-              if (name[opix] === "-") {
-                offset = -offset;
-              }
-              name.substring(0, opix);
-              const target = sloc - offset;
-              const [isOutside, block, part] = shared.ChunkFileUtils.isOutsideWithPart(this._blockReader._enrichedChunks, this._blockReader._currentChunk, sloc);
-              if (part != null) {
-                const entry = part.objList?.find((x) => typeof x === "object" && x !== null && "location" in x && "object" in x && x.location === target);
-                if (entry && entry.object) {
-                  entry.object.marker = offset;
-                }
-              }
-            }
-          }
-        }
-      }
-      ix = indexOfAny(str, _StringReader.STRING_REFERENCE_CHARACTERS, ix + 7);
-    }
-  }
-};
-var TypeParser = class {
-  constructor(blockReader) {
-    this._blockReader = blockReader;
-    this._referenceManager = blockReader._referenceManager;
-    this._romDataReader = blockReader._romDataReader;
-    this._stringReader = blockReader._stringReader;
-    this._stringTypes = blockReader._root.stringTypes;
-  }
-  parseType(typeName, reg, depth, bank) {
-    if (typeName[0] === "&") {
-      return this.parseLocation(this._romDataReader.readUShort(), bank, typeName.substring(1), shared.AddressType.Offset);
-    }
-    if (typeName[0] === "@") {
-      return this.parseLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), typeName.substring(1), shared.AddressType.Address);
-    }
-    const stringType = this._stringTypes[typeName];
-    if (stringType) {
-      return this._stringReader.parseString(stringType);
-    }
-    const mType = this.tryParseMemberType(typeName);
-    if (mType !== null) {
-      switch (mType) {
-        case shared.MemberType.Byte:
-          return new shared.Byte(this._romDataReader.readByte());
-        case shared.MemberType.Word:
-          return new shared.Word(this.parseWordSafe());
-        case shared.MemberType.Offset:
-          return this.parseLocation(this._romDataReader.readUShort(), bank, null, shared.AddressType.Offset);
-        case shared.MemberType.Address:
-          return this.parseLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), null, shared.AddressType.Address);
-        case shared.MemberType.Binary:
-          return this.parseBinary();
-        case shared.MemberType.Code:
-          return this.parseCode(reg);
-        default:
-          throw new Error("Invalid member type");
-      }
-    }
-    const parentType = this._blockReader._root.structs[typeName];
-    if (!parentType) {
-      throw new Error(`Unknown type: ${typeName}`);
-    }
-    const delimiter = parentType.delimiter;
-    const discOffset = parentType.discriminator;
-    const objects = [];
-    let delReached;
-    while (!(delReached = this._blockReader.delimiterReached(delimiter))) {
-      const startPosition = this._romDataReader.position;
-      let targetType = parentType;
-      if (discOffset !== void 0) {
-        const discPosition = this._romDataReader.position + discOffset;
-        const desc = this._romDataReader.romData[discPosition];
-        if (discOffset === 0) {
-          this._romDataReader.position++;
-        }
-        const matchedStruct = Object.values(this._blockReader._root.structs).find(
-          (x) => x.parent === typeName && x.discriminator === desc
-        );
-        targetType = matchedStruct || parentType;
-      }
-      const types = targetType.types;
-      if (types && types.length > 0) {
-        const memberCount = types.length;
-        const prevPosition = this._romDataReader.position;
-        const parts = new Array(memberCount);
-        const def = { name: targetType.name, parts };
-        for (let i = 0; i < memberCount; i++) {
-          parts[i] = this.parseType(types[i], null, depth + 1, bank);
-        }
-        if (discOffset !== void 0 && discOffset === this._romDataReader.position - prevPosition) {
-          this._romDataReader.position++;
-        }
-        objects.push(def);
-      }
-      let checkPosition = startPosition;
-      while (++checkPosition < this._romDataReader.position) {
-        if (this._referenceManager.containsStruct(checkPosition)) {
-          this._romDataReader.position = checkPosition;
-          break;
-        }
-      }
-      if (!this._blockReader.partCanContinue()) {
-        break;
-      }
-    }
-    if (delReached && depth === 0) {
-      this._referenceManager.tryAddStruct(this._romDataReader.position, typeName);
-    }
-    return objects;
-  }
-  tryParseMemberType(memberTypeName) {
-    const upperName = memberTypeName.toUpperCase();
-    for (const [key, value] of Object.entries(shared.MemberType)) {
-      if (key.toUpperCase() === upperName) {
-        return value;
-      }
-    }
-    return null;
-  }
-  parseWordSafe() {
-    return this._referenceManager.containsStruct(this._romDataReader.position + 1) ? this._romDataReader.readByte() : this._romDataReader.readUShort();
-  }
-  parseBinary() {
-    const startPosition = this._romDataReader.position;
-    do {
-      this._romDataReader.position++;
-    } while (this._blockReader.partCanContinue());
-    const len = this._romDataReader.position - startPosition;
-    const outBuffer = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-      outBuffer[i] = this._romDataReader.romData[startPosition + i];
-    }
-    return outBuffer;
-  }
-  parseLocation(offset, bank, typeName, addrType) {
-    if ((bank === void 0 || bank === null) && offset === 0) {
-      return new shared.Word(offset);
-    }
-    const resolvedBank = bank ?? this._romDataReader.position >> 16;
-    const adrs = new shared.Address(resolvedBank, offset);
-    if (adrs.space !== shared.AddressSpace.ROM) {
-      return adrs;
-    }
-    const loc = adrs.toInt();
-    if (this._blockReader._currentChunk && shared.ChunkFileUtils.isInside(this._blockReader._currentChunk, loc) && !this._blockReader._root.rewrites[loc]) {
-      const resolvedTypeName = typeName ?? this._blockReader._currentAsmBlock.structName ?? "Binary";
-      this._referenceManager.tryAddStruct(loc, resolvedTypeName);
-      const referenceName = `${resolvedTypeName.toLowerCase()}_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
-      this._referenceManager.tryAddName(loc, referenceName);
-    }
-    return new shared.LocationWrapper(loc, addrType);
-  }
-  parseCode(reg) {
-    const opList = [];
-    let first = true;
-    while (this._romDataReader.position < this._blockReader._partEnd) {
-      if (first) {
-        first = false;
-      } else if (this._referenceManager.containsStruct(this._romDataReader.position)) {
-        break;
-      }
-      if (reg) {
-        this._blockReader.hydrateRegisters(reg);
-      }
-      const op = this._blockReader._asmReader.parseAsm(reg);
-      opList.push(op);
-    }
-    return opList;
-  }
-};
-var AsmReader = class _AsmReader {
-  static {
-    // Constants
-    this.PROCESSOR_FLAG_MASK = 223;
-  }
-  static {
-    this.ACCUMULATOR_OP_MASK = 15;
-  }
-  static {
-    this.ACCUMULATOR_OP_VALUE = 9;
-  }
-  static {
-    this.VARIABLE_SIZE_INDICATOR = -2;
-  }
-  static {
-    this.TWO_BYTES_SIZE = 2;
-  }
-  static {
-    this.THREE_BYTES_SIZE = 3;
-  }
-  constructor(blockReader) {
-    this._blockReader = blockReader;
-    this._transformProcessor = new TransformProcessor(blockReader);
-    this._addressingModeHandler = new AddressingModeHandler(blockReader, this._transformProcessor);
-    this._romDataReader = blockReader._romDataReader;
-  }
-  parseAsm(reg) {
-    const opStart = this._romDataReader.position;
-    const opCode = this._romDataReader.readByte();
-    const code = this._blockReader._root.opCodes[opCode];
-    if (!code) {
-      throw new Error("Unknown OpCode");
-    }
-    const operationContext = this.initializeOperation(code, reg, opStart);
-    const operands = this._addressingModeHandler.processAddressingMode(code, operationContext, reg);
-    this._transformProcessor.applyTransforms(operationContext.xForm1, operationContext.xForm2, operands);
-    const op = new shared.Op(
-      code,
-      opStart,
-      operands,
-      this._romDataReader.position - opStart
-    );
-    if (operationContext.copDef) {
-      op.copDef = operationContext.copDef;
-    }
-    return op;
-  }
-  clearDestinationRegister(code, reg) {
-    switch (code.mnem) {
-      case "LDA":
-        reg.accumulator = void 0;
-        break;
-      case "LDX":
-        reg.xIndex = void 0;
-        break;
-      case "LDY":
-        reg.yIndex = void 0;
-        break;
-    }
-  }
-  initializeOperation(code, reg, loc) {
-    const size = this.calculateInstructionSize(code, reg);
-    const next = loc + size;
-    this.clearDestinationRegister(code, reg);
-    const context = new OperationContext();
-    context.size = size;
-    context.nextAddress = next;
-    context.xForm1 = this._transformProcessor.getTransform();
-    context.xForm2 = null;
-    context.copDef = null;
-    return context;
-  }
-  calculateInstructionSize(code, reg) {
-    const addrMode = this._blockReader._root.addrLookup[code.mode];
-    let size = addrMode.size;
-    if (size === _AsmReader.VARIABLE_SIZE_INDICATOR || code.mode === "Immediate") {
-      if ((code.code & _AsmReader.PROCESSOR_FLAG_MASK) === 194) {
-        size = _AsmReader.TWO_BYTES_SIZE;
-      } else if ((code.code & _AsmReader.ACCUMULATOR_OP_MASK) === _AsmReader.ACCUMULATOR_OP_VALUE) {
-        size = reg.accumulatorFlag ?? false ? _AsmReader.TWO_BYTES_SIZE : _AsmReader.THREE_BYTES_SIZE;
-      } else {
-        size = reg.indexFlag ?? false ? _AsmReader.TWO_BYTES_SIZE : _AsmReader.THREE_BYTES_SIZE;
-      }
-    }
-    return size;
-  }
-};
-
-// src/assembly/Stack.ts
-var Stack = class {
-  constructor() {
-    this.bytes = new Uint8Array(70);
-    this.location = 10;
-  }
-  /**
-   * Push a byte onto the stack
-   */
-  push(value) {
-    this.bytes[this.location++] = value & 255;
-  }
-  /**
-   * Push a 16-bit value onto the stack (little-endian)
-   */
-  pushUInt16(value) {
-    this.bytes[this.location++] = value & 255;
-    this.bytes[this.location++] = value >> 8 & 255;
-  }
-  /**
-   * Pop a byte from the stack
-   */
-  popByte() {
-    return this.bytes[--this.location];
-  }
-  /**
-   * Pop a 16-bit value from the stack (little-endian)
-   */
-  popUInt16() {
-    const high = this.bytes[--this.location];
-    const low = this.bytes[--this.location];
-    return high << 8 | low;
-  }
-  /**
-   * Reset the stack to initial state
-   */
-  reset() {
-    this.bytes.fill(0);
-    this.location = 10;
-  }
-};
-var Registers = class {
-  constructor() {
-    this.stack = new Stack();
-  }
-  /**
-   * Get the current status flags
-   */
-  get statusFlags() {
-    let flags = 0;
-    if (this.accumulatorFlag ?? false) {
-      flags |= shared.StatusFlags.AccumulatorMode;
-    }
-    if (this.indexFlag ?? false) {
-      flags |= shared.StatusFlags.IndexMode;
-    }
-    return flags;
-  }
-  /**
-   * Set the status flags
-   */
-  set statusFlags(value) {
-    this.accumulatorFlag = (value & shared.StatusFlags.AccumulatorMode) !== 0;
-    this.indexFlag = (value & shared.StatusFlags.IndexMode) !== 0;
-  }
-  /**
-   * Reset all registers to initial state
-   */
-  reset() {
-    this.accumulatorFlag = void 0;
-    this.indexFlag = void 0;
-    this.direct = void 0;
-    this.dataBank = void 0;
-    this.accumulator = void 0;
-    this.xIndex = void 0;
-    this.yIndex = void 0;
-    this.stack.reset();
-  }
-};
-var QuintetLZ = class _QuintetLZ {
-  static {
-    this.DICTIONARY_SIZE = 256;
-  }
-  static {
-    this.DICTIONARY_INIT = 32;
-  }
-  static {
-    this.DICTIONARY_OFFSET = 239;
-  }
-  static {
-    this.DEFAULT_PAGE_SIZE = 32768;
-  }
-  /**
-   * Expand (decompress) data using QuintetLZ algorithm
-   * @param srcData Source data buffer
-   * @param srcPosition Starting position in source data
-   * @param srcLen Length of source data to process
-   * @returns Expanded data
-   */
-  expand(srcData, srcPosition = 0, srcLen = _QuintetLZ.DEFAULT_PAGE_SIZE) {
-    const bitStream = new shared.BitStream(srcData, srcPosition);
-    const srcStop = srcPosition + srcLen;
-    const dictionary = new Uint8Array(_QuintetLZ.DICTIONARY_SIZE);
-    dictionary.fill(_QuintetLZ.DICTIONARY_INIT);
-    let dictPosition = _QuintetLZ.DICTIONARY_OFFSET;
-    let outPosition = 0;
-    let dstLen = bitStream.readShort();
-    if (dstLen === 0) {
-      return srcData.slice(srcPosition + 2, srcStop);
-    } else if (dstLen & 32768) {
-      dstLen = 65536 - dstLen;
-    }
-    const outBuffer = new Uint8Array(dstLen);
-    while (bitStream.currentPosition < srcStop && outPosition < dstLen) {
-      if (bitStream.readBit()) {
-        const sample = bitStream.readByte();
-        if (outPosition < dstLen) {
-          outBuffer[outPosition++] = sample;
-        }
-        dictionary[dictPosition] = sample;
-        dictPosition = dictPosition + 1 & 255;
-      } else {
-        let wordIndex = bitStream.readByte();
-        let wordLength = bitStream.readNibble() + 2;
-        while (wordLength-- > 0) {
-          const sample = dictionary[wordIndex];
-          wordIndex = wordIndex + 1 & 255;
-          if (outPosition < dstLen) {
-            outBuffer[outPosition++] = sample;
-          }
-          dictionary[dictPosition] = sample;
-          dictPosition = dictPosition + 1 & 255;
-        }
-      }
-    }
-    if (outPosition < dstLen) {
-      return outBuffer.slice(0, outPosition);
-    }
-    return outBuffer;
-  }
-  /**
-   * Compact (compress) data using QuintetLZ algorithm
-   * @param srcData Source data to compress
-   * @returns Compressed data
-   */
-  compact(srcData) {
-    const dictionary = new Uint8Array(_QuintetLZ.DICTIONARY_SIZE);
-    dictionary.fill(_QuintetLZ.DICTIONARY_INIT);
-    let offset = _QuintetLZ.DICTIONARY_OFFSET;
-    let srcIx = 0;
-    let dstIx = 0;
-    const srcLen = srcData.length;
-    const outputBuffer = new Uint8Array(srcLen * 2);
-    outputBuffer[dstIx++] = srcLen & 255;
-    outputBuffer[dstIx++] = srcLen >> 8 & 255;
-    const bitStream = new shared.BitStream(outputBuffer, 2);
-    const getCommand = () => {
-      const maxLen = Math.min(srcLen - srcIx, 17);
-      if (maxLen < 2) {
-        return [0, 0];
-      }
-      let startByte = 0;
-      let bestLen = 0;
-      let bx = offset;
-      for (let i = 0; i < 256; i++, bx = bx + 1 & 255) {
-        let size = 0;
-        let bix = bx;
-        while (size < maxLen && dictionary[bix] === srcData[srcIx + size]) {
-          bix = bix + 1 & 255;
-          if (bix === offset) {
-            bix = bx;
-          }
-          size++;
-        }
-        if (size > bestLen) {
-          startByte = bx;
-          bestLen = size;
-          if (bestLen >= maxLen) {
-            break;
-          }
-        }
-      }
-      return [startByte, bestLen];
-    };
-    while (srcIx < srcLen) {
-      const [cmdStart, cmdLen] = getCommand();
-      if (cmdLen >= 2) {
-        bitStream.writeBit(false);
-        bitStream.writeByte(cmdStart);
-        bitStream.writeNibble(cmdLen - 2);
-        for (let i = 0; i < cmdLen; i++) {
-          dictionary[offset] = srcData[srcIx++];
-          offset = offset + 1 & 255;
-        }
-      } else {
-        bitStream.writeBit(true);
-        const val = srcData[srcIx++];
-        bitStream.writeByte(val);
-        dictionary[offset] = val;
-        offset = offset + 1 & 255;
-      }
-    }
-    bitStream.flush();
-    const finalSize = Math.max(dstIx, bitStream.currentPosition);
-    return outputBuffer.slice(0, finalSize);
-  }
-};
-
-// src/compression/registry.ts
-function registerCompressionProviders() {
-  shared.CompressionRegistry.register("QuintetLZ", () => new QuintetLZ());
-}
-registerCompressionProviders();
-
-// src/rom/extraction/blocks.ts
-registerCompressionProviders();
-var BlockReader = class {
-  constructor(romData, root) {
-    // Current Processing State (Database)
-    //public _currentBlock!: DbBlock;
-    //public _currentPart: DbPart | null = null;
-    this._partEnd = 0;
-    // ChunkFile Processing State
-    this._currentChunk = null;
-    this._currentAsmBlock = null;
-    this._enrichedChunks = [];
-    this._romDataReader = new RomDataReader(romData);
-    this._stateManager = new ProcessorStateManager();
-    this._referenceManager = new ReferenceManager(root);
-    this._root = root;
-    this._stringReader = new StringReader(this);
-    this._asmReader = new AsmReader(this);
-    this._typeParser = new TypeParser(this);
-    this.initializeOverrides();
-    this.initializeFileReferences();
-  }
-  static {
-    // Constants
-    this.REF_SEARCH_MAX_RANGE = 416;
-  }
-  static {
-    this.BANK_MASK_CHECK = 64;
-  }
-  static {
-    this.BYTE_DELIMITER_THRESHOLD = 256;
-  }
-  static {
-    this.BANK_HIGH_MEMORY_1 = 126;
-  }
-  static {
-    this.BANK_HIGH_MEMORY_2 = 127;
-  }
-  static {
-    this.POINTER_CHARACTERS = ["&", "@"];
-  }
-  static {
-    // Location regex pattern: _([A-Fa-f0-9]{6})
-    this.LOCATION_REGEX = /_([A-Fa-f0-9]{6})/;
-  }
-  // Backward Compatibility Properties
-  get AccumulatorFlags() {
-    return this._stateManager.accumulatorFlags;
-  }
-  get IndexFlags() {
-    return this._stateManager.indexFlags;
-  }
-  get BankNotes() {
-    return this._stateManager.bankNotes;
-  }
-  get StackPosition() {
-    return this._stateManager.stackPositions;
-  }
-  // Direct access to reference management collections
-  get _structTable() {
-    return this._referenceManager.structTable;
-  }
-  get _markerTable() {
-    return this._referenceManager.markerTable;
-  }
-  get _nameTable() {
-    return this._referenceManager.nameTable;
-  }
-  /**
-   * Processes predefined overrides for registers and bank notes
-   */
-  initializeOverrides() {
-    for (const over of Object.values(this._root.overrides)) {
-      switch (over.register) {
-        case shared.RegisterType.M:
-          this._stateManager.setAccumulatorFlag(over.location, over.value === 1);
-          break;
-        case shared.RegisterType.X:
-          this._stateManager.setIndexFlag(over.location, over.value === 1);
-          break;
-        case shared.RegisterType.B:
-          this._stateManager.setBankNote(over.location, over.value);
-          break;
-      }
-    }
-  }
-  /**
-   * Processes predefined file references
-   */
-  initializeFileReferences() {
-    for (const file of this._root.files) {
-      this._referenceManager.tryAddName(file.start, file.name);
-    }
-  }
-  /**
-   * Resolves mnemonic for a given address
-   */
-  resolveMnemonic(addr) {
-    if ((addr.bank & shared.Address.DATA_BANK_FLAG) !== 0) {
-      return;
-    }
-    let offset = addr.offset;
-    const label = this._root.mnemonics[offset];
-    if (!label) {
-      return;
-    }
-    const ix = indexOfAny(label, shared.RomProcessingConstants.OPERATORS);
-    if (ix >= 0) {
-      let opnd = parseInt(label.substring(ix + 1), 16);
-      const op = label[ix];
-      if (op === "-")
-        opnd = -opnd;
-      offset -= opnd;
-    }
-    this._currentChunk.mnemonics[offset] = label.substring(0, ix >= 0 ? ix : label.length);
-  }
-  /**
-   * Resolves name for a location (delegated to ReferenceManager)
-   */
-  resolveName(location, type, isBranch) {
-    return this._referenceManager.resolveName(location, type, isBranch);
-  }
-  /**
-   * Resolves include for a location
-   */
-  resolveInclude(loc, isBranch) {
-    const [outside, foundBlock, foundPart] = shared.ChunkFileUtils.isOutsideWithPart(this._enrichedChunks, this._currentChunk, loc);
-    if (outside && foundBlock && foundPart) {
-      this._currentAsmBlock.includes.add({ block: foundBlock, part: foundPart });
-    } else if (isBranch && !this._referenceManager.tryGetName(loc).found) {
-      const name = `loc_${loc.toString(16).toUpperCase().padStart(6, "0")}`;
-      this._referenceManager.tryAddName(loc, name);
-    }
-  }
-  /**
-   * Notes a type at a location and manages chunk references
-   */
-  noteType(loc, type, silent = false, reg) {
-    this._referenceManager.tryAddStruct(loc, type);
-    const nameResult = this._referenceManager.tryGetName(loc);
-    let name;
-    if (!nameResult.found) {
-      name = this._referenceManager.createTypeName(type, loc);
-      this._referenceManager.tryAddName(loc, name);
-    } else {
-      name = nameResult.referenceName;
-    }
-    if (!silent && type === shared.BlockReaderConstants.CODE_TYPE && reg) {
-      this.updateRegisterState(loc, reg);
-    }
-    return name;
-  }
-  updateRegisterState(loc, reg) {
-    if (reg.accumulatorFlag !== void 0) {
-      this._stateManager.tryAddAccumulatorFlag(loc, reg.accumulatorFlag);
-    }
-    if (reg.indexFlag !== void 0) {
-      this._stateManager.tryAddIndexFlag(loc, reg.indexFlag);
-    }
-    if (reg.stack.location > 0) {
-      this._stateManager.tryAddStackPosition(loc, reg.stack.location);
-    }
-  }
-  /**
-   * Checks if a delimiter has been reached
-   */
-  delimiterReached(delimiter) {
-    if (delimiter === void 0) {
-      return false;
-    }
-    if (delimiter >= shared.BlockReaderConstants.BYTE_DELIMITER_THRESHOLD) {
-      if (this._romDataReader.peekShort() === delimiter) {
-        this._romDataReader.position += 2;
-        return true;
-      }
-    } else if (this._romDataReader.peekByte() === delimiter) {
-      this._romDataReader.position++;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Checks if processing of the current part can continue
-   */
-  partCanContinue() {
-    return this._romDataReader.position < this._partEnd && !this._referenceManager.containsStruct(this._romDataReader.position);
-  }
-  analyzeAndResolve() {
-    this.createChunkFilesFromDatabase();
-    this.initializeBlocksAndParts();
-    this.analyzeChunkFiles();
-    this.resolveReferences();
-    return this._enrichedChunks;
-  }
-  /**
-   * Analyzes all blocks in the ROM
-   */
-  // private analyzeBlocks(): void {
-  //   this.initializeBlocksAndParts();
-  //   for (const chunk of this._enrichedChunks) {
-  //     this._currentChunk = chunk;
-  //     for (const part of chunk.parts || []) {
-  //       this.processPart(part);
-  //     }
-  //   }
-  // }
-  /**
-   * Initializes blocks and parts with base references
-   */
-  initializeBlocksAndParts() {
-    for (const block of this._enrichedChunks) {
-      for (const part of block.parts || []) {
-        if (part.structName) {
-          this._referenceManager.tryAddStruct(part.location, part.structName);
-        }
-        if (part.label) {
-          this._referenceManager.tryAddName(part.location, part.label);
-        }
-      }
-    }
-  }
-  /**
-   * Processes a single part
-   */
-  processPart(part) {
-    this._currentAsmBlock = part;
-    this._romDataReader.position = part.location;
-    this._partEnd = part.location + part.size;
-    let current = part.structName || shared.BlockReaderConstants.BINARY_TYPE;
-    const chunks = [];
-    const reg = new Registers();
-    const bank = part.bank;
-    let last = null;
-    while (this._romDataReader.position < this._partEnd) {
-      const structResult = this._referenceManager.tryGetStruct(this._romDataReader.position);
-      if (structResult.found) {
-        current = structResult.chunkType;
-      } else if (last !== null) {
-        this.processContinuousEntry(current, reg, bank, last);
-        continue;
-      }
-      last = shared.createTableEntry(this._romDataReader.position);
-      chunks.push(last);
-      this.processNewEntry(current, reg, bank, last);
-    }
-    part.objList = chunks;
-  }
-  /**
-   * Processes a continuous entry (same type as previous)
-   */
-  processContinuousEntry(current, reg, bank, last) {
-    const obj = this._typeParser.parseType(current, reg, 0, bank);
-    if (!Array.isArray(last.object)) {
-      last.object = [last.object];
-    }
-    last.object.push(obj);
-  }
-  /**
-   * Processes a new entry
-   */
-  processNewEntry(current, reg, bank, last) {
-    let res = this._typeParser.parseType(current, reg, 0, bank);
-    if (shared.BlockReaderConstants.POINTER_CHARACTERS.includes(current[0]) && !Array.isArray(res)) {
-      res = [res];
-    }
-    last.object = res;
-  }
-  /**
-   * Creates ChunkFile objects from database structure
-   */
-  createChunkFilesFromDatabase() {
-    this._enrichedChunks = [];
-    this.createChunkFilesFromSfx();
-    this.createChunkFilesFromDbFiles();
-    this.createChunkFilesFromDbBlocks();
-  }
-  /**
-   * Creates binary ChunkFiles from DbFiles (enriched with rawData)
-   */
-  createChunkFilesFromSfx() {
-    let pos = this._root.config.sfxLocation;
-    const count = this._root.config.sfxCount;
-    const romData = this._romDataReader.romData;
-    const getSize = () => romData[pos++] | romData[pos++] << 8;
-    for (let i = 0; i < count; i++) {
-      const size = getSize();
-      const startPos = pos;
-      let remaining = size;
-      let end = pos + remaining;
-      let data;
-      if (end & shared.RomProcessingConstants.PAGE_SIZE) {
-        const endLen = end & 32767;
-        remaining -= endLen;
-        data = romData.slice(pos, pos + remaining);
-        pos += remaining + shared.RomProcessingConstants.PAGE_SIZE;
-        end = pos + endLen;
-        const data2 = romData.slice(pos, end);
-        data = new Uint8Array([...data, ...data2]);
-      } else {
-        data = romData.slice(pos, end);
-      }
-      pos = end;
-      const chunk = new shared.ChunkFile(`sfx${i.toString(16).toUpperCase().padStart(2, "0")}`, size, startPos, shared.BinType.Sound);
-      chunk.rawData = data;
-      this._enrichedChunks.push(chunk);
-    }
-  }
-  /**
-   * Creates binary ChunkFiles from DbFiles (enriched with rawData)
-   */
-  createChunkFilesFromDbFiles() {
-    for (const dbFile of this._root.files) {
-      const chunkFile = shared.createChunkFileFromDbFile(this._romDataReader.romData, this._root.compression, dbFile);
-      this._enrichedChunks.push(chunkFile);
-    }
-  }
-  /**
-   * Creates assembly ChunkFiles from DbBlocks (enriched with parts)
-   */
-  createChunkFilesFromDbBlocks() {
-    for (const block of this._root.blocks) {
-      const chunkFile = shared.createChunkFileFromDbBlock(block);
-      this._enrichedChunks.push(chunkFile);
-    }
-  }
-  /**
-   * Analyzes only assembly ChunkFiles (those with parts from DbBlocks)
-   */
-  analyzeChunkFiles() {
-    const assemblyChunks = this._enrichedChunks.filter((chunk) => chunk.type === shared.BinType.Assembly);
-    for (const chunkFile of assemblyChunks) {
-      this._currentChunk = chunkFile;
-      for (const asmBlock of chunkFile.parts || []) {
-        this._currentAsmBlock = asmBlock;
-        this.processPart(asmBlock);
-      }
-    }
-  }
-  // /**
-  //  * Processes a single AsmBlock (similar to processPart)
-  //  */
-  // private processAsmBlock(asmBlock: AsmBlock): void {
-  //   this._romDataReader.position = asmBlock.location;
-  //   this._partEnd = asmBlock.location + asmBlock.size;
-  //   let current = asmBlock.structName || BlockReaderConstants.BINARY_TYPE;
-  //   const chunks: TableEntry[] = [];
-  //   const reg = new Registers();
-  //   const bank = this._currentAsmBlock?.bank;
-  //   let last: TableEntry | null = null;
-  //   while (this._romDataReader.position < this._partEnd) {
-  //     const structResult = this._referenceManager.tryGetStruct(this._romDataReader.position);
-  //     if (structResult.found) {
-  //       current = structResult.chunkType!;
-  //     } else if (last !== null) {
-  //       this.processContinuousEntry(current, reg, bank, last);
-  //       continue;
-  //     }
-  //     last = createTableEntry(this._romDataReader.position);
-  //     chunks.push(last);
-  //     this.processNewEntry(current, reg, bank, last);
-  //   }
-  //   asmBlock.objList = chunks;
-  // }
-  /**
-   * Resolves references in assembly ChunkFiles only
-   */
-  resolveReferences() {
-    for (const chunkFile of this._enrichedChunks) {
-      this._currentChunk = chunkFile;
-      for (const asmBlock of chunkFile.parts || []) {
-        this._currentAsmBlock = asmBlock;
-        this.resolveObject(asmBlock.objList, false);
-      }
-    }
-  }
-  /**
-   * Resolves a single object and its references
-   */
-  resolveObject(obj, isBranch) {
-    if (typeof obj === "string") {
-      return;
-    }
-    if (Array.isArray(obj)) {
-      for (const o of obj) {
-        this.resolveObject(o, isBranch);
-      }
-      return;
-    }
-    if (obj instanceof shared.Address) {
-      this.resolveMnemonic(obj);
-      return;
-    }
-    if (typeof obj === "number") {
-      this.resolveInclude(obj, isBranch);
-      return;
-    }
-    if (obj instanceof shared.LocationWrapper) {
-      this.resolveInclude(obj.location, isBranch);
-      return;
-    }
-    if (obj && typeof obj === "object") {
-      if ("string" in obj && "type" in obj) {
-        this._stringReader.resolveString(obj, isBranch);
-        return;
-      }
-      if ("name" in obj && "parts" in obj) {
-        this.resolveObject(obj.parts, isBranch);
-        return;
-      }
-      if ("location" in obj && "object" in obj) {
-        this.resolveObject(obj.object, isBranch);
-        return;
-      }
-      if ("code" in obj && "operands" in obj) {
-        this.resolveOperationObject(obj);
-        return;
-      }
-    }
-  }
-  /**
-   * Resolves references in an operation object
-   */
-  resolveOperationObject(op) {
-    const branch = this.isBranchOperation(op);
-    for (const opnd of op.operands) {
-      this.resolveObject(opnd, branch);
-    }
-  }
-  /**
-   * Checks if an operation is a branch operation
-   */
-  isBranchOperation(op) {
-    return op.mode === "PCRelative" || op.mode === "PCRelativeLong" || op.mnem[0] === "J";
-  }
-  /**
-   * Hydrates registers with stored state
-   */
-  hydrateRegisters(reg) {
-    this._stateManager.hydrateRegisters(this._romDataReader.position, reg);
-  }
-};
-var PostProcessor = class {
-  constructor(reader) {
-    this._referenceManager = reader._referenceManager;
-  }
-  /**
-   * Execute post process directive on a block if present.
-   */
-  process(block) {
-    if (!block.postProcess || block.postProcess.trim() === "") {
-      return;
-    }
-    let signature = block.postProcess;
-    const parts = [];
-    const index = signature.indexOf("(");
-    if (index > 0) {
-      const endIx = signature.indexOf(")", index);
-      const params = signature.substring(
-        index + 1,
-        endIx >= 0 ? endIx : signature.length
-      );
-      if (params.length > 0) {
-        for (const p of params.split(",")) {
-          parts.push(p.trim());
-        }
-      }
-      signature = signature.substring(0, index);
-    }
-    const fn = this[signature];
-    if (typeof fn !== "function") {
-      throw new Error(`Unable to locate postprocess function ${signature}`);
-    }
-    fn.apply(this, [block, ...parts]);
-  }
-  /**
-   * Builds a lookup table from struct entries.
-   * Equivalent to PostProcessor.Lookup in C# implementation.
-   */
-  Lookup(block, keyIx, valueIx) {
-    const kix = parseInt(keyIx.trim());
-    const vix = parseInt(valueIx.trim());
-    if (!block.parts || block.parts.length === 0) {
-      throw new Error("Invalid block structure for Lookup post process");
-    }
-    const table = block.parts[0]?.objList;
-    const tableEntry = table && table[0];
-    const entries = tableEntry?.object;
-    if (!tableEntry || !entries) {
-      throw new Error("Invalid table structure for Lookup post process");
-    }
-    const newParts = [];
-    const newList = [];
-    newParts.push({ location: tableEntry.location, object: newList });
-    let eIx = 1;
-    for (const entry of entries) {
-      if (!entry || !Array.isArray(entry.parts)) {
-        continue;
-      }
-      const struct = entry;
-      let cIx = 0;
-      let key = null;
-      let value = null;
-      for (const obj of struct.parts) {
-        if (cIx === kix) {
-          if (obj && typeof obj === "object" && "value" in obj) {
-            key = obj.value;
-          } else {
-            key = obj;
-          }
-        } else if (cIx === vix) {
-          value = obj;
-        }
-        cIx++;
-      }
-      if (key === null || value === null) {
-        throw new Error("Could not locate key or value for transform");
-      }
-      const name = `entry_${key.toString(16).toUpperCase().padStart(2, "0")}`;
-      const loc = tableEntry.location + eIx;
-      newParts.push({ location: loc, object: value });
-      this._referenceManager.nameTable.set(loc, name);
-      while (newList.length <= key) {
-        newList.push(new shared.Word(0));
-      }
-      newList[key] = `&${name}`;
-      eIx++;
-    }
-    block.parts[0].objList = newParts;
-  }
-};
-
-// src/rom/extraction/writer.ts
-var isWindows = (() => {
-  if (typeof process !== "undefined" && process.platform) {
-    return process.platform === "win32";
-  }
-  if (typeof navigator !== "undefined" && navigator.userAgent) {
-    return navigator.userAgent.includes("Windows");
-  }
-  return false;
-})();
-var NEWLINE = isWindows ? "\r\n" : "\n";
-var ObjectType = /* @__PURE__ */ ((ObjectType2) => {
-  ObjectType2["TableEntryArray"] = "TableEntryArray";
-  ObjectType2["StructDef"] = "StructDef";
-  ObjectType2["OpArray"] = "OpArray";
-  ObjectType2["LocationWrapper"] = "LocationWrapper";
-  ObjectType2["Address"] = "Address";
-  ObjectType2["StringWrapper"] = "StringWrapper";
-  ObjectType2["ByteArray"] = "ByteArray";
-  ObjectType2["Array"] = "Array";
-  ObjectType2["String"] = "String";
-  ObjectType2["Number"] = "Number";
-  ObjectType2["TypedNumber"] = "TypedNumber";
-  return ObjectType2;
-})(ObjectType || {});
-var BlockWriter = class {
-  constructor(reader) {
-    this._isInline = false;
-    this._currentPart = null;
-    this._blockReader = reader;
-    this._root = reader._root;
-    this._referenceManager = reader._referenceManager;
-    this._postProcessor = new PostProcessor(reader);
-  }
-  // async writeBlocks(outPath: string): Promise<void> {
-  //   const res = DbRootUtils.getPath(this._root, BinType.Assembly);
-  //   const folderPath = join(outPath, res.folder);
-  //   for (const block of this._root.blocks) {
-  //     const groupedFolderPath = block.group 
-  //       ? join(folderPath, block.group)
-  //       : folderPath;
-  //     await fs.mkdir(groupedFolderPath, { recursive: true });
-  //     const outFile = join(groupedFolderPath, `${block.name}.${res.extension}`);
-  //     // Check if file exists, skip if it does
-  //     try {
-  //       await fs.access(outFile);
-  //       continue;
-  //     } catch {
-  //       // File doesn't exist, continue with creation
-  //     }
-  //     const content = this.generateAsm(block);
-  //     await fs.writeFile(outFile, content);
-  //   }
-  // }
-  generateAllAsm(chunkFiles) {
-    const lines = [];
-    for (const block of chunkFiles) {
-      lines.push({
-        name: block.name,
-        group: block.group,
-        text: this.generateAsm(block)
-      });
-    }
-    return lines;
-  }
-  generateAsm(block) {
-    if (!block.parts) {
-      throw new Error("Invalid block structure for generateAsm");
-    }
-    const lines = [];
-    if (block.bank !== void 0) {
-      lines.push(`?BANK ${block.bank.toString(16).toUpperCase().padStart(2, "0")}`);
-    }
-    const includes = shared.ChunkFileUtils.getIncludes(block);
-    if (includes && includes.length > 0) {
-      lines.push("");
-      for (const inc of includes) {
-        lines.push(`?INCLUDE '${inc.name}'`);
-      }
-    }
-    const mnemonics = this.getMnemonicsForBlock(block);
-    if (mnemonics && mnemonics.length > 0) {
-      lines.push("");
-      for (const [name, address] of mnemonics) {
-        const paddedName = name.padEnd(30, " ");
-        lines.push(`!${paddedName} ${address.toString(16).toUpperCase().padStart(4, "0")}`);
-      }
-    }
-    this._postProcessor.process(block);
-    for (const part of block.parts || []) {
-      this._currentPart = part;
-      this._isInline = true;
-      lines.push("");
-      lines.push("---------------------------------------------");
-      const objectLines = this.writeObject(part.objList, -1);
-      lines.push(...objectLines);
-    }
-    let content = lines.join(NEWLINE);
-    if (block.transforms) {
-      for (const x of block.transforms) {
-        if (x.key && x.value) {
-          const regex = new RegExp(x.key, "g");
-          content = content.replace(regex, x.value);
-        }
-      }
-    }
-    if (!isWindows) {
-      content = content.replace(/\r/g, "");
-    }
-    return content;
-  }
-  getMnemonicsForBlock(block) {
-    if (!block.mnemonics) {
-      return [];
-    }
-    return Object.entries(block.mnemonics).map(([k, v]) => [v, parseInt(k, 10)]).sort((a, b) => a[1] - b[1]);
-  }
-  resolveOperand(op, obj, isBranch = false) {
-    if (obj instanceof shared.TypedNumber) {
-      const len = obj.size * 2;
-      return obj.value.toString(16).toUpperCase().padStart(len, "0");
-    }
-    if (typeof obj === "number") {
-      if (op.mode === "Immediate") {
-        return obj;
-      }
-      return this._blockReader.resolveName(obj, shared.AddressType.Address, isBranch);
-    }
-    if (this.getObjectType(obj) === "LocationWrapper" /* LocationWrapper */) {
-      const lw = obj;
-      return this._blockReader.resolveName(lw.location, lw.type, isBranch);
-    }
-    if (this.getObjectType(obj) === "Address" /* Address */) {
-      const addr = obj;
-      if (op.size === 4) {
-        return addr;
-      }
-      if (addr.isCodeBank && addr.offset < shared.Address.UPPER_BANK) {
-        const label = this._root.mnemonics[addr.offset];
-        if (label) {
-          return label;
-        }
-      }
-      return addr.offset;
-    }
-    if (obj && obj instanceof shared.TypedNumber) {
-      return obj;
-    }
-    return obj;
-  }
-  getObjectType(obj) {
-    if (obj === null || obj === void 0) {
-      return "String" /* String */;
-    }
-    if (obj._tag) {
-      return obj._tag;
-    }
-    if (obj instanceof shared.TypedNumber) {
-      return "TypedNumber" /* TypedNumber */;
-    }
-    if (Array.isArray(obj)) {
-      if (obj.length > 0) {
-        if (obj[0] && typeof obj[0] === "object" && "location" in obj[0] && "object" in obj[0]) {
-          return "TableEntryArray" /* TableEntryArray */;
-        }
-        if (obj[0] instanceof shared.Op) {
-          return "OpArray" /* OpArray */;
-        }
-      }
-      return "Array" /* Array */;
-    }
-    if (obj instanceof shared.Op) {
-      return "OpArray" /* OpArray */;
-    }
-    if (obj instanceof shared.LocationWrapper) {
-      return "LocationWrapper" /* LocationWrapper */;
-    }
-    if (obj instanceof shared.Address) {
-      return "Address" /* Address */;
-    }
-    if (obj instanceof Uint8Array) {
-      return "ByteArray" /* ByteArray */;
-    }
-    if (obj && typeof obj === "object") {
-      if ("string" in obj && "type" in obj && "marker" in obj && "location" in obj) {
-        return "StringWrapper" /* StringWrapper */;
-      }
-      if ("name" in obj && "parts" in obj) {
-        return "StructDef" /* StructDef */;
-      }
-    }
-    if (typeof obj === "string") {
-      return "String" /* String */;
-    }
-    if (typeof obj === "number") {
-      return "Number" /* Number */;
-    }
-    return "String" /* String */;
-  }
-  writeObject(obj, depth, isBranch = false) {
-    const lines = [];
-    const objType = this.getObjectType(obj);
-    let objLines;
-    switch (objType) {
-      case "TableEntryArray" /* TableEntryArray */:
-        objLines = this.writeTableEntryArray(obj, depth);
-        break;
-      case "StructDef" /* StructDef */:
-        objLines = this.writeStructDef(obj, depth);
-        break;
-      case "OpArray" /* OpArray */:
-        objLines = this.writeOpArray(obj, depth);
-        break;
-      case "LocationWrapper" /* LocationWrapper */:
-        objLines = [
-          this._blockReader.resolveName(
-            obj.location,
-            obj.type,
-            isBranch
-          )
-        ];
-        break;
-      case "Address" /* Address */:
-        objLines = [`$${obj.toString()}`];
-        break;
-      case "ByteArray" /* ByteArray */:
-        objLines = [
-          `#${Array.from(obj).map((b) => b.toString(16).toUpperCase().padStart(2, "0")).join("")}`
-        ];
-        break;
-      case "StringWrapper" /* StringWrapper */:
-        objLines = this.writeStringWrapper(obj);
-        break;
-      case "Array" /* Array */:
-        objLines = this.writeArray(obj, depth);
-        break;
-      case "Number" /* Number */:
-        objLines = this.writeNumber(obj);
-        break;
-      case "TypedNumber" /* TypedNumber */:
-        objLines = this.writeTypedNumber(obj);
-        break;
-      case "String" /* String */:
-        objLines = [String(obj)];
-        break;
-      default:
-        objLines = [String(obj)];
-        break;
-    }
-    lines.push(...objLines);
-    return lines;
-  }
-  writeTableEntryArray(tGroup, depth) {
-    const lines = [];
-    const isInline = this._isInline;
-    for (const t of tGroup) {
-      const nameResult = this._referenceManager.tryGetName(t.location);
-      const name = nameResult.found ? nameResult.referenceName : `loc_${t.location.toString(16).toUpperCase().padStart(6, "0")}`;
-      const objectLines = this.writeObject(t.object, depth + 1);
-      lines.push("");
-      lines.push(`${name} ${objectLines[0]}`);
-      if (objectLines.length > 1) {
-        lines.push(...objectLines.slice(1));
-      }
-    }
-    this._isInline = isInline;
-    return lines;
-  }
-  writeStructDef(structObj, depth) {
-    const parts = [];
-    const isInline = this._isInline;
-    this._isInline = true;
-    for (const part of structObj.parts) {
-      const partLines = this.writeObject(part, depth);
-      parts.push(partLines.join(NEWLINE));
-    }
-    const line = `${structObj.name} < ${parts.join(", ")} >`;
-    this._isInline = isInline;
-    return [line];
-  }
-  writeOpArray(opList, depth) {
-    const lines = [];
-    lines.push("{");
-    const isInline = this._isInline;
-    this._isInline = true;
-    let first = true;
-    for (const op of opList) {
-      if (first) {
-        first = false;
-      } else {
-        const labelResult = this._referenceManager.tryGetName(op.location);
-        if (labelResult.found) {
-          lines.push("");
-          lines.push(`  ${labelResult.referenceName}:`);
-        }
-      }
-      let opLine = `    ${op.mnem} `;
-      if (op.copDef) {
-        opLine += `[${op.copDef.mnem}]`;
-        if (op.operands && op.operands.length > 1) {
-          const operandStrings = [];
-          for (let i = 1; i < op.operands.length; i++) {
-            const operandLines = this.writeObject(op.operands[i], depth + 1, false);
-            operandStrings.push(operandLines[0]);
-          }
-          opLine += ` ( ${operandStrings.join(", ")} )`;
-        }
-      } else if (op.operands && op.operands.length > 0) {
-        const isBr = op.mnem[0] === "J" || op.mode === "PCRelative" || op.mode === "PCRelativeLong";
-        const resolvedOperand = this.resolveOperand(op, op.operands[0], isBr);
-        const format = this._root.addrLookup[op.mode]?.formatString;
-        if (format) {
-          let actualFormat = format;
-          if (op.mode === "Immediate" && op.size === 3) {
-            actualFormat = format.replace("X2", "X4");
-          }
-          const resolvedSecondOperand = op.operands.length > 1 ? this.resolveOperand(op, op.operands[1], isBr) : void 0;
-          opLine += this.formatOperand(actualFormat, [resolvedOperand, resolvedSecondOperand]);
-        } else {
-          opLine += this.formatDefaultOperand(resolvedOperand, op.size);
-        }
-      }
-      lines.push(opLine);
-    }
-    lines.push("}");
-    this._isInline = isInline;
-    return lines;
-  }
-  formatDefaultOperand(operand, size) {
-    if (typeof operand === "string") {
-      return operand;
-    }
-    if (operand && operand instanceof shared.TypedNumber) {
-      return this.formatTypedNumber(operand);
-    }
-    if (typeof operand === "number") {
-      const hexSize = (size - 1) * 2;
-      const hex = operand.toString(16).toUpperCase().padStart(hexSize, "0");
-      return `$${hex}`;
-    }
-    return String(operand);
-  }
-  writeStringWrapper(stringObj) {
-    let str = stringObj.string;
-    const stringReferenceChars = ["~", "^"];
-    for (const char of stringReferenceChars) {
-      let ix = str.indexOf(char);
-      while (ix >= 0) {
-        const hexStr = str.substring(ix + 1, ix + 7);
-        const rawAddr = parseInt(hexStr, 16);
-        const adrs = new shared.Address(rawAddr >> 16 & 255, rawAddr & 65535);
-        if (adrs.space === shared.AddressSpace.ROM) {
-          const addressType = char === "^" ? shared.AddressType.Offset : shared.AddressType.Address;
-          const location = adrs.toInt();
-          const name = this._blockReader.resolveName(location, addressType, false);
-          str = str.replace(str.substring(ix, ix + 7), name);
-        } else {
-          throw new Error("Unsupported address space");
-        }
-        ix = str.indexOf(char, ix + 7);
-      }
-    }
-    const refChar = stringObj.type.delimiter;
-    let marker = stringObj.marker;
-    if (marker <= 0) {
-      const markerResult = this._referenceManager.tryGetMarker(stringObj.location);
-      marker = markerResult.found ? markerResult.offset || 0 : 0;
-    }
-    if (marker > 0) {
-      let six = 0;
-      let mix = 0;
-      while (mix < marker) {
-        if (str[six] === "[") {
-          const eix = str.indexOf("]", ++six);
-          const parts = str.substring(six, eix).split(/[,: ]/);
-          const cmd = Object.values(stringObj.type.commands).find((x) => x.value === parts[0]);
-          if (cmd && cmd.types) {
-            for (const t of cmd.types) {
-              switch (t) {
-                case shared.MemberType.Byte:
-                  mix += 1;
-                  break;
-                case shared.MemberType.Word:
-                case shared.MemberType.Offset:
-                  mix += 2;
-                  break;
-                case shared.MemberType.Address:
-                  mix += 3;
-                  break;
-                case shared.MemberType.Binary:
-                  mix += parts.length - 1;
-                  break;
-                default:
-                  throw new Error("Unsupported member type");
-              }
-            }
-          }
-          six = eix + 1;
-          mix++;
-        } else {
-          six++;
-          mix++;
-        }
-      }
-      str = str.substring(0, six) + "[::]" + str.substring(six);
-    }
-    return [`${refChar}${str}${refChar}`];
-  }
-  writeArray(arr, depth) {
-    const lines = [];
-    const indent = "  ".repeat(Math.max(0, depth));
-    const isInline = this._isInline;
-    lines.push("[");
-    this._isInline = false;
-    for (let i = 0; i < arr.length; i++) {
-      const objLines = this.writeObject(arr[i], depth + 1);
-      for (const line of objLines) {
-        lines.push(indent + "  " + line);
-      }
-      lines[lines.length - 1] += `   ;${i.toString(16).toUpperCase().padStart(2, "0")}`;
-    }
-    lines.push(indent + "]");
-    this._isInline = isInline;
-    return lines;
-  }
-  writeNumber(num) {
-    if (num <= 255) {
-      return [`#${num.toString(16).toUpperCase().padStart(2, "0")}`];
-    }
-    if (num <= 65535) {
-      return [`#$${num.toString(16).toUpperCase().padStart(4, "0")}`];
-    }
-    return [`#$${num.toString(16).toUpperCase().padStart(6, "0")}`];
-  }
-  formatTypedNumber(num) {
-    if (typeof num.value === "number") {
-      const width = num.size * 2;
-      const hex = num.value.toString(16).toUpperCase().padStart(width, "0");
-      return num.size === 1 ? `#${hex}` : `#$${hex}`;
-    }
-    return `#${num.value}`;
-  }
-  writeTypedNumber(num) {
-    return [this.formatTypedNumber(num)];
-  }
-  formatOperand(format, operands) {
-    return format.replace(/\{(\d+)(?::([^}]+))?\}/g, (match, index, formatSpec) => {
-      const operand = operands[parseInt(index)];
-      if (operand && typeof operand === "object" && operand._tag && "value" in operand) {
-        const value = operand.value;
-        if (formatSpec && typeof value === "number" && formatSpec.startsWith("X")) {
-          const width = parseInt(formatSpec.substring(1)) || 2;
-          return value.toString(16).toUpperCase().padStart(width, "0");
-        }
-        return String(value);
-      }
-      if (formatSpec && typeof operand === "number") {
-        if (formatSpec.startsWith("X")) {
-          const width = parseInt(formatSpec.substring(1)) || 2;
-          return operand.toString(16).toUpperCase().padStart(width, "0");
-        }
-      }
-      return String(operand);
-    });
-  }
-};
-var RomLayout = class _RomLayout {
-  constructor(files) {
-    this.bestResult = new Array(512).fill(0);
-    this.bestSample = new Array(512).fill(0);
-    this.currentBank = 0;
-    this.currentUpper = false;
-    this.bestDepth = 0;
-    this.bestOffset = 0;
-    this.bestRemain = 0;
-    this.unmatchedFiles = Array.from(files).filter((x) => (x.size || 0) > 0).sort((a, b) => {
-      const aAsm = a.parts ? 0 : 1;
-      const bAsm = b.parts ? 0 : 1;
-      if (aAsm !== bAsm) return aAsm - bAsm;
-      if (b.size !== a.size) return b.size - a.size;
-      if (a.location !== b.location) return a.location - b.location;
-      return a.name.localeCompare(b.name);
-    });
-  }
-  static {
-    this.MIN_ACCEPTED_REMAINING = 32;
-  }
-  organize() {
-    for (let page = 0; page < 128; page++) {
-      if (this.unmatchedFiles.length === 0) break;
-      let remain = shared.RomProcessingConstants.PAGE_SIZE;
-      if (page === 1) remain -= shared.RomProcessingConstants.SNES_HEADER_SIZE;
-      this.currentUpper = (page & 1) !== 0;
-      this.currentBank = page >> 1;
-      this.bestDepth = 0;
-      this.bestRemain = remain;
-      this.bestOffset = 0;
-      const start = page << 15;
-      this.testDepth(0, 0, remain, this.currentUpper);
-      if (this.currentUpper) {
-        this.bestOffset = this.bestDepth;
-        this.testDepth(0, this.bestDepth, this.bestRemain, false);
-      }
-      let position = start;
-      for (let i = 0; i < this.bestDepth; ) {
-        const file = this.unmatchedFiles[this.bestResult[i++]];
-        file.location = position;
-        console.log(`  ${position.toString(16).toUpperCase().padStart(6, "0")}: ${file.name}`);
-        position += file.size || 0;
-      }
-      console.log(`Page ${start.toString(16).toUpperCase().padStart(6, "0")} matched with ${this.bestDepth} files ${this.bestRemain} remaining`);
-      this.commitPage();
-    }
-    if (this.unmatchedFiles.length > 0) {
-      const names = this.unmatchedFiles.map((x) => x.name).join("\r\n");
-      throw new Error(`Unable to match ${this.unmatchedFiles.length} files\r
-${names}`);
-    }
-  }
-  testDepth(startIndex, depth, remain, asmMode) {
-    for (let fileIndex = startIndex; fileIndex < this.unmatchedFiles.length; fileIndex++) {
-      const file = this.unmatchedFiles[fileIndex];
-      const fileSize = file.size || 0;
-      if (fileSize > remain) continue;
-      if (file.parts) {
-        if (!asmMode) {
-          if (!this.currentUpper || (file.bank ?? -1) >= 0) continue;
-        } else if (file.bank !== this.currentBank) {
-          continue;
-        }
-      } else if (asmMode) {
-        continue;
-      } else if (file.upper && !this.currentUpper) {
-        continue;
-      }
-      let inList = false;
-      for (let y = this.bestOffset; --y >= 0; ) {
-        if (this.bestResult[y] === fileIndex) {
-          inList = true;
-          break;
-        }
-      }
-      if (inList) continue;
-      this.bestSample[depth] = fileIndex;
-      const newRemain = remain - fileSize;
-      if (newRemain < this.bestRemain) {
-        this.bestRemain = newRemain;
-        this.bestDepth = depth + 1;
-        for (let i = this.bestOffset; i < this.bestDepth; i++) {
-          this.bestResult[i] = this.bestSample[i];
-        }
-      }
-      if (newRemain < _RomLayout.MIN_ACCEPTED_REMAINING) return true;
-      if (this.testDepth(fileIndex + 1, depth + 1, newRemain, asmMode)) return true;
-    }
-    return true;
-  }
-  commitPage() {
-    if (this.bestOffset > 0) {
-      for (let i = this.bestDepth; --i >= 0; ) {
-        let lastY = 0;
-        let lastX = 0;
-        let y = 0;
-        for (let x = this.bestDepth; --x >= 0; ) {
-          y = this.bestResult[x];
-          if (y > lastY) {
-            lastY = y;
-            lastX = x;
-          }
-        }
-        this.bestResult[lastX] = 0;
-        this.unmatchedFiles.splice(lastY, 1);
-      }
-    } else {
-      for (let i = this.bestDepth; --i >= 0; ) {
-        this.unmatchedFiles.splice(this.bestResult[i], 1);
-      }
-    }
-  }
-};
-var RomProcessor = class _RomProcessor {
-  constructor(writer) {
-    this.writer = writer;
-  }
-  async repack(allFiles) {
-    const patches = allFiles.filter((x) => x.type === shared.BinType.Patch);
-    const asmFiles = allFiles.filter((x) => !!x.parts);
-    _RomProcessor.applyPatches(asmFiles, patches);
-    for (const asm of asmFiles) {
-      shared.ChunkFileUtils.calculateSize(asm);
-    }
-    const layout = new RomLayout(allFiles);
-    layout.organize();
-    for (const file of asmFiles) {
-      shared.ChunkFileUtils.rebase(file);
-    }
-    for (const f of asmFiles) {
-      const includeBlocks = asmFiles.filter((x) => f.includes?.has(x.name.toUpperCase())).flatMap((x) => x.parts).filter((b) => !!b.label);
-      f.includeLookup = /* @__PURE__ */ new Map();
-      for (const b of includeBlocks) {
-        if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-      }
-      for (const b of (f.parts || []).filter((x) => !!x.label)) {
-        if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-      }
-    }
-    const blockLookup = /* @__PURE__ */ new Map();
-    for (const f of allFiles) {
-      blockLookup.set(f.name.toUpperCase(), f.location);
-    }
-    for (const file of allFiles) {
-      await this.writer.writeFile(file, blockLookup);
-    }
-    const entryBlocks = asmFiles.filter((x) => (x.bank ?? -1) === 0).flatMap((x) => x.parts || []).filter((b) => !!b.label);
-    for (const ep of this.writer.entryPoints) {
-      const match = entryBlocks.find((b) => b.label === ep.name);
-      if (match) this.writer.writeTransform(ep.location, match.location & 65535);
-    }
-  }
-  static applyPatches(asmFiles, patches) {
-    for (const patch of patches.filter((x) => x.includes && x.includes.size > 0)) {
-      let file = null;
-      let dstIx = -1;
-      const inc = asmFiles.filter((x) => patch.includes.has(x.name.toUpperCase()));
-      for (let ix = 0; patch.parts && ix < patch.parts.length; ) {
-        const block = patch.parts[ix];
-        let match = null;
-        if (block.label) {
-          for (const i of inc) {
-            if (!i.parts) continue;
-            for (let y = 0; y < i.parts.length; y++) {
-              const check = i.parts[y];
-              if (check.label === block.label) {
-                file = i;
-                dstIx = y;
-                match = check;
-                break;
-              }
-            }
-          }
-        }
-        if (match) {
-          file.parts[dstIx++] = block;
-        } else if (dstIx >= 0) {
-          file.parts.splice(dstIx++, 0, block);
-        } else {
-          ix++;
-          continue;
-        }
-        file.includes = file.includes || /* @__PURE__ */ new Set();
-        file.includes.add(patch.name.toUpperCase());
-        patch.parts.splice(ix, 1);
-      }
-    }
-  }
-};
-var RomWriter = class {
-  constructor(entryPoints, cartName, makerCode) {
-    this.cartName = cartName;
-    this.makerCode = makerCode;
-    this.entryPoints = entryPoints;
-    this.outBuffer = new Uint8Array(4194304);
-  }
-  async repack(files) {
-    const processor = new RomProcessor(this);
-    await processor.repack(files);
-    this.writeHeader();
-    this.writeEntryPoints(files.filter((x) => !!x.parts));
-    this.writeChecksum();
-    return this.outBuffer;
-  }
-  writeHeader() {
-    const buf = this.outBuffer;
-    let pos = 65456;
-    this.writeAscii(this.makerCode.padEnd(6, " "), pos);
-    pos += 6;
-    for (let i = 0; i < 10; i++) buf[pos++] = 0;
-    this.writeAscii(this.cartName.toUpperCase().padEnd(21, " "), pos);
-    pos += 21;
-    buf[pos++] = 49;
-    buf[pos++] = 2;
-    buf[pos++] = 12;
-    buf[pos++] = 3;
-    buf[pos++] = 1;
-    buf[pos++] = 51;
-    buf[pos++] = 0;
-  }
-  writeChecksum() {
-    const buf = this.outBuffer;
-    buf[65500] = 255;
-    buf[65501] = 255;
-    buf[65502] = 0;
-    buf[65503] = 0;
-    let sum = 0;
-    for (let i = 0; i < buf.length; i++) sum += buf[i];
-    buf[65502] = sum & 255;
-    buf[65503] = sum >> 8 & 255;
-    const comp = ~sum;
-    buf[65500] = comp & 255;
-    buf[65501] = comp >> 8 & 255;
-  }
-  // private async generatePatch(): Promise<void> {
-  //   const flips = this._projectRoot.flipsPath;
-  //   if (!flips) return;
-  //   if (typeof process === 'undefined' || !process.versions?.node) return;
-  //   const { spawn } = await import('child_process');
-  //   const { resolve } = await import('path');
-  //   this.bpsPath = `${this._projectRoot.baseDir}/${this._projectRoot.name}.bps`;
-  //   await new Promise<void>((resolvePromise) => {
-  //     const p = spawn(flips, ['--create', '--bps', `${this._projectRoot.romPath}`, `${this.romPath}`, `${this.bpsPath}`], {
-  //       stdio: ['ignore', 'pipe', 'pipe']
-  //     });
-  //     p.on('close', () => resolvePromise());
-  //   });
-  // }
-  writeEntryPoints(asmFiles) {
-    this.outBuffer;
-    const entryBlocks = asmFiles.filter((x) => (x.bank ?? -1) === 0).flatMap((x) => x.parts || []).filter((b) => !!b.label);
-    for (const ep of this.entryPoints) {
-      const match = entryBlocks.find((b) => b.label === ep.name);
-      if (match) this.writeTransform(ep.location, match.location & 65535);
-    }
-  }
-  writeTransform(location, value, size) {
-    const buf = this.outBuffer;
-    if (size === void 0) {
-      if (value <= 255) {
-        size = 1;
-      } else if (value <= 65535) {
-        size = 2;
-      } else if (value <= 16777215) {
-        size = 3;
-      } else {
-        size = 4;
-      }
-    }
-    switch (size) {
-      case 1:
-        buf[location] = value & 255;
-        break;
-      case 2:
-        buf[location] = value & 255;
-        buf[location + 1] = value >> 8 & 255;
-        break;
-      case 3:
-        buf[location] = value & 255;
-        buf[location + 1] = value >> 8 & 255;
-        buf[location + 2] = value >> 16 & 255;
-        break;
-      case 4:
-        buf[location] = value & 255;
-        buf[location + 1] = value >> 8 & 255;
-        buf[location + 2] = value >> 16 & 255;
-        buf[location + 3] = value >> 24 & 255;
-        break;
-      default:
-        throw new Error(`Invalid size ${size} for writeTransform`);
-    }
-  }
-  async writeFile(file, _chunkLookup) {
-    const start = file.location;
-    let pos = start;
-    const buf = this.outBuffer;
-    if (file.rawData) {
-      const data = file.rawData;
-      let remain = file.size;
-      let srcPos = 0;
-      if (file.type === shared.BinType.Tilemap) {
-        remain -= 2;
-        buf[pos++] = data[srcPos++];
-        buf[pos++] = data[srcPos++];
-      } else if (file.type === shared.BinType.Meta17) {
-        remain -= 4;
-        for (let i = 0; i < 4; i++) buf[pos++] = data[srcPos++];
-      } else if (file.type === shared.BinType.Sound) {
-        remain -= 2;
-        buf[pos++] = remain & 255;
-        buf[pos++] = remain >> 8 & 255;
-      }
-      if (file.compressed !== void 0) {
-        remain -= 2;
-        const inverse = 0 - remain & 65535;
-        buf[pos++] = inverse & 255;
-        buf[pos++] = inverse >> 8 & 255;
-      }
-      while (remain > 0) {
-        buf[pos++] = data[srcPos++];
-        remain--;
-      }
-    } else {
-      if (file.parts && file.parts.length > 0) {
-        if (file.parts[0].location !== file.location && (file.location || 0) !== 0) {
-          throw new Error("Assembly was not based properly");
-        }
-        this.parseAssembly(file.parts, _chunkLookup, file.includeLookup);
-      }
-    }
-    return pos - start;
-  }
-  // No address mapping required: layout assigns absolute file offsets
-  writeAscii(text, pos) {
-    const buf = this.outBuffer;
-    for (let i = 0; i < text.length; i++) buf[pos + i] = text.charCodeAt(i) & 255;
-  }
-  /**
-   * Parse assembly blocks and write binary data to output buffer
-   * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs ParseAssembly method
-   */
-  parseAssembly(blocks, chunkLookup, includeLookup) {
-    if (!blocks) {
-      throw new Error("Assembly has not been parsed");
-    }
-    const buf = this.outBuffer;
-    for (const block of blocks) {
-      let position = block.location;
-      const objList = block.objList;
-      let opos = 0;
-      const processObject = (obj, parentOp) => {
-        let currentObj = obj;
-        while (true) {
-          if (Array.isArray(currentObj)) {
-            for (const obj2 of currentObj) {
-              processObject(obj2, parentOp);
-            }
-            break;
-          } else if (this.isTableEntry(currentObj)) {
-            currentObj = currentObj.object;
-            continue;
-          } else if (currentObj instanceof shared.Op) {
-            const op = currentObj;
-            buf[position++] = op.code & 255;
-            opos += op.size;
-            for (const operand of op.operands) {
-              processObject(operand, op);
-            }
-            break;
-          } else if (currentObj instanceof Uint8Array) {
-            const arr = currentObj;
-            for (let i = 0; i < arr.length; i++) {
-              buf[position + i] = arr[i];
-            }
-            position += arr.length;
-            opos += arr.length;
-            break;
-          } else if (typeof currentObj === "string") {
-            const str = currentObj;
-            let label = str;
-            let ix = 0;
-            while (ix < label.length && shared.RomProcessingConstants.ADDRESS_SPACE.includes(label[ix])) {
-              ix++;
-            }
-            if (ix > 0) {
-              label = label.substring(ix);
-            }
-            let loc;
-            const isRelative = parentOp && (parentOp.mode === "PCRelative" || parentOp.mode === "PCRelativeLong");
-            const operatorIdx = this.indexOfAny(label, shared.RomProcessingConstants.OPERATORS);
-            let offset = null;
-            let useMarker = false;
-            if (operatorIdx > 0) {
-              if (label[operatorIdx + 1] === "M") {
-                useMarker = true;
-              } else {
-                offset = parseInt(label.substring(operatorIdx + 1), 16);
-                if (label[operatorIdx] === "-") {
-                  offset = -offset;
-                }
-              }
-              label = label.substring(0, operatorIdx);
-            }
-            const labelUpper = label.toUpperCase();
-            let target;
-            if (includeLookup.has(labelUpper)) {
-              target = includeLookup.get(labelUpper);
-              loc = target.location;
-            } else if (chunkLookup.has(labelUpper)) {
-              loc = chunkLookup.get(labelUpper);
-            } else {
-              if (label.startsWith("#")) {
-                label = label.substring(1);
-              }
-              if (label.startsWith("$")) {
-                label = label.substring(1);
-              }
-              if (isRelative && label.length > 4) {
-                const off = parseInt(label, 16) - (block.location + opos);
-                currentObj = parentOp?.size === 2 ? off & 255 : off & 65535;
-                continue;
-              } else {
-                switch (label.length) {
-                  case 1:
-                  case 2:
-                    currentObj = new shared.Byte(parseInt(label, 16));
-                    continue;
-                  case 3:
-                  case 4:
-                    currentObj = new shared.Word(parseInt(label, 16));
-                    continue;
-                  case 5:
-                  case 6:
-                    currentObj = new shared.Long(parseInt(label, 16));
-                    continue;
-                  default:
-                    throw new Error(`Invalid operand '${label}'`);
-                }
-              }
-            }
-            let type = shared.Address.typeFromCode(str[0]);
-            if (type === shared.AddressType.Unknown) {
-              type = parentOp?.size === 4 ? shared.AddressType.Address : parentOp?.size === 2 ? shared.AddressType.Unknown : shared.AddressType.Offset;
-            }
-            if (isRelative) {
-              loc -= block.location + opos;
-              if (type === shared.AddressType.Unknown && !(loc < 128 || loc >= 4194176)) {
-                throw new Error("Relative out of range");
-              }
-            }
-            if (offset !== null) {
-              loc += offset;
-            } else if (useMarker && target) {
-              let markerOffset = 0;
-              for (const part of target.objList) {
-                if (this.isStringMarker(part)) {
-                  loc += markerOffset;
-                  break;
-                } else {
-                  markerOffset += shared.RomProcessingConstants.getSize(part);
-                }
-              }
-            }
-            switch (type) {
-              case shared.AddressType.Offset:
-                currentObj = new shared.Word(loc);
-                continue;
-              case shared.AddressType.Bank:
-                currentObj = new shared.Byte(loc >> 16 | ((loc & 65535) >= 32768 ? 128 : 192));
-                continue;
-              case shared.AddressType.WBank:
-                currentObj = new shared.Word(loc >> 16 | ((loc & 65535) >= 32768 ? 128 : 192));
-                continue;
-              case shared.AddressType.Address:
-                currentObj = new shared.Long(loc | ((loc & 65535) >= 32768 ? 8388608 : 12582912));
-                continue;
-              default:
-                currentObj = new shared.Byte(loc);
-                continue;
-            }
-          } else if (currentObj instanceof shared.TypedNumber) {
-            let value = currentObj.value;
-            for (let i = 0; i < currentObj.size; i++) {
-              buf[position++] = value & 255;
-              value >>= 8;
-            }
-            break;
-          } else if (typeof currentObj === "number") {
-            const num = currentObj;
-            const size = parentOp?.size ?? 0;
-            if (num <= 255 && size <= 2) {
-              buf[position] = num & 255;
-              position++;
-            } else if (num <= 65535 && size <= 3) {
-              buf[position] = num & 255;
-              buf[position + 1] = num >> 8 & 255;
-              position += 2;
-            } else if (num <= 16777215 && size <= 4) {
-              buf[position] = num & 255;
-              buf[position + 1] = num >> 8 & 255;
-              buf[position + 2] = num >> 16 & 255;
-              position += 3;
-            } else {
-              buf[position] = num & 255;
-              buf[position + 1] = num >> 8 & 255;
-              buf[position + 2] = num >> 16 & 255;
-              buf[position + 3] = num >> 24 & 255;
-              position += 4;
-            }
-            break;
-          } else if (this.isStringMarker(currentObj)) {
-            break;
-          } else {
-            throw new Error(`Unable to process '${currentObj}'`);
-          }
-        }
-      };
-      for (const obj of objList) {
-        processObject(obj);
-      }
-    }
-  }
-  /**
-   * Helper method to find index of any character from an array in a string
-   */
-  indexOfAny(str, chars) {
-    for (let i = 0; i < str.length; i++) {
-      if (chars.includes(str[i])) {
-        return i;
-      }
-    }
-    return -1;
-  }
-  /**
-   * Helper method to check if an object is a StringMarker
-   */
-  isStringMarker(obj) {
-    return typeof obj === "object" && obj !== null && "offset" in obj;
-  }
-  isTableEntry(obj) {
-    return typeof obj === "object" && obj !== null && "location" in obj && "object" in obj;
-  }
-};
-var StringProcessor = class {
-  constructor(context) {
-    this.memBuffer = [];
-    this.context = context;
-    this.root = context.root;
-  }
-  dispose() {
-    this.memBuffer.length = 0;
-  }
-  consumeString() {
-    let str = null;
-    const typeChar = this.context.lineBuffer[0];
-    const endIx = this.context.lineBuffer.indexOf(typeChar, 1);
-    if (endIx >= 0) {
-      str = this.context.lineBuffer.substring(1, endIx);
-      this.context.lineBuffer = this.context.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
-    } else {
-      str = this.context.lineBuffer.substring(1);
-      this.context.lineBuffer = "";
-    }
-    this.memBuffer.length = 0;
-    const stringType = this.root.stringCharLookup[typeChar];
-    this.processString(str, stringType);
-  }
-  flushBuffer(stringType, wrap = false) {
-    const size = this.memBuffer.length;
-    if (size > 0) {
-      const buffer = new Uint8Array(this.memBuffer);
-      this.context.currentBlock.objList.push(buffer);
-      this.context.currentBlock.size += size;
-      this.memBuffer.length = 0;
-    }
-  }
-  processString(str, stringType) {
-    const dict = stringType.commands;
-    stringType.characterMap;
-    this.getShiftUp(stringType.shiftType);
-    let lastCmd = null;
-    for (let x = 0; x < str.length; x++) {
-      const c = str[x];
-      if (c === "[") {
-        const endIx = str.indexOf("]", x + 1);
-        const splitChars = [":", ",", " "];
-        const parts = str.substring(x + 1, endIx).split(new RegExp(`[${splitChars.join("")}]`)).filter((p) => p.length > 0);
-        x = endIx;
-        if (parts.length === 0) {
-          this.flushBuffer(stringType, true);
-          this.context.currentBlock.objList.push({
-            offset: this.context.currentBlock.size
-          });
-          continue;
-        }
-        const cmd = Object.values(dict).find((x2) => x2.value === parts[0]);
-        if (cmd) {
-          lastCmd = cmd;
-          this.memBuffer.push(cmd.key);
-          this.processStringCommand(cmd, stringType, parts);
-          continue;
-        }
-      }
-      lastCmd = null;
-      if (this.applyLayers(c, stringType)) {
-        continue;
-      }
-    }
-    if (lastCmd === null || !lastCmd.halt) {
-      this.memBuffer.push(stringType.terminator);
-    }
-    this.flushBuffer(stringType, true);
-  }
-  applyLayers(c, stringType) {
-    if (this.applyMap(c, stringType.characterMap, this.getShiftUp(stringType.shiftType))) {
-      return true;
-    }
-    if (stringType.layers) {
-      for (const layer of stringType.layers) {
-        if (this.applyMap(c, layer.map, (x) => x + layer.base)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  applyMap(c, map, shift) {
-    for (let i = 0, len = map.length; i < len; i++) {
-      const v = map[i];
-      if (v != null && c === v[0]) {
-        this.memBuffer.push(shift(i));
-        return true;
-      }
-    }
-    return false;
-  }
-  processStringCommand(cmd, stringType, parts) {
-    const hasPointer = cmd.types.includes(shared.MemberType.Address) || cmd.types.includes(shared.MemberType.Offset);
-    if (hasPointer) {
-      this.flushBuffer(stringType, true);
-    }
-    for (let y = 0, pix = 1; y < cmd.types.length; y++, pix++) {
-      switch (cmd.types[y]) {
-        case shared.MemberType.Byte:
-          this.memBuffer.push(parseInt(parts[pix], 16));
-          break;
-        case shared.MemberType.Word:
-          const us = parseInt(parts[pix], 16);
-          this.memBuffer.push(us & 255);
-          this.memBuffer.push(us >> 8 & 255);
-          break;
-        case shared.MemberType.Binary:
-          while (pix < parts.length) {
-            const ch = parseInt(parts[pix], 16);
-            this.memBuffer.push(ch);
-            pix++;
-          }
-          if (cmd.delimiter !== void 0) {
-            this.memBuffer.push(cmd.delimiter);
-          }
-          break;
-        case shared.MemberType.Offset:
-        case shared.MemberType.Address:
-          this.flushBuffer(stringType, false);
-          this.context.currentBlock.objList.push(parts[pix]);
-          this.context.currentBlock.size += cmd.types[y] === shared.MemberType.Offset ? 2 : 3;
-          break;
-      }
-    }
-    if (hasPointer) {
-      this.flushBuffer(stringType, false);
-    }
-  }
-  getShiftUp(shiftType) {
-    switch (shiftType) {
-      case "h2":
-        return (x) => (x & 112) << 1 | x & 15;
-      case "wh2":
-        return (x) => (x & 56) << 1 | x & 7;
-      default:
-        return (x) => x;
-    }
-  }
-};
-
-// src/rom/rebuild/sorted-map.ts
-var SortedMap = class {
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-    this._keys = [];
-  }
-  get size() {
-    return this.map.size;
-  }
-  set(key, value) {
-    if (!this.map.has(key)) {
-      this._keys.push(key);
-      this.sortKeys();
-    }
-    this.map.set(key, value);
-    return this;
-  }
-  get(key) {
-    return this.map.get(key);
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  delete(key) {
-    const result = this.map.delete(key);
-    if (result) {
-      const index = this._keys.indexOf(key);
-      if (index >= 0) {
-        this._keys.splice(index, 1);
-      }
-    }
-    return result;
-  }
-  clear() {
-    this.map.clear();
-    this._keys.length = 0;
-  }
-  keys() {
-    return [...this._keys];
-  }
-  values() {
-    return this._keys.map((key) => this.map.get(key));
-  }
-  entries() {
-    return this._keys.map((key) => [key, this.map.get(key)]);
-  }
-  *[Symbol.iterator]() {
-    for (const key of this._keys) {
-      yield [key, this.map.get(key)];
-    }
-  }
-  sortKeys() {
-    this._keys.sort((a, b) => {
-      if (a.length !== b.length) {
-        return b.length - a.length;
-      }
-      return a.localeCompare(b);
-    });
-  }
-};
-var AssemblerState = class _AssemblerState {
-  constructor(context, structType = null, saveDelimiter = false) {
-    this.context = context;
-    this.root = context.root;
-    this.dbStruct = structType === null ? null : Object.values(this.root.structs).find(
-      (x) => x.name.toLowerCase() === structType.toLowerCase()
-    ) || null;
-    this.parentStruct = !this.dbStruct || !this.dbStruct.parent ? null : Object.values(this.root.structs).find(
-      (x) => x.name.toLowerCase() === this.dbStruct.parent.toLowerCase()
-    ) || null;
-    this.discriminator = this.parentStruct?.discriminator ?? null;
-    this.delimiter = this.dbStruct?.delimiter || null;
-    this.memberOffset = 0;
-    this.dataOffset = 0;
-    this.memberTypes = this.dbStruct?.types || null;
-    this.currentType = this.memberTypes?.[this.memberOffset] || null;
-    if (saveDelimiter) {
-      this.context.lastDelimiter = this.dbStruct?.delimiter ?? this.parentStruct?.delimiter ?? null;
-    }
-  }
-  checkDisc() {
-    if (this.discriminator === this.dataOffset) {
-      this.context.currentBlock.objList.push(this.dbStruct.discriminator);
-      this.context.currentBlock.size += 1;
-      this.dataOffset += 1;
-    }
-  }
-  advancePart() {
-    if (this.currentType != null && this.discriminator != null) {
-      this.dataOffset += shared.RomProcessingConstants.getSize(this.currentType);
-    }
-    if (this.memberTypes != null && this.memberOffset + 1 < this.memberTypes.length) {
-      this.currentType = this.memberTypes[++this.memberOffset];
-    }
-  }
-  processOrigin() {
-    this.context.lineBuffer = this.context.lineBuffer.substring(3).replace(/^[\s,\t]+/, "");
-    if (this.context.lineBuffer.startsWith("$")) {
-      this.context.lineBuffer = this.context.lineBuffer.substring(1);
-    }
-    let hex;
-    const endIx = this.context.lineBuffer.search(/[\s,\t]/);
-    if (endIx >= 0) {
-      hex = this.context.lineBuffer.substring(0, endIx);
-      this.context.lineBuffer = this.context.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
-    } else {
-      hex = this.context.lineBuffer;
-      this.context.lineBuffer = "";
-    }
-    const location = parseInt(hex, 16);
-    this.context.blocks.push(this.context.currentBlock = new shared.AsmBlock(location));
-    this.context.blockIndex++;
-  }
-  static doMath(operand) {
-    const ix = operand.search(/[-+]/);
-    if (ix >= 0) {
-      const op = operand[ix];
-      const vix = operand.lastIndexOf("$", ix) + 1;
-      const valueStr = operand.substring(vix, ix);
-      if (valueStr.match(/^[a-fA-F0-9]+$/)) {
-        const value = parseInt(valueStr, 16);
-        let endIx = operand.substring(ix + 1).search(shared.RomProcessingConstants.SYMBOL_SPACE_REGEX);
-        if (endIx < 0) {
-          endIx = operand.length;
-        }
-        const number = parseInt(operand.substring(ix + 1, endIx), 16);
-        let result;
-        if (op === "-") {
-          result = value - number;
-        } else {
-          result = value + number;
-        }
-        const len = ix - vix <= 2 ? 2 : ix - vix <= 4 ? 4 : 6;
-        operand = operand.substring(0, vix) + result.toString(16).toUpperCase().padStart(len, "0") + operand.substring(endIx);
-      }
-    }
-    return operand;
-  }
-  tryCreateLabel(mnemonic, operand) {
-    if (!operand || operand.length === 0) {
-      return false;
-    }
-    const labelChar = operand[0];
-    if (!shared.RomProcessingConstants.LABEL_SPACE.includes(labelChar)) {
-      return false;
-    }
-    const newBlock = new shared.AsmBlock(
-      this.context.currentBlock.location + this.context.currentBlock.size,
-      0,
-      this.root.stringDelimiters.includes(operand[0]),
-      mnemonic
-    );
-    this.context.blocks.push(newBlock);
-    this.context.currentBlock = newBlock;
-    this.context.blockIndex++;
-    if (labelChar === ":") {
-      this.context.lineBuffer = this.context.lineBuffer.substring(1);
-    } else if (labelChar === "[" || labelChar === "{") {
-      this.context.lineBuffer = operand.substring(1).replace(/^[\s,\t]+/, "");
-      const state = new _AssemblerState(this.context, this.currentType);
-      state.processText(labelChar);
-      this.advancePart();
-    }
-    return true;
-  }
-  processText(openTag) {
-    this.checkDisc();
-    while (!this.context.eof) {
-      if (!this.context.getLine()) {
-        return;
-      }
-      let mnemonic = null;
-      let operand = null;
-      let operand2 = null;
-      while (this.context.lineBuffer.length > 0) {
-        const lineSymbol = this.context.lineBuffer[0];
-        if (this.root.stringDelimiters.includes(lineSymbol)) {
-          this.context.stringProcessor.consumeString();
-          this.advancePart();
-          continue;
-        }
-        if (shared.RomProcessingConstants.ADDRESS_SPACE.includes(lineSymbol)) {
-          this.context.processRawData();
-          if (openTag === "[") {
-            this.context.lastDelimiter = null;
-          }
-          this.advancePart();
-          continue;
-        }
-        if (lineSymbol === ">") {
-          if (openTag === "<") {
-            this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
-            this.checkDisc();
-          }
-          return;
-        }
-        if (lineSymbol === "]") {
-          this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
-          this.delimiter = this.delimiter ?? this.context.lastDelimiter;
-          if (this.delimiter != null) {
-            if (this.delimiter >= 256) {
-              this.context.currentBlock.objList.push(this.delimiter);
-              this.context.currentBlock.size += 2;
-            } else {
-              this.context.currentBlock.objList.push(this.delimiter);
-              this.context.currentBlock.size += 1;
-            }
-          }
-          return;
-        }
-        if (lineSymbol === "}") {
-          if (openTag === "{") {
-            this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
-          }
-          return;
-        }
-        if (lineSymbol === "[") {
-          this.context.lineBuffer = this.context.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
-          const state = new _AssemblerState(this.context, this.currentType);
-          state.processText("[");
-          this.advancePart();
-          continue;
-        }
-        if (this.context.lineBuffer.startsWith("ORG")) {
-          this.processOrigin();
-          continue;
-        }
-        const symbolIndex = this.context.lineBuffer.search(shared.RomProcessingConstants.SYMBOL_SPACE_REGEX);
-        if (symbolIndex > 0) {
-          mnemonic = this.context.lineBuffer.substring(0, symbolIndex);
-          operand = this.context.lineBuffer.substring(symbolIndex).replace(/^[, \t]+/, "");
-          if (operand && operand.startsWith("<")) {
-            this.context.lineBuffer = operand.substring(1).replace(/^[, \t]+/, "");
-            const state = new _AssemblerState(this.context, mnemonic, openTag === "[" && this.currentType == null);
-            state.processText("<");
-            mnemonic = null;
-            continue;
-          }
-          this.context.lineBuffer = operand;
-        } else {
-          mnemonic = this.context.lineBuffer;
-          this.context.lineBuffer = "";
-        }
-        break;
-      }
-      if (mnemonic && mnemonic.length > 0) {
-        const codes = this.root.opLookup[mnemonic.toUpperCase()];
-        if (!codes || codes.length === 0) {
-          if (this.tryCreateLabel(mnemonic, operand || void 0)) {
-            continue;
-          }
-          throw new Error(`Unknown instruction line ${this.context.lineCount}: '${mnemonic}'`);
-        }
-        this.context.lineBuffer = "";
-        if (!operand) {
-          const opCode2 = codes.find((x) => this.root.addrLookup[x.mode].size === 1);
-          this.context.currentBlock.objList.push(new shared.Op(opCode2, 0, [], 1));
-          this.context.currentBlock.size++;
-          continue;
-        }
-        operand = _AssemblerState.doMath(operand);
-        let opCode = codes[0];
-        if (opCode?.mnem === "COP") {
-          const parts = operand.split(/[\s\t,()[\]$#]/).filter((p) => p.length > 0);
-          const cmd = parts[0];
-          const cop = this.root.copLookup[cmd];
-          if (!cop) {
-            throw new Error(`Unknown COP command ${cmd}`);
-          }
-          this.context.currentBlock.objList.push(new shared.Op(opCode, 0, [new shared.Byte(cop.code), ...parts.slice(1)], cop.size + 2));
-          this.context.currentBlock.size += cop.size + 2;
-          continue;
-        }
-        opCode = null;
-        for (const code of codes) {
-          if (code.mode === "PCRelative" || code.mode === "PCRelativeLong") {
-            opCode = code;
-            break;
-          }
-          const addrMode2 = this.root.addrLookup[code.mode];
-          const regex = addrMode2.parseRegex;
-          if (regex) {
-            const match = new RegExp(regex).exec(operand);
-            if (match) {
-              opCode = code;
-              operand = match[1];
-              if (match.length > 2) {
-                operand2 = match[2];
-              }
-              break;
-            }
-          }
-        }
-        if (operand.startsWith("#")) {
-          operand = operand.substring(1);
-        }
-        if (operand.startsWith("$")) {
-          operand = operand.substring(1);
-        }
-        if (opCode == null) {
-          const addrIx = operand.search(shared.RomProcessingConstants.ADDRESS_SPACE_REGEX);
-          if (addrIx && addrIx >= 0) {
-            const eix = operand.search(/[\s\t,\])]/);
-            if (eix && eix >= 0) {
-              operand = operand.substring(addrIx, eix);
-            }
-          }
-          opCode = codes.find((x) => x.mode === "Immediate") ?? codes.find((x) => x.mode === "AbsoluteLong") ?? codes.find((x) => x.mode === "Absolute") ?? null;
-          if (opCode == null) {
-            throw new Error(`Unable to determine mode/code line ${this.context.lineCount}: '${this.context.lineBuffer}'`);
-          }
-        }
-        const opnd1 = this.context.parseOperand(operand);
-        const addrMode = this.root.addrLookup[opCode.mode];
-        let size = addrMode.size;
-        if (size === AsmReader.VARIABLE_SIZE_INDICATOR || opCode.mode === "Immediate") {
-          size = operand?.startsWith("^") || operand?.length === 2 ? 2 : 3;
-        }
-        const operands = operand2 != null ? [opnd1, this.context.parseOperand(operand2)] : [opnd1];
-        this.context.currentBlock.objList.push(new shared.Op(opCode, 0, operands, size));
-        this.context.currentBlock.size += size;
-      }
-    }
-  }
-  hexStringToBytes(hex) {
-    const result = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-      result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-    }
-    return result;
-  }
-};
-
-// src/rom/rebuild/assembler.ts
-var Assembler = class {
-  constructor(dbRoot, textData) {
-    this.currentLineIndex = 0;
-    this.lineBuffer = "";
-    this.includes = /* @__PURE__ */ new Set();
-    this.blocks = [];
-    this.tags = new SortedMap();
-    this.currentBlock = null;
-    this.lineCount = 0;
-    this.blockIndex = 0;
-    this.lastDelimiter = null;
-    this.reqBank = null;
-    this.eof = false;
-    this.root = dbRoot;
-    this.lines = textData.split(/\r?\n/);
-    this.stringProcessor = new StringProcessor(this);
-  }
-  dispose() {
-    this.stringProcessor.dispose();
-  }
-  parseAssembly() {
-    this.blocks.push(this.currentBlock = new shared.AsmBlock());
-    const state = new AssemblerState(this);
-    state.processText();
-    return {
-      blocks: this.blocks,
-      includes: this.includes,
-      reqBank: this.reqBank
-    };
-  }
-  getLine() {
-    if (this.eof) {
-      return false;
-    }
-    if (this.lineBuffer.length > 0) {
-      return true;
-    }
-    let rawLine = null;
-    while (true) {
-      if (this.currentLineIndex >= this.lines.length) {
-        if (this.lineBuffer.length === 0) {
-          this.eof = true;
-          return false;
-        } else {
-          rawLine = "";
-        }
-      } else {
-        rawLine = this.lines[this.currentLineIndex++];
-        this.lineBuffer += rawLine;
-      }
-      this.lineCount++;
-      this.trimComments("--");
-      this.trimComments(";");
-      this.trimComments("//");
-      this.lineBuffer = this.lineBuffer.replace(shared.RomProcessingConstants.COMMA_SPACE_TRIM_REGEX, "");
-      if (this.lineBuffer.length === 0) {
-        continue;
-      }
-      if (this.lineBuffer.endsWith("\\")) {
-        this.lineBuffer = this.lineBuffer.slice(0, -1);
-        continue;
-      }
-      if (this.lineBuffer[0] === "?") {
-        this.processDirectives();
-        this.lineBuffer = "";
-        continue;
-      }
-      if (this.lineBuffer[0] === "!") {
-        this.processTags();
-        this.lineBuffer = "";
-        continue;
-      }
-      this.resolveTags();
-      return true;
-    }
-  }
-  trimComments(sequence) {
-    const index = this.lineBuffer.indexOf(sequence);
-    if (index >= 0) {
-      const strDelimRegex = new RegExp(`[${this.root.stringDelimiters.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("")}]`);
-      const strIndex = this.lineBuffer.search(strDelimRegex);
-      if (strIndex < 0 || strIndex > index || this.lineBuffer.lastIndexOf(this.lineBuffer[strIndex] || "") < index) {
-        this.lineBuffer = this.lineBuffer.substring(0, index);
-      }
-    }
-  }
-  processDirectives() {
-    let endIx = this.lineBuffer.search(shared.RomProcessingConstants.COMMA_SPACE_REGEX);
-    if (endIx < 0) {
-      endIx = this.lineBuffer.length;
-    }
-    const value = this.lineBuffer.substring(endIx).replace(/^[\s,\t]+/, "");
-    switch (this.lineBuffer.substring(1, endIx).toUpperCase()) {
-      // This is taken care of by the loader
-      case "BANK":
-        this.reqBank = parseInt(value, 16);
-        break;
-      case "INCLUDE":
-        if (value.length > 0) {
-          this.includes.add(value.toUpperCase().replace(/'/g, ""));
-        }
-        break;
-    }
-  }
-  processTags() {
-    this.lineBuffer = this.lineBuffer.substring(1).replace(/^[\s,\t]+/, "");
-    while (this.lineBuffer.length > 0) {
-      let name = this.lineBuffer;
-      let value = null;
-      let endIx = this.lineBuffer.search(/[\s,\t]/);
-      if (endIx >= 0) {
-        name = this.lineBuffer.substring(0, endIx);
-        value = this.lineBuffer.substring(endIx + 1).replace(/^[\s,\t]+/, "");
-        const nextIx = value.search(/[\s,\t]/);
-        if (nextIx >= 0) {
-          this.lineBuffer = value.substring(nextIx + 1).replace(/^[\s,\t]+/, "");
-          value = value.substring(0, nextIx);
-        } else {
-          this.lineBuffer = "";
-        }
-      } else {
-        this.lineBuffer = "";
-      }
-      this.tags.set(name, value);
-    }
-  }
-  resolveTags() {
-    for (const [key, value] of this.tags) {
-      let ix;
-      while ((ix = this.lineBuffer.toLowerCase().indexOf(key.toLowerCase())) >= 0) {
-        this.lineBuffer = this.lineBuffer.substring(0, ix) + (value || "") + this.lineBuffer.substring(ix + key.length);
-      }
-    }
-  }
-  parseOperand(opnd) {
-    if (!opnd) return null;
-    if (opnd.match(/^[a-fA-F0-9]{2,6}$/)) {
-      switch (opnd.length) {
-        case 2:
-          return new shared.Byte(parseInt(opnd, 16));
-        case 4:
-          return new shared.Word(parseInt(opnd, 16));
-        case 6:
-          return new shared.Long(parseInt(opnd, 16));
-      }
-    }
-    return opnd;
-  }
-  processRawData() {
-    let reverse = false;
-    if (this.lineBuffer[0] === "#") {
-      this.lineBuffer = this.lineBuffer.substring(1);
-    }
-    if (this.lineBuffer[0] === "$") {
-      reverse = true;
-      this.lineBuffer = this.lineBuffer.substring(1);
-    }
-    let hex;
-    const symbolIx = this.lineBuffer.search(shared.RomProcessingConstants.SYMBOL_SPACE_REGEX);
-    if (symbolIx >= 0) {
-      hex = this.lineBuffer.substring(0, symbolIx);
-      this.lineBuffer = this.lineBuffer.substring(symbolIx).replace(/^[, \t]+/, "");
-    } else {
-      hex = this.lineBuffer;
-      this.lineBuffer = "";
-    }
-    if (hex.length > 0) {
-      if (shared.RomProcessingConstants.ADDRESS_SPACE.includes(hex[0])) {
-        this.currentBlock.objList.push(hex);
-        this.currentBlock.size += shared.RomProcessingConstants.getSize(hex);
-      } else {
-        const data = this.hexStringToBytes(hex);
-        if (data.length === 1) {
-          this.currentBlock.objList.push(new shared.Byte(data[0]));
-          this.currentBlock.size++;
-        } else {
-          if (reverse) {
-            data.reverse();
-          }
-          if (data.length === 2) {
-            this.currentBlock.objList.push(new shared.Word(data[0] | data[1] << 8));
-            this.currentBlock.size += 2;
-          } else {
-            this.currentBlock.objList.push(data);
-            this.currentBlock.size += data.length;
-          }
-        }
-      }
-    }
-  }
-  hexStringToBytes(hex) {
-    const result = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-      result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-    }
-    return result;
-  }
-};
-var RomGenerator = class {
-  constructor(projectName) {
-    this.crc = 0;
-    this.branchId = "";
-    //private chunkFiles: ChunkFile[] = [];
-    //private asmFiles: ChunkFile[] = [];
-    this.dbRoot = {};
-    this.sourceData = new Uint8Array();
-    this.projectName = projectName;
-  }
-  async initialize() {
-    var projectData = await shared.summaryFromSupabaseByProject(this.projectName);
-    this.crc = projectData.baseRomBranch.gameRomBranch.gameRom.crc;
-    this.branchId = projectData.id;
-  }
-  async validateAndDownload(sourceData) {
-    const calc = shared.crc32_buffer(sourceData);
-    if (calc === this.crc) {
-      this.dbRoot = await shared.DbRootUtils.fromSupabaseProject(this.projectName, this.branchId);
-      this.sourceData = sourceData;
-      return true;
-    }
-    return false;
-  }
-  async generateProject(modules, manualFiles, unshiftManualFiles = false) {
-    if (!this.dbRoot) throw new Error("Database not initialized");
-    if (!this.sourceData) throw new Error("Source data not initialized");
-    const reader = new BlockReader(this.sourceData, this.dbRoot);
-    const chunkFiles = reader.analyzeAndResolve();
-    const asmFiles = chunkFiles.filter((b) => b.type === shared.BinType.Assembly);
-    const patchFiles = [];
-    const writer = new BlockWriter(reader);
-    for (const block of asmFiles) block.textData = writer.generateAsm(block);
-    for (const chunkFile of this.dbRoot.baseRomFiles) this.applyPatchFile(chunkFile, chunkFiles, asmFiles, patchFiles);
-    const moduleLookup = this.applyProjectInit(chunkFiles, asmFiles, patchFiles);
-    if (unshiftManualFiles) {
-      for (const file of manualFiles ?? []) this.applyPatchFile(file, chunkFiles, asmFiles, patchFiles);
-    }
-    for (const module of modules) {
-      for (const file of moduleLookup.get(module)) this.applyPatchFile(file, chunkFiles, asmFiles, patchFiles);
-    }
-    if (!unshiftManualFiles) {
-      for (const file of manualFiles ?? []) this.applyPatchFile(file, chunkFiles, asmFiles, patchFiles);
-    }
-    this.assembleCodeFromText(asmFiles);
-    RomProcessor.applyPatches(asmFiles, patchFiles);
-    for (const asm of chunkFiles) shared.ChunkFileUtils.calculateSize(asm);
-    const layout = new RomLayout(chunkFiles);
-    layout.organize();
-    for (const file of asmFiles) shared.ChunkFileUtils.rebase(file);
-    this.generateAsmIncludeLookups(asmFiles);
-    const blockLookup = /* @__PURE__ */ new Map();
-    for (const f of chunkFiles) blockLookup.set(f.name.toUpperCase(), f.location);
-    const outRom = await this.writeRom(blockLookup, this.dbRoot.entryPoints, chunkFiles, asmFiles);
-    return outRom;
-  }
-  applyProjectInit(chunkFiles, asmFiles, patchFiles) {
-    const moduleLookup = /* @__PURE__ */ new Map();
-    for (const chunkFile of this.dbRoot.projectFiles) {
-      console.log(`Processing patch: ${chunkFile.name}`);
-      if (chunkFile.group) {
-        let modArray;
-        if (!moduleLookup.has(chunkFile.group)) moduleLookup.set(chunkFile.group, modArray = []);
-        else modArray = moduleLookup.get(chunkFile.group);
-        modArray.push(chunkFile);
-      } else this.applyPatchFile(chunkFile, chunkFiles, asmFiles, patchFiles);
-    }
-    return moduleLookup;
-  }
-  //Assemble code from script text
-  assembleCodeFromText(asmFiles) {
-    for (const block of asmFiles) {
-      const assembler = new Assembler(this.dbRoot, block.textData);
-      const { blocks, includes, reqBank } = assembler.parseAssembly();
-      block.parts = blocks;
-      block.includes = includes;
-      block.bank = reqBank ?? void 0;
-    }
-  }
-  // Build include lookup map per asm file
-  generateAsmIncludeLookups(asmFiles) {
-    for (const f of asmFiles) {
-      const includeBlocks = asmFiles.filter((x) => f.includes?.has(x.name.toUpperCase())).flatMap((x) => x.parts).filter((b) => !!b.label);
-      f.includeLookup = /* @__PURE__ */ new Map();
-      for (const b of includeBlocks) {
-        if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-      }
-      for (const b of (f.parts || []).filter((x) => !!x.label)) {
-        if (b.label) f.includeLookup.set(b.label.toUpperCase(), b);
-      }
-    }
-  }
-  applyPatchFile(chunkFile, chunkFiles, asmFiles, patchFiles) {
-    console.log(`Processing patch: ${chunkFile.name}`);
-    const existing = chunkFiles.find((x) => x.name === chunkFile.name);
-    if (chunkFile.type === shared.BinType.Patch || chunkFile.type === shared.BinType.Assembly) {
-      if (existing) {
-        existing.textData = chunkFile.textData;
-      } else {
-        if (chunkFile.type === shared.BinType.Patch) {
-          patchFiles.push(chunkFile);
-        }
-        asmFiles.push(chunkFile);
-        chunkFiles.push(chunkFile);
-      }
-    } else {
-      if (existing) {
-        existing.rawData = chunkFile.rawData;
-        existing.size = chunkFile.size;
-      } else {
-        chunkFiles.push(chunkFile);
-      }
-    }
-  }
-  async writeRom(blockLookup, entryPoints, chunkFiles, asmFiles) {
-    const romWriter = new RomWriter(entryPoints, "GAIALABS", "01JG  ");
-    for (const file of chunkFiles) await romWriter.writeFile(file, blockLookup);
-    romWriter.writeHeader();
-    romWriter.writeEntryPoints(asmFiles);
-    romWriter.writeChecksum();
-    return romWriter.outBuffer;
-  }
-};
-
-// src/sprites/SpriteFrame.ts
-var SpriteFrame = class {
-  constructor(duration = 0, groupIndex = 0, groupOffset = 0) {
-    this.duration = duration;
-    this.groupIndex = groupIndex;
-    this.groupOffset = groupOffset;
-  }
-};
-
-// src/sprites/SpritePart.ts
-var SpritePart = class {
-  constructor() {
-    this.isLarge = false;
-    this.xOffset = 0;
-    this.xOffsetMirror = 0;
-    this.yOffset = 0;
-    this.yOffsetMirror = 0;
-    this.vMirror = false;
-    this.hMirror = false;
-    this.someOffset = 0;
-    this.paletteIndex = 0;
-    this.tileIndex = 0;
-  }
-};
-
-// src/sprites/SpriteGroup.ts
-var SpriteGroup = class {
-  constructor() {
-    this.xOffset = 0;
-    this.xOffsetMirror = 0;
-    this.yOffset = 0;
-    this.yOffsetMirror = 0;
-    this.xRecoilHitboxOffset = 0;
-    this.yRecoilHitboxOffset = 0;
-    this.xRecoilHitboxTilesize = 0;
-    this.yRecoilHitboxTilesize = 0;
-    this.xHostileHitboxOffset = 0;
-    this.xHostileHitboxSize = 0;
-    this.yHostileHitboxOffset = 0;
-    this.yHostileHitboxSize = 0;
-    this.parts = [];
-  }
-};
-
-// src/sprites/SpriteMap.ts
-var SpriteMap = class _SpriteMap {
-  constructor() {
-    this.frameSets = [];
-    this.groups = [];
-  }
-  /**
-   * Create a SpriteMap from binary data
-   * @param data Binary data buffer
-   * @returns SpriteMap instance
-   */
-  static fromBytes(data) {
-    let position = 0;
-    const getByte = () => {
-      if (position >= data.length) return 0;
-      return data[position++];
-    };
-    const getUshort = () => {
-      if (position + 1 >= data.length) return 0;
-      const low = data[position++];
-      const high = data[position++];
-      return low | high << 8;
-    };
-    const spriteMap = new _SpriteMap();
-    const setOffsets = /* @__PURE__ */ new Set();
-    const groupOffsets = /* @__PURE__ */ new Set();
-    position = 0;
-    while (!setOffsets.has(position)) {
-      const offset = getUshort() - 16384;
-      setOffsets.add(offset);
-    }
-    for (const offStart of setOffsets) {
-      position = offStart;
-      const frameList = [];
-      while (true) {
-        const duration = getUshort();
-        if (duration === 65535) {
-          break;
-        }
-        const groupOffset = getUshort() - 16384;
-        frameList.push(new SpriteFrame(duration, 0, groupOffset));
-        groupOffsets.add(groupOffset);
-      }
-      spriteMap.frameSets.push(frameList);
-    }
-    let grpIx = 0;
-    const sortedGroupOffsets = Array.from(groupOffsets).sort((a, b) => a - b);
-    for (const offStart of sortedGroupOffsets) {
-      position = offStart;
-      for (const set of spriteMap.frameSets) {
-        for (const frame of set) {
-          if (frame.groupOffset === offStart) {
-            frame.groupIndex = grpIx;
-          }
-        }
-      }
-      const grp = new SpriteGroup();
-      grp.xOffset = getByte();
-      grp.xOffsetMirror = getByte();
-      grp.yOffset = getByte();
-      grp.yOffsetMirror = getByte();
-      grp.xRecoilHitboxOffset = getByte();
-      grp.yRecoilHitboxOffset = getByte();
-      grp.xRecoilHitboxTilesize = getByte();
-      grp.yRecoilHitboxTilesize = getByte();
-      grp.xHostileHitboxOffset = getByte();
-      grp.xHostileHitboxSize = getByte();
-      grp.yHostileHitboxOffset = getByte();
-      grp.yHostileHitboxSize = getByte();
-      let numParts = getByte();
-      while (numParts-- > 0) {
-        const part = new SpritePart();
-        part.isLarge = getByte() !== 0;
-        part.xOffset = getByte();
-        part.xOffsetMirror = getByte();
-        part.yOffset = getByte();
-        part.yOffsetMirror = getByte();
-        const props = getUshort();
-        part.vMirror = (props & 32768) !== 0;
-        part.hMirror = (props & 16384) !== 0;
-        part.someOffset = props >> 12 & 3;
-        part.paletteIndex = props >> 9 & 7;
-        part.tileIndex = props & 511;
-        grp.parts.push(part);
-      }
-      spriteMap.groups.push(grp);
-      grpIx++;
-    }
-    return spriteMap;
-  }
-  /**
-   * Convert this SpriteMap to binary data
-   * @returns Binary data buffer
-   */
-  toBytes() {
-    let size = this.frameSets.length * 2;
-    for (const set of this.frameSets) {
-      size += set.length * 4 + 2;
-    }
-    for (const grp of this.groups) {
-      size += grp.parts.length * 7 + 13;
-    }
-    const buffer = new Uint8Array(size);
-    let position = 0;
-    const writeShort = (val) => {
-      buffer[position++] = val & 255;
-      buffer[position++] = val >> 8 & 255;
-    };
-    const writeLoc = (val) => writeShort(val + 16384);
-    let pos = this.frameSets.length << 1;
-    const groupPos = new Array(this.groups.length);
-    for (const set of this.frameSets) {
-      writeLoc(pos);
-      pos += (set.length << 2) + 2;
-    }
-    for (let i = 0; i < this.groups.length; i++) {
-      groupPos[i] = pos;
-      pos += this.groups[i].parts.length * 7 + 13;
-    }
-    for (const set of this.frameSets) {
-      for (const frm of set) {
-        writeShort(frm.duration);
-        writeLoc(groupPos[frm.groupIndex]);
-      }
-      writeShort(65535);
-    }
-    for (const grp of this.groups) {
-      buffer[position++] = grp.xOffset;
-      buffer[position++] = grp.xOffsetMirror;
-      buffer[position++] = grp.yOffset;
-      buffer[position++] = grp.yOffsetMirror;
-      buffer[position++] = grp.xRecoilHitboxOffset;
-      buffer[position++] = grp.yRecoilHitboxOffset;
-      buffer[position++] = grp.xRecoilHitboxTilesize;
-      buffer[position++] = grp.yRecoilHitboxTilesize;
-      buffer[position++] = grp.xHostileHitboxOffset;
-      buffer[position++] = grp.xHostileHitboxSize;
-      buffer[position++] = grp.yHostileHitboxOffset;
-      buffer[position++] = grp.yHostileHitboxSize;
-      buffer[position++] = grp.parts.length;
-      for (const prt of grp.parts) {
-        buffer[position++] = prt.isLarge ? 1 : 0;
-        buffer[position++] = prt.xOffset;
-        buffer[position++] = prt.xOffsetMirror;
-        buffer[position++] = prt.yOffset;
-        buffer[position++] = prt.yOffsetMirror;
-        const accum = (prt.vMirror ? 32768 : 0) | (prt.hMirror ? 16384 : 0) | (prt.someOffset & 3) << 12 | (prt.paletteIndex & 7) << 9 | prt.tileIndex;
-        writeShort(accum);
-      }
-    }
-    return buffer.slice(0, position);
-  }
-};
-
-// src/index.ts
-var GAIA_CORE_VERSION = "0.1.6";
-var isPlatformBrowser = typeof window !== "undefined";
-var isPlatformNode = typeof process !== "undefined" && process.versions?.node;
-var isPlatformWebWorker = typeof importScripts !== "undefined";
-
-exports.AddressingModeHandler = AddressingModeHandler;
-exports.AsmReader = AsmReader;
-exports.Assembler = Assembler;
-exports.AssemblerState = AssemblerState;
-exports.BlockReader = BlockReader;
-exports.BlockWriter = BlockWriter;
-exports.CopCommandProcessor = CopCommandProcessor;
-exports.GAIA_CORE_VERSION = GAIA_CORE_VERSION;
-exports.ObjectType = ObjectType;
-exports.OperationContext = OperationContext;
-exports.PostProcessor = PostProcessor;
-exports.ProcessorStateManager = ProcessorStateManager;
-exports.QuintetLZ = QuintetLZ;
-exports.ReferenceManager = ReferenceManager;
-exports.Registers = Registers;
-exports.RomDataReader = RomDataReader;
-exports.RomGenerator = RomGenerator;
-exports.RomLayout = RomLayout;
-exports.RomProcessor = RomProcessor;
-exports.RomState = RomState;
-exports.RomStateUtils = RomStateUtils;
-exports.RomWriter = RomWriter;
-exports.SortedMap = SortedMap;
-exports.SpriteFrame = SpriteFrame;
-exports.SpriteGroup = SpriteGroup;
-exports.SpriteMap = SpriteMap;
-exports.SpritePart = SpritePart;
-exports.Stack = Stack;
-exports.StackOperations = StackOperations;
-exports.StringProcessor = StringProcessor;
-exports.StringReader = StringReader;
-exports.TransformProcessor = TransformProcessor;
-exports.TypeParser = TypeParser;
-exports.isPlatformBrowser = isPlatformBrowser;
-exports.isPlatformNode = isPlatformNode;
-exports.isPlatformWebWorker = isPlatformWebWorker;
-exports.registerCompressionProviders = registerCompressionProviders;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map