0-3: Constant $4E $45 $53 $1A ("NES" followed by MS-DOS end-of-file)
4: Size of PRG ROM in 16 KB units
5: Size of CHR ROM in 8 KB units (Value 0 means the board uses CHR RAM)

fetch('./sample1.nes')
    .then((res) => res.arrayBuffer())
    .then((nesFile: ArrayBuffer) => {
        const nes = new NES();
        nes.load(nesFile);
        nes.start();
    });

function parse(buf) {
    const characterROMPages = buf[5];
    const characterROMStart = 0x0010 + buf[4] * 0x4000;
    const characterROMEnd = characterROMStart + buf[5] * 0x2000;
    return {
      programROM: buf.slice(NES_HEADER_SIZE, characterROMStart - 1),
      characterROM: buf.slice(characterROMStart, characterROMEnd - 1),
    }
}

this.registers = {
  A: 0x00,
  X: 0x00,
  Y: 0x00,
  P: {
    negative: false,
    overflow: false,
    reserved: true,
    break: true,
    decimal: false,
    interrupt: true,
    zero: false,
    carry: false,
  },
  SP: 0x01FD,
  PC: 0x0000,
};

class Cpu {

  ... 略 ...

  reset() {
　　　　　　　　// レジスタの初期化
    this.registers = {
      ...defaultRegisters,
      P: { ...defaultRegisters.P }
    };
    this.registers.PC = this.readWord(0xFFFC);
  }

  ... 略 ...

}

const cycles = [
  /*0x00*/ 7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6,
  /*0x10*/ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 6, 7,
  /*0x20*/ 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6,
  /*0x30*/ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 6, 7,
  /*0x40*/ 6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6,
  /*0x50*/ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 6, 7,
  /*0x60*/ 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6,
  /*0x70*/ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 6, 7,
  /*0x80*/ 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4,
  /*0x90*/ 2, 6, 2, 6, 4, 4, 4, 4, 2, 4, 2, 5, 5, 4, 5, 5,
  /*0xA0*/ 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4,
  /*0xB0*/ 2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4,
  /*0xC0*/ 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6,
  /*0xD0*/ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7,
  /*0xE0*/ 2, 6, 3, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6,
  /*0xF0*/ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7,
];

class Cpu {

  /* ...略... */

  read(addr) {
    return this.bus.read(addr);
  }

  fetch() {
    return this.read(this.register.PC++);
  }

  // アドレッシング・モードに従い演算対象を算出する
  fetchOpeland(addressing) {
    switch (addressing) {
      case 'accumulator': return;
      case 'implied': return;
      case 'immediate': return this.fetch(),
      case 'zeroPage': return this.fetch(),
      case 'zeroPageX': {
        const addr = this.fetch();
        return (addr + this.registers.X) & 0xFF,
      }
      case 'zeroPageY': {
        const addr = this.fetch();
        return (addr + this.registers.Y & 0xFF);
      }
      case 'absolute': return this.fetchWord();
      case 'absoluteX': {
        const addr = this.fetchWord();
        return (addr + this.registers.X) & 0xFFFF;
      }
      case 'absoluteY': {
        const addr = this.fetchWord();
        return (addr + this.registers.Y) & 0xFFFF;
      }
      case 'preIndexedIndirect': {
        const baseAddr = (this.fetch() + this.registers.X) & 0xFF;
        const addr = this.read(baseAddr) + (this.read((baseAddr + 1) & 0xFF) << 8);
        return addr & 0xFFFF;
      }
      case 'postIndexedIndirect': {
        const addrOrData = this.fetch();
        const baseAddr = this.read(addrOrData) + (this.read((addrOrData + 1) & 0xFF) << 8);
        const addr = baseAddr + this.registers.Y;
        return addr & 0xFFFF;
      }
      case 'indirectAbsolute': {
        const addrOrData = this.fetchWord();
        const addr = this.read(addrOrData) + (this.read((addrOrData & 0xFF00) | (((addrOrData & 0xFF) + 1) & 0xFF)) << 8);
        return addr & 0xFFFF;
      }
    }
  }

