dsh-inner-browser-use 0.34.28 → 0.34.96

package/runtime/flash-app/main.js

@@ -0,0 +1,232 @@
+/* The one job of this app: open a window Chromium will render, and let the
+   sidecar drive it over the debugging port. The Flash plugin arrives from the
+   sidecar's environment and is appended to the command line here, because
+   Electron only honours these switches when they are set before Chromium
+   starts. */
+const { app, BrowserWindow, Menu } = require('electron')
+const http = require('http')
+const env = process.env
+
+app.commandLine.appendSwitch('use-mock-keychain')
+app.commandLine.appendSwitch('lang', 'zh-CN')
+app.commandLine.appendSwitch('password-store', 'basic')
+app.commandLine.appendSwitch('disable-background-timer-throttling')
+app.commandLine.appendSwitch('disable-backgrounding-occluded-windows')
+app.commandLine.appendSwitch('disable-renderer-backgrounding')
+/* A plugin paints on its own surface, and a GPU-composited surface does not
+   reach the screencast; software compositing puts it back in the page bitmap. */
+if (env.DSH_FLASH_SOFTWARE === '1') {
+  app.commandLine.appendSwitch('disable-gpu')
+  app.commandLine.appendSwitch('disable-gpu-compositing')
+  app.commandLine.appendSwitch('in-process-gpu')
+}
+if (env.DSH_FLASH_PORT) app.commandLine.appendSwitch('remote-debugging-port', env.DSH_FLASH_PORT)
+if (env.DSH_FLASH_UDD) app.commandLine.appendSwitch('user-data-dir', env.DSH_FLASH_UDD)
+if (env.DSH_FLASH_PLUGIN) {
+  app.commandLine.appendSwitch('ppapi-flash-path', env.DSH_FLASH_PLUGIN)
+  app.commandLine.appendSwitch('ppapi-flash-version', env.DSH_FLASH_VERSION || '32.0.0.371')
+  app.commandLine.appendSwitch('allow-outdated-plugins')
+  /* The plugin process is sandboxed in a way that cannot open a plugin living
+     outside the app bundle: it fails with "file system sandbox blocked open()"
+     and the page then reports no usable Flash. This app renders one page we
+     name ourselves, so it does not need that sandbox. */
+  app.commandLine.appendSwitch('no-sandbox')
+}
+
+app.on('window-all-closed', () => {
+  /* A closed window is the person closing the mirror, not the app's business. */
+})
+
+/* A plugin paints on a surface the debugging protocol's screencast does not
+   see, so the app hands out its own frames over a loopback port. */
+let capture = null
+let latest = null
+/* A plugin surface cannot be screencast, so this app is the capture source.
+   Capturing inside the request would make the picture cost the poll interval
+   plus the capture itself; a pump keeps one JPEG ready and requests return it. */
+let latestJpeg = null
+let latestAt = 0
+let pumping = false
+let pumpTimer = 0
+let painted = 0
+
+function alive(win) {
+  try {
+    return win !== null && win !== undefined && win.isDestroyed() !== true
+  } catch {
+    return false
+  }
+}
+
+/* A timer is its own fault domain: a window that closed between ticks must end
+   the pump, not throw into the app's process. */
+function pump() {
+  /* Offscreen rendering already hands every frame over in its paint callback;
+     a screenshot pump on top of it could only write a staler picture back. */
+  if (painted > 0) {
+    if (pumpTimer !== 0) clearInterval(pumpTimer)
+    pumpTimer = 0
+    return
+  }
+  if (pumping === true) return
+  if (alive(capture) !== true) {
+    if (pumpTimer !== 0) clearInterval(pumpTimer)
+    pumpTimer = 0
+    return
+  }
+  pumping = true
+  try {
+    capture.webContents.capturePage()
+      .then((image) => {
+        if (alive(capture) !== true) return
+        latest = image
+        latestJpeg = image.toJPEG(Number(env.DSH_FLASH_JPEG_QUALITY || 72))
+        latestAt = Date.now()
+      })
+      .catch(() => {})
+      .finally(() => { pumping = false })
+  } catch {
+    pumping = false
+  }
+}
+
+app.whenReady().then(() => {
+  const window = new BrowserWindow({
+    width: 1440,
+    height: 900,
+    x: -3000,
+    y: -3000,
+    /* Never a window on anybody's screen: the picture belongs in the column
+       that asked for it, and a game window parked off to the side is exactly
+       what this must not add to the desktop. */
+    show: false,
+    /* Without this macOS pulls a window placed past the edge of the screen back
+       onto it; the window is meant to stay where nobody can see it. */
+    enableLargerThanScreen: true,
+    frame: false,
+    skipTaskbar: true,
+    hasShadow: false,
+    focusable: false,
+    webPreferences: {
+      plugins: true,
+      backgroundThrottling: false,
+      contextIsolation: true,
+      /* macOS does not paint a window nobody can see, which used to force this
+         app to put a real game window on the desktop. Offscreen rendering
+         paints into a bitmap instead, so the page exists only in the column. */
+      offscreen: true,
+      useSharedTexture: false,
+      paintWhenInitiallyHidden: true,
+    },
+  })
+  capture = window
+  /* The Dock wanted to show this as a running app; the only thing it runs is
+     the picture in someone's column. */
+  if (app.dock !== undefined && app.dock !== null) app.dock.hide()
+  /* A running app with a menu puts its name in the menu bar the moment macOS
+     activates it, which is a second way for this to appear on someone's
+     desktop. No menu, and an accessory app: only the picture in the column. */
+  Menu.setApplicationMenu(null)
+  if (typeof app.setActivationPolicy === 'function') app.setActivationPolicy('accessory')
+  /* Offscreen frames arrive here; nothing is ever shown on a display. A paint
+     callback is its own fault domain: one failed frame must not end the app. */
+  try {
+    window.webContents.setFrameRate(Number(env.DSH_FLASH_FRAME_RATE || 30))
+    window.webContents.on('paint', (event, dirty, image) => {
+      try {
+        latest = image
+        latestJpeg = image.toJPEG(Number(env.DSH_FLASH_JPEG_QUALITY || 72))
+        latestAt = Date.now()
+        painted += 1
+      } catch {
+        /* a frame that cannot be encoded is skipped; the next one may work */
+      }
+    })
+  } catch {
+    /* an Electron without offscreen painting falls back to the capture pump */
+  }
+  window.loadURL(env.DSH_FLASH_URL || 'about:blank')
+  /* Faster than the sidecar asks: it then always finds a fresh picture. */
+  pumpTimer = setInterval(pump, Number(env.DSH_FLASH_PUMP_MS || 40))
+
+  const port = Number(env.DSH_FLASH_BRIDGE_PORT || 0)
+  if (port > 0) {
+    http.createServer(async (request, response) => {
+      if (capture === null || !request.url) {
+        response.writeHead(404).end()
+        return
+      }
+      if (request.url.startsWith('/info')) {
+        const size = latest === null ? null : latest.getSize()
+        response.writeHead(200, { 'content-type': 'application/json' })
+        response.end(JSON.stringify({ size, age: latestAt === 0 ? null : Date.now() - latestAt, visible: capture.isVisible(), opacity: capture.getOpacity(), painted, bounds: capture.getBounds(), url: capture.webContents.getURL(), title: capture.webContents.getTitle() }))
+        return
+      }
+      if (request.url.startsWith('/resize')) {
+        /* The column is a tall, narrow pane: a 16:10 window letterboxes the
+           game into a strip. Resizing the window to the pane makes the picture
+           fill it and the JPEG smaller, since capture is window-sized. */
+        try {
+          const size = new URL(request.url, 'http://x').searchParams
+          const width = Math.max(200, Math.min(2560, Number(size.get('w') || 0)))
+          const height = Math.max(200, Math.min(2560, Number(size.get('h') || 0)))
+          if (Number.isFinite(width) && Number.isFinite(height)) {
+            if (alive(capture) !== true) { response.writeHead(503); response.end(); return }
+            capture.setBounds({ x: -3000, y: -3000, width: Math.round(width), height: Math.round(height) })
+          }
+          const bounds = capture.getBounds()
+          response.writeHead(200, { 'content-type': 'application/json' })
+          response.end(JSON.stringify({ bounds }))
+        } catch {
+          response.writeHead(500).end()
+        }
+        return
+      }
+      if (request.url.startsWith('/input')) {
+        /* Input goes straight into the page instead of round-tripping through
+           the debugging protocol: a press arrives in a few milliseconds, and a
+           game that reads its mouse every frame is not left behind. */
+        try {
+          if (request.method !== 'POST') { response.writeHead(405).end(); return }
+          const chunks = []
+          let bytes = 0
+          for await (const chunk of request) {
+            bytes += chunk.length
+            if (bytes > 8192) { response.writeHead(413).end(); return }
+            chunks.push(chunk)
+          }
+          const body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}')
+          if (alive(capture) !== true) { response.writeHead(503).end(); return }
+          const event = {}
+          for (const field of ['type', 'x', 'y', 'button', 'clickCount', 'deltaX', 'deltaY', 'keyCode', 'modifiers']) {
+            if (body[field] !== undefined && body[field] !== null) event[field] = body[field]
+          }
+          if (typeof event.type !== 'string' || event.type === '') { response.writeHead(400).end(); return }
+          capture.webContents.sendInputEvent(event)
+          response.writeHead(200, { 'content-type': 'application/json' })
+          response.end('{"ok":true}')
+        } catch {
+          response.writeHead(500).end()
+        }
+        return
+      }
+      if (!request.url.startsWith('/frame')) {
+        response.writeHead(404).end()
+        return
+      }
+      try {
+        const asked = Number(new URL(request.url, 'http://x').searchParams.get('q') || 0) // ui-copy-ignore
+        let jpeg = latestJpeg
+        if (jpeg === null || (asked > 0 && asked !== Number(env.DSH_FLASH_JPEG_QUALITY || 72))) {
+          const image = latest !== null ? latest : alive(capture) === true ? await capture.webContents.capturePage() : null
+          if (image === null) { response.writeHead(503); response.end(); return }
+          jpeg = image.toJPEG(asked > 0 ? asked : Number(env.DSH_FLASH_JPEG_QUALITY || 72))
+        }
+        response.writeHead(200, { 'content-type': 'image/jpeg', 'content-length': jpeg.length }) // ui-copy-ignore
+        response.end(jpeg)
+      } catch {
+        response.writeHead(503).end()
+      }
+    }).listen(port, '127.0.0.1')
+  }
+})