  // 命令と演算対象を受け取り演算を実行する
  exec(baseName, opeland, mode) {
    switch (baseName) {
      case 'LDA': {
        this.registers.A = mode === 'immediate' ? opeland : this.read(opeland);
        this.registers.P.negative = !!(this.registers.A & 0x80);
        this.registers.P.zero = !this.registers.A;
        break;
      }
      case 'STA': {
        this.write(opeland, this.registers.A);
        break;
      }
      case  /* ...略... */
            /* 残りの命令を実装 */
      }
  }
  /* ...略... */

  // CPUの実行
  // 後述する実行タイミング調整のために実行にかかったサイクル数を返す
  run() {
    const opecode = this.fetch();
    const { baseName, mode, cycle } = this.opecodeList[opecode];
    const opeland = this.fetchOpeland(mode);
    this.exec(baseName, opeland, mode);
    return cycle;
  }
}

class Cpu {
  constructor(bus) {
    this.bus = bus;
    this.register = {/* ...略... */ }
  }

  read(addr) {
    return this.bus.read(addr);
  }

  write(addr, data) {
    this.bus.write(addr, data);
  }
  /* ...略... */
}

import Rom from '../rom';
import Ram from '../ram';
import Ppu from '../ppu';
import Keypad from '../keypad';
import Dma from '../dma';
import Apu from '../apu';

class CpuBus {
  constructor(ram, programROM, ppu, keypad, dma, apu) {
    this.ram = ram;
    this.programROM = programROM;
    this.ppu = ppu;
    this.apu = apu;
    this.keypad = keypad;
    this.dma = dma;
  }

  readByCpu(addr: Word): Byte {
    if (addr < 0x0800) {
      return this.ram.read(addr);
    } else if (addr < 0x2000) {
      // mirror
      return this.ram.read(addr - 0x0800);
    } else if (addr < 0x4000) {
      // mirror
      const data = this.ppu.read((addr - 0x2000) % 8);
      return data;
    } else if (addr === 0x4016) {
      // TODO Add 2P
      return +this.keypad.read();
    } else if (addr >= 0xC000) {
      // Mirror, if prom block number equals 1
      if (this.programROM.size <= 0x4000) {
        return this.programROM.read(addr - 0xC000);
      }
      return this.programROM.read(addr - 0x8000);
    } else if (addr >= 0x8000) {
      // ROM
      return this.programROM.read(addr - 0x8000);
    } else {
      return 0;
    }
  }

  writeByCpu(addr, data) {
    // log.debug(`cpu:write addr = ${addr}`, data);
    if (addr < 0x0800) {
      // RAM
      this.ram.write(addr, data);
    } else if (addr < 0x2000) {
      // mirror
      this.ram.write(addr - 0x0800, data);
    } else if (addr < 0x2008) {
      // PPU
      this.ppu.write(addr - 0x2000, data);
    } else if (addr >= 0x4000 && addr < 0x4020) {
      if (addr === 0x4014) {
        this.dma.write(data);
      } else if (addr === 0x4016) {
        // TODO Add 2P
        this.keypad.write(data);
      } else {
        // APU
        this.apu.write(addr - 0x4000, data);
      }
    }
  }
}

Addresses $3F10/$3F14/$3F18/$3F1C are mirrors of $3F00/$3F04/$3F08/$3F0C.
Note that this goes for writing as well as reading.
A symptom of not having implemented this correctly in an emulator is the sky being black in Super Mario Bros., which writes the backdrop color through $3F10.

const colors = [
  [0x80, 0x80, 0x80], [0x00, 0x3D, 0xA6], [0x00, 0x12, 0xB0], [0x44, 0x00, 0x96],
  [0xA1, 0x00, 0x5E], [0xC7, 0x00, 0x28], [0xBA, 0x06, 0x00], [0x8C, 0x17, 0x00],
  [0x5C, 0x2F, 0x00], [0x10, 0x45, 0x00], [0x05, 0x4A, 0x00], [0x00, 0x47, 0x2E],
  [0x00, 0x41, 0x66], [0x00, 0x00, 0x00], [0x05, 0x05, 0x05], [0x05, 0x05, 0x05],
  [0xC7, 0xC7, 0xC7], [0x00, 0x77, 0xFF], [0x21, 0x55, 0xFF], [0x82, 0x37, 0xFA],
  [0xEB, 0x2F, 0xB5], [0xFF, 0x29, 0x50], [0xFF, 0x22, 0x00], [0xD6, 0x32, 0x00],
  [0xC4, 0x62, 0x00], [0x35, 0x80, 0x00], [0x05, 0x8F, 0x00], [0x00, 0x8A, 0x55],
  [0x00, 0x99, 0xCC], [0x21, 0x21, 0x21], [0x09, 0x09, 0x09], [0x09, 0x09, 0x09],
  [0xFF, 0xFF, 0xFF], [0x0F, 0xD7, 0xFF], [0x69, 0xA2, 0xFF], [0xD4, 0x80, 0xFF],
  [0xFF, 0x45, 0xF3], [0xFF, 0x61, 0x8B], [0xFF, 0x88, 0x33], [0xFF, 0x9C, 0x12],
  [0xFA, 0xBC, 0x20], [0x9F, 0xE3, 0x0E], [0x2B, 0xF0, 0x35], [0x0C, 0xF0, 0xA4],
  [0x05, 0xFB, 0xFF], [0x5E, 0x5E, 0x5E], [0x0D, 0x0D, 0x0D], [0x0D, 0x0D, 0x0D],
  [0xFF, 0xFF, 0xFF], [0xA6, 0xFC, 0xFF], [0xB3, 0xEC, 0xFF], [0xDA, 0xAB, 0xEB],
  [0xFF, 0xA8, 0xF9], [0xFF, 0xAB, 0xB3], [0xFF, 0xD2, 0xB0], [0xFF, 0xEF, 0xA6],
  [0xFF, 0xF7, 0x9C], [0xD7, 0xE8, 0x95], [0xA6, 0xED, 0xAF], [0xA2, 0xF2, 0xDA],
  [0x99, 0xFF, 0xFC], [0xDD, 0xDD, 0xDD], [0x11, 0x11, 0x11], [0x11, 0x11, 0x11],
];

class Ppu {

  ... 略 ...

  run(cycle){
    this.cycle += cycle;
    if(this.line === 0) {
      this.background.length = 0;
    }

    // 1ライン分のサイクル
    if (this.cycle >= 341) {
      this.cycle -= 341;
      this.line++;

      if (this.line <= 240 && this.line % 8 === 0) {
        this.buildBackground();
      }
      if (this.line === 262) {
        this.line = 0;
        return {
          background: this.background,
          palette: this.getPalette(),
        };
      }
    }
  }

  buildSprite(spriteId) {
    const sprite = new Array(8).fill(0).map(() => [0, 0, 0, 0, 0, 0, 0, 0]);
    for (let i = 0; i < 16; i = i + 1) {
      for (let j = 0; j < 8; j = j + 1) {
        const addr = spriteId * 16 + i;
        const ram = this.readCharacterRAM(addr);
        if (ram & (0x80 >> j)) {
          sprite[i % 8][j] += 0x01 << ~~(i / 8);
        }
      }
    }
    return sprite;
  }

  buildTile(tileX, tileY) {
    const blockId = this.getBlockId(tileX, tileY); 
    const spriteId = this.getSpriteId(tileX, tileY); 
    const attr = this.getAttribute(tileX, tileY); 
    const paletteId = (attr >> (blockId * 2)) & 0x03; 
    const sprite = this.buildSprite(spriteId); 
    return { 
      sprite, 
      paletteId, 
    }; 
  } 

  buildBackground() { 
    const clampedTileY = this.tileY % 30; 
    for (let x = 0; x < 32; x = x + 1) {
      const clampedTileX = x % 32;
      const nameTableId = (~~(x / 32) % 2);
      const tile = this.buildTile(clampedTileX, clampedTileY);
      this.background.push(tile);
    }
  }
}

class Renderer {

  ... 略 ...

  render(data) {
    const { background, palette } = data;
    this.renderBackground(background, palette);
    this.ctx.putImageData(this.image, 0, 0);
  }

  renderBackground(background, palette) {
    this.background = background;
    for (let i = 0; i < background.length; i += 1) {
      const x = (i % 32) * 8;
      const y = ~~(i / 32) * 8;
      this.renderTile(background[i], x, y, palette);
    }
  }