package/runtime/flash-app/package.json

@@ -0,0 +1 @@
+{"name":"dsh-flash-app","version":"1.0.0","private":true,"main":"main.js"}

package/runtime/flash-setup.mjs

@@ -0,0 +1,151 @@
+/* A page from the Flash era needs two things this plugin cannot put in its own
+   tarball: a browser that still speaks PPAPI, and the plugin itself. The first
+   is a Chromium build (BSD, redistributable); the second is Adobe's, which may
+   not be shipped. So the switch fetches both once, into the person's own state
+   directory, and afterwards the plugin works offline. */
+import { execFileSync } from 'node:child_process'
+import { existsSync, mkdirSync, renameSync, rmSync, statSync, readdirSync, copyFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/** Root of everything the Flash runtime keeps. */
+export const FLASH_DIR = join(homedir(), '.dsh', 'inner-browser-use', 'flash')
+
+/** Chromium 87 is the last build with PPAPI, and the last Electron 11. */
+const ELECTRON_VERSION = process.env.DSH_FLASH_ELECTRON_VERSION ?? '11.3.0'
+
+/** Launchers known to carry a Pepper Flash plugin build. */
+const LAUNCHERS = ['百田游戏安全管家.app', '百田游戏管家.app', 'Flash Player.app']
+
+/** Where a Pepper Flash plugin may already live on this machine. */
+const PLUGIN_PATHS = LAUNCHERS.flatMap((name) => [
+  join('/Applications', name, 'Contents', 'Resources', 'libs', 'PepperFlashPlayer.plugin'),
+  join(homedir(), 'Applications', name, 'Contents', 'Resources', 'libs', 'PepperFlashPlayer.plugin'),
+  join('/Library/Internet Plug-Ins', 'PepperFlashPlayer.plugin'),
+])
+
+/** @param {string} path - candidate. @returns {boolean} true when it is a plugin bundle. */
+function isPlugin(path) {
+  return existsSync(join(path, 'Contents', 'Info.plist'))
+}
+
+/** @returns {string | undefined} the plugin already installed here. */
+export function findPlugin() {
+  const noted = process.env.DSH_INNER_BROWSER_FLASH_PLUGIN
+  if (noted !== undefined && existsSync(noted)) return noted
+  const own = join(FLASH_DIR, 'plugin', 'PepperFlashPlayer.plugin')
+  if (isPlugin(own)) return own
+  return PLUGIN_PATHS.find((path) => isPlugin(path))
+}
+
+/** @param {string} bundle - a .plugin bundle. @returns {string} the loadable plugin file. */
+export function pluginExecutable(bundle) {
+  const inner = join(bundle, 'Contents', 'MacOS', 'PepperFlashPlayer')
+  return existsSync(inner) ? inner : bundle
+}
+
+/** @returns {string} where the Chromium 87 binary would be. */
+export function electronPath() {
+  return join(FLASH_DIR, 'electron', 'Electron.app', 'Contents', 'MacOS', 'Electron')
+}
+
+/** @returns {{ electron: string, plugin: string } | null} the runtime, when ready. */
+export function readyFlash() {
+  const electron = electronPath()
+  const bundle = findPlugin()
+  if (!existsSync(electron) || bundle === undefined) return null
+  return { electron, plugin: pluginExecutable(bundle) }
+}
+
+/** @returns {string} the Chromium 87 build matching this machine. */
+function electronUrl() {
+  const noted = process.env.DSH_FLASH_ELECTRON_URL
+  if (noted !== undefined) return noted
+  /* Flash exists as an x86_64 library only, so the browser that hosts it must
+     be x86_64 as well; on Apple silicon both run under Rosetta. */
+  return `https://npmmirror.com/mirrors/electron/${ELECTRON_VERSION}/electron-v${ELECTRON_VERSION}-darwin-x64.zip`
+}
+
+/**
+ * Fetch one URL to a file, saying how far along it is.
+ * @param {string} url - what to fetch.
+ * @param {string} file - where it lands.
+ * @param {(seen: number, total: number) => void} [progress] - byte counter.
+ * @returns {Promise<void>} resolves when the file is complete.
+ */
+async function download(url, file, progress) {
+  const response = await fetch(url, { redirect: 'follow' })
+  if (!response.ok) throw new Error(`flash: ${url} answered ${response.status}`)
+  const total = Number(response.headers.get('content-length') ?? 0)
+  const chunks = []
+  let seen = 0
+  for await (const chunk of response.body) {
+    chunks.push(chunk)
+    seen += chunk.length
+    progress?.(seen, total)
+  }
+  const body = Buffer.concat(chunks)
+  if (total > 0 && body.length !== total) throw new Error(`flash: short download (${body.length}/${total})`)
+  mkdirSync(join(file, '..'), { recursive: true })
+  await import('node:fs/promises').then((fs) => fs.writeFile(file, body))
+}
+
+/**
+ * Make the Flash runtime usable on this machine, fetching what is missing.
+ * @param {{ progress?: (line: string) => void }} [options] - reporting hook.
+ * @returns {Promise<{ electron: string, plugin: string }>} the runtime.
+ */
+export async function ensureFlash(options = {}) {
+  const say = options.progress ?? (() => {})
+  mkdirSync(FLASH_DIR, { recursive: true })
+  let plugin = findPlugin()
+
+  if (!existsSync(electronPath())) {
+    const zip = join(FLASH_DIR, 'cache', `electron-v${ELECTRON_VERSION}-darwin-x64.zip`)
+    if (!existsSync(zip) || statSync(zip).size < 40_000_000) {
+      const url = electronUrl()
+      say(`下载 Chromium 87（约 80 MB）: ${url}`)
+      let last = 0
+      await download(url, zip, (seen, total) => {
+        if (seen - last > 8_000_000) {
+          last = seen
+          say(`  ${Math.round(seen / 1e6)} MB${total === 0 ? '' : ` / ${Math.round(total / 1e6)} MB`}`)
+        }
+      })
+    }
+    const staging = join(FLASH_DIR, 'electron.tmp')
+    rmSync(staging, { recursive: true, force: true })
+    mkdirSync(staging, { recursive: true })
+    say('解压 Chromium 87')
+    execFileSync('/usr/bin/unzip', ['-q', '-o', zip, '-d', staging], { stdio: 'ignore' })
+    const app = join(staging, 'Electron.app')
+    if (!existsSync(app)) throw new Error('flash: the archive had no Electron.app')
+    rmSync(join(FLASH_DIR, 'electron'), { recursive: true, force: true })
+    renameSync(staging, join(FLASH_DIR, 'electron'))
+    say('Chromium 87 就绪')
+  }
+
+  if (plugin === undefined) {
+    throw new Error('flash: 这台机器上没有 Pepper Flash 插件；装一次任意带 Flash 的游戏客户端（例如百田游戏安全管家），或用 DSH_INNER_BROWSER_FLASH_PLUGIN 指向已有的 PepperFlashPlayer.plugin')
+  }
+
+  const electron = electronPath()
+  const pluginFile = pluginExecutable(plugin)
+  say(`Flash 运行时就绪: ${electron}`)
+  say(`插件: ${pluginFile}`)
+  return { electron, plugin: pluginFile }
+}
+
+/**
+ * Human-readable state, without fetching anything.
+ * @returns {{ ready: boolean, electron: boolean, plugin: string | null, dir: string }} the state.
+ */
+export function flashStatus() {
+  const plugin = findPlugin() ?? null
+  return {
+    ready: existsSync(electronPath()) && plugin !== null,
+    electron: existsSync(electronPath()),
+    plugin: plugin === null ? null : pluginExecutable(plugin),
+    dir: FLASH_DIR,
+  }
+}

package/runtime/swf.mjs

@@ -0,0 +1,233 @@
+/**
+ * Read a SWF far enough to talk about it: what it is, how long it plays, which
+ * ActionScript it needs, and what it is made of.
+ *
+ * This is the front half of the Flash-compatible runtime: the movie is a tag
+ * stream, and everything a renderer, an agent or a replay needs can be read off
+ * that stream without decoding a single shape. It does not draw.
+ */
+import { inflateSync } from 'node:zlib'
+
+/** Every tag this reader names; anything else is reported by number. */
+export const TAG_NAMES = {
+  0: 'End',
+  1: 'ShowFrame',
+  2: 'DefineShape',
+  4: 'PlaceObject',
+  5: 'RemoveObject',
+  6: 'DefineBits',
+  7: 'DefineButton',
+  8: 'JPEGTables',
+  9: 'SetBackgroundColor',
+  10: 'DefineFont',
+  11: 'DefineText',
+  12: 'DoAction',
+  13: 'DefineFontInfo',
+  14: 'DefineSound',
+  15: 'StartSound',
+  17: 'DefineButtonSound',
+  18: 'SoundStreamHead',
+  19: 'SoundStreamBlock',
+  20: 'DefineBitsLossless',
+  21: 'DefineBitsJPEG2',
+  22: 'DefineShape2',
+  24: 'Protect',
+  26: 'PlaceObject2',
+  28: 'RemoveObject2',
+  32: 'DefineShape3',
+  33: 'DefineText2',
+  34: 'DefineButton2',
+  35: 'DefineBitsJPEG3',
+  36: 'DefineBitsLossless2',
+  37: 'DefineEditText',
+  39: 'DefineSprite',
+  43: 'FrameLabel',
+  45: 'SoundStreamHead2',
+  46: 'DefineMorphShape',
+  48: 'DefineFont2',
+  56: 'ExportAssets',
+  57: 'ImportAssets',
+  58: 'EnableDebugger',
+  59: 'DoInitAction',
+  60: 'DefineVideoStream',
+  61: 'VideoFrame',
+  62: 'DefineFontInfo2',
+  65: 'ScriptLimits',
+  69: 'FileAttributes',
+  70: 'PlaceObject3',
+  73: 'DefineFontAlignZones',
+  74: 'CSMTextSettings',
+  75: 'DefineFont3',
+  76: 'SymbolClass',
+  77: 'Metadata',
+  78: 'DefineScalingGrid',
+  82: 'DoABC',
+  83: 'DefineShape4',
+  84: 'DefineMorphShape2',
+  86: 'DefineSceneAndFrameLabelData',
+  87: 'DefineBinaryData',
+  88: 'DefineFontName',
+  89: 'StartSound2',
+  90: 'DefineBitsJPEG4',
+  91: 'DefineFont4',
+}
+
+const SHAPES = new Set([2, 22, 32, 83])
+const BITMAPS = new Set([6, 20, 21, 35, 36, 90])
+const FONTS = new Set([10, 48, 75])
+const SOUNDS = new Set([14])
+const SPRITES = new Set([39])
+const AVM1 = new Set([12, 59, 26]) // DoAction, DoInitAction, PlaceObject2 actions
+const AVM2 = new Set([76, 72, 82]) // SymbolClass, DoABC2, DoABC
+
+/** Bit reader over the movie header, which is packed rather than byte aligned. */
+class Bits {
+  /** @param {Buffer} body - the bytes after the 8 byte file header. */
+  constructor(body) {
+    this.body = body
+    this.bit = 0
+  }
+
+  /** @param {number} n - how many bits, at most 32. @returns {number} unsigned value. */
+  read(n) {
+    let value = 0
+    for (let i = 0; i < n; i += 1) {
+      const byte = this.body[(this.bit / 8) | 0]
+      if (byte === undefined) throw new Error('the movie header ends in the middle of a rectangle')
+      value = value * 2 + ((byte >> (7 - (this.bit % 8))) & 1)
+      this.bit += 1
+    }
+    return value
+  }
+
+  /** @param {number} n - how many bits. @returns {number} signed value. */
+  readSigned(n) {
+    if (n === 0) return 0
+    const raw = this.read(n)
+    return raw >= 2 ** (n - 1) ? raw - 2 ** n : raw
+  }
+
+  /** @returns {number} the byte offset after the bits just read. */
+  get offset() {
+    return Math.ceil(this.bit / 8)
+  }
+}
+
+/**
+ * Read one tag stream.
+ * @param {Buffer} body - the movie, or the body of a sprite.
+ * @param {number} start - byte offset of the first tag.
+ * @param {() => number} budget - how many tags outside sprites to record.
+ * @returns {{tags: Array<{code: number, name: string, offset: number, length: number}>, counts: Record<string, number>}} the tags found.
+ */
+function readTags(body, start, budget) {
+  const tags = []
+  const histogram = {}
+  const counts = { shapes: 0, sprites: 0, bitmaps: 0, fonts: 0, sounds: 0, scripts: 0 }
+  let at = start
+  while (at + 2 <= body.length) {
+    const head = body.readUInt16LE(at)
+    let code = head >> 6
+    let length = head & 0x3f
+    let header = 2
+    if (length === 0x3f) {
+      if (at + 6 > body.length) break
+      length = body.readUInt32LE(at + 2)
+      header = 6
+    }
+    if (at + header + length > body.length) {
+      throw new Error(`tag ${code} at ${at} claims ${length} bytes past the end of the movie`)
+    }
+    if (code === 0) break
+    const payload = at + header
+    if (SHAPES.has(code)) counts.shapes += 1
+    if (SPRITES.has(code)) counts.sprites += 1
+    if (BITMAPS.has(code)) counts.bitmaps += 1
+    if (FONTS.has(code)) counts.fonts += 1
+    if (SOUNDS.has(code)) counts.sounds += 1
+    if (code === 82 || code === 72) counts.scripts += 1
+    const name = TAG_NAMES[code] ?? `tag ${code}`
+    histogram[name] = (histogram[name] ?? 0) + 1
+    if (budget() > 0) tags.push({ code, name, offset: at, length })
+    if (code === 39 && length >= 4) {
+      /* A sprite carries its own small tag stream; read it for the counts only. */
+      try {
+        const inner = readTags(body.subarray(payload + 4, payload + length), 0, () => 0)
+        for (const key of Object.keys(counts)) counts[key] += inner.counts[key] ?? 0
+      } catch {
+        /* a sprite this reader cannot walk still counts as a sprite */
+      }
+    }
+    at = payload + length
+  }
+  return { tags, counts, histogram }
+}
+
+/**
+ * Read a movie.
+ * @param {Buffer|Uint8Array} input - the file.
+ * @returns {object} header, whether it plays ActionScript 3, tag histogram and the first tags.
+ */
+export function parseSwf(input) {
+  const file = Buffer.isBuffer(input) ? input : Buffer.from(input)
+  if (file.length < 8) throw new Error('too short to be a SWF: 8 bytes of header are the minimum')
+  const signature = file.subarray(0, 3).toString('latin1')
+  if (signature !== 'FWS' && signature !== 'CWS' && signature !== 'ZWS') {
+    throw new Error(`not a SWF: it starts with ${JSON.stringify(signature)}`)
+  }
+  const version = file[3]
+  const declared = file.readUInt32LE(4)
+  let body
+  if (signature === 'FWS') body = file.subarray(8)
+  else if (signature === 'CWS') body = inflateSync(file.subarray(8))
+  else throw new Error('a ZWS movie is LZMA compressed, which this reader cannot open yet')
+  const bits = new Bits(body)
+  const nbits = bits.read(5)
+  const box = [bits.readSigned(nbits), bits.readSigned(nbits), bits.readSigned(nbits), bits.readSigned(nbits)]
+  const afterBox = bits.offset
+  const rate = body.readUInt16LE(afterBox)
+  const frames = body.readUInt16LE(afterBox + 2)
+  const frameRate = Number(((rate & 0xff) / 256 + (rate >>> 8)).toFixed(2))
+  let left = 40
+  const tags = readTags(body, afterBox + 4, () => (left-- > 0 ? 1 : 0))
+  const histogram = tags.histogram
+  const names = new Set(Object.keys(histogram))
+  const avm2ByTag = ['SymbolClass', 'DoABC', 'DoABC2'].some((name) => names.has(name))
+  const avm1ByTag = ['DoAction', 'DoInitAction', 'PlaceObject2'].some((name) => names.has(name))
+  const avm = avm2ByTag ? 'avm2' : avm1ByTag ? 'avm1' : 'none'
+  return {
+    signature,
+    version,
+    declaredBytes: declared,
+    bytes: file.length,
+    compressed: signature !== 'FWS',
+    width: Math.round((box[1] - box[0]) / 20),
+    height: Math.round((box[3] - box[2]) / 20),
+    frameRate,
+    frames,
+    avm,
+    counts: tags.counts,
+    histogram,
+    tags: tags.tags,
+  }
+}
+
+/**
+ * The report as lines a person or a model can read without the raw tag dump.
+ * @param {object} report - from parseSwf.
+ * @param {{tags?: number}} [options] - how many leading tags to list.
+ * @returns {string[]} lines.
+ */
+export function describeSwf(report, options = {}) {
+  const lines = [
+    `a ${report.signature} movie, version ${report.version}, ${report.bytes} bytes${report.compressed ? ` (${report.declaredBytes} uncompressed)` : ''}`,
+    `${report.width}x${report.height} at ${report.frameRate} frames a second, ${report.frames} frames (${(report.frames / Math.max(report.frameRate, 0.01)).toFixed(1)} s)`,
+    report.avm === 'none' ? 'no ActionScript' : `needs ${report.avm === 'avm2' ? 'ActionScript 3 (AVM2)' : 'ActionScript 1/2 (AVM1)'}`,
+    `made of ${report.counts.shapes} shape(s), ${report.counts.sprites} sprite(s), ${report.counts.bitmaps} bitmap(s), ${report.counts.fonts} font(s), ${report.counts.sounds} sound(s), ${report.counts.scripts} script block(s)`,
+  ]
+  const listed = report.tags.slice(0, options.tags ?? 12)
+  if (listed.length > 0) {
+    lines.push(`first tags ${listed.map((tag) => `${tag.name}@${tag.offset}+${tag.length}`).join(' ')}`)
+  }
+  return lines
+}