  // キャラクターROMで記載したSpriteに記載されてあるパレット番号に基づき各ピクセルを着色
  renderTile({ sprite, paletteId }, tileX, tileY, palette) {
    const { data } = this.image;
    for (let i = 0; i < 8; i = i + 1) {
      for (let j = 0; j < 8; j = j + 1) {
        const paletteIndex = paletteId * 4 + sprite[i][j];
        const colorId = palette[paletteIndex];
        const color = colors[colorId];
        const x = tileX + j;
        const y = tileY + i;
        if (x >= 0 && 0xFF >= x && y >= 0 && y < 224) {
          const index = (x + (y * 0x100)) * 4;
          data[index] = color[0];
          data[index + 1] = color[1];
          data[index + 2] = color[2];
          data[index + 3] = 0xFF;
        }
      }
    }
  }
}

class NES {
  frame() {
    while (true) {
      let cycle: number = 0;
　　　　　　　　　　 // 命令実行にかかったサイクル数を返す
      cycle += this.cpu.run();
　　　　　　　　　　　　// PPUはCPUの3倍の速度で動作するのでCPUの実行サイクルの3倍のサイクル数を渡す
      const renderingData = this.ppu.run(cycle * 3); 
      if (renderingData) { 
　　　　　　　　　　　　　　　　// 1画面分のデータが完成していたらcanvasに描画する
        this.renderer.render(renderingData); 
        break;
      }
    }
    requestAnimationFrame(this.frame);
  }

  start() {
    requestAnimationFrame(this.frame);
  }
}

.setcpu     "6502"
.autoimport on

.segment "HEADER"
    .byte   $4E, $45, $53, $1A  ; "NES" Header
    .byte   $02         ; PRG-BANKS
    .byte   $01         ; CHR-BANKS
    .byte   $01         ; Vetrical Mirror
    .byte   $00         ; 
    .byte   $00, $00, $00, $00  ; 
    .byte   $00, $00, $00, $00  ; 

.segment "STARTUP"
.proc   Reset
    sei
    ldx #$ff
    txs

    lda #$00
    sta $2000
    sta $2001

    lda #$3f
    sta $2006
    lda #$00
    sta $2006
    ldx #$00
    ldy #$10
copypal:
    lda palettes, x
    sta $2007
    inx
    dey
    bne copypal

    lda #$21
    sta $2006
    lda #$c9
    sta $2006
    ldx #$00
    ldy #$0d
copymap:
    lda string, x
    sta $2007
    inx
    dey
    bne copymap

    lda #$00
    sta $2005
    sta $2005

    lda #$08
    sta $2000
    lda #$1e
    sta $2001

mainloop:
    jmp mainloop
.endproc

palettes:
    .byte   $0f, $00, $10, $20
    .byte   $0f, $06, $16, $26
    .byte   $0f, $08, $18, $28
    .byte   $0f, $0a, $1a, $2a

string:
    .byte   "HELLO, WORLD!"

.segment "VECINFO"
    .word   $0000
    .word   Reset
    .word   $0000

.segment "CHARS"
    .incbin "character.chr"

.segment "HEADER"
    .byte   $4E, $45, $53, $1A  ; "NES" Header
    .byte   $02         ; PRG-BANKS
    .byte   $01         ; CHR-BANKS
    .byte   $01         ; Vetrical Mirror
    .byte   $00         ; 
    .byte   $00, $00, $00, $00  ; 
    .byte   $00, $00, $00, $00  ; 

.segment "STARTUP"
.proc   Reset
    sei
    ldx #$ff
    txs

    lda #$00
    sta $2000
    sta $2001

    lda #$3f
    sta $2006
    lda #$00
    sta $2006
    ldx #$00
    ldy #$10

copypal:
    lda palettes, x
    sta $2007
    inx
    dey
    bne copypal

    lda #$21
    sta $2006
    lda #$c9
    sta $2006
    ldx #$00
    ldy #$0d
copymap:
    lda string, x
    sta $2007
    inx
    dey
    bne copymap

    lda #$00
    sta $2005
    sta $2005

    lda #$08
    sta $2000
    lda #$1e
    sta $2001

mainloop:
    jmp mainloop
.endproc