@erclx/canon 5.51.0 → 5.53.0

package/src/slides/package/motion.ts

@@ -1,316 +0,0 @@
-import type JSZip from 'jszip'
-
-/**
- * Slide transitions and entrance animations, written into a slide's XML after
- * pptxgenjs has written it, since pptxgenjs declares neither. A slide states
- * them in its HTML, `walk.ts` reads the attributes, and the converter resolves
- * each animated element to the object names `planSlide` gave its shapes. This
- * module turns those names into the shape ids the written XML assigned.
- */
-
-export interface TransitionSpec {
-  readonly effect: string
-  readonly duration?: string
-}
-
-export interface EntranceSpec {
-  /** The element that declared it, which every notice names. */
-  readonly selector: string
-  readonly effect: string
-  readonly order?: string
-  readonly duration?: string
-  /** Every shape drawn from the element and the elements inside it. */
-  readonly shapes: readonly string[]
-}
-
-export interface SlideMotion {
-  readonly transition?: TransitionSpec
-  readonly entrances: readonly EntranceSpec[]
-}
-
-export interface MotionResult {
-  readonly xml: string
-  readonly notices: readonly string[]
-}
-
-/** A slide's motion, numbered as the package numbers its slide parts. */
-export interface SlideMotionEdit {
-  readonly slide: number
-  readonly motion: SlideMotion
-}
-
-export interface MotionNotice {
-  readonly slide: number
-  readonly message: string
-}
-
-/** The child element `<p:transition>` holds, each in its default direction. */
-const TRANSITIONS: Readonly<Record<string, string>> = {
-  fade: '<p:fade/>',
-  push: '<p:push/>',
-  wipe: '<p:wipe/>',
-  cover: '<p:cover/>',
-}
-
-/**
- * The strict schema states a transition's length only as one of three speeds,
- * 0.5, 0.75, and 1 second. A length in milliseconds needs the PowerPoint 2010
- * extension namespace, so a declared duration rounds to the nearest speed.
- */
-function speedOf(duration: number | undefined): 'fast' | 'med' | 'slow' {
-  if (duration === undefined) return 'med'
-  if (duration < 625) return 'fast'
-  return duration < 875 ? 'med' : 'slow'
-}
-
-type Behaviors = (spid: string, duration: number, next: () => number) => string
-
-const target = (spid: string): string =>
-  `<p:tgtEl><p:spTgt spid="${spid}"/></p:tgtEl>`
-
-const animEffect =
-  (filter: string): Behaviors =>
-  (spid, duration, next) =>
-    `<p:animEffect transition="in" filter="${filter}"><p:cBhvr><p:cTn id="${next()}" dur="${duration}"/>${target(spid)}</p:cBhvr></p:animEffect>`
-
-function anim(
-  spid: string,
-  duration: number,
-  id: number,
-  attribute: string,
-  from: string,
-  to: string,
-): string {
-  return `<p:anim calcmode="lin" valueType="num"><p:cBhvr additive="base"><p:cTn id="${id}" dur="${duration}" fill="hold"/>${target(spid)}<p:attrNameLst><p:attrName>${attribute}</p:attrName></p:attrNameLst></p:cBhvr><p:tavLst><p:tav tm="0"><p:val><p:strVal val="${from}"/></p:val></p:tav><p:tav tm="100000"><p:val><p:strVal val="${to}"/></p:val></p:tav></p:tavLst></p:anim>`
-}
-
-interface Preset {
-  readonly id: number
-  readonly subtype: number
-  readonly behaviors: Behaviors
-}
-
-/**
- * PowerPoint's own preset ids, so the effect shows by name in its animation
- * pane. Fly comes in from the bottom and wipe from the left, the directions
- * PowerPoint picks when none is chosen. A wipe filter names the edge the
- * reveal starts from, so from the left pairs with `wipe(left)`.
- */
-const ENTRANCES: Readonly<Record<string, Preset>> = {
-  fade: { id: 10, subtype: 0, behaviors: animEffect('fade') },
-  fly: {
-    id: 2,
-    subtype: 4,
-    behaviors: (spid, duration, next) =>
-      anim(spid, duration, next(), 'ppt_x', '#ppt_x', '#ppt_x') +
-      anim(spid, duration, next(), 'ppt_y', '1+#ppt_h/2', '#ppt_y'),
-  },
-  wipe: { id: 22, subtype: 8, behaviors: animEffect('wipe(left)') },
-  zoom: {
-    id: 53,
-    subtype: 16,
-    behaviors: (spid, duration, next) =>
-      anim(spid, duration, next(), 'ppt_w', '0', '#ppt_w') +
-      anim(spid, duration, next(), 'ppt_h', '0', '#ppt_h') +
-      animEffect('fade')(spid, duration, next),
-  },
-}
-
-const DEFAULT_ENTRANCE_MS = 500
-
-const ANCHOR = '</p:clrMapOvr>'
-
-const list = (names: readonly string[]): string =>
-  `${names.slice(0, -1).join(', ')}, or ${names.at(-1)}`
-
-/**
- * The object names an entrance on `root` brings in: every shape drawn from it
- * and from the elements inside it, so a card's box and its text arrive on one
- * click. A descendant in `roots` declares its own entrance and keeps its
- * subtree for that click. A record follows its parent in document order, which
- * lets one pass collect the subtree.
- */
-export function entranceShapes(
-  root: number | null,
-  records: readonly { readonly id: number; readonly parent: number | null }[],
-  names: readonly { readonly record: number; readonly name: string }[],
-  roots: ReadonlySet<number>,
-): string[] {
-  if (root === null) return []
-  const subtree = new Set([root])
-  for (const record of records) {
-    const isOwnEntrance = roots.has(record.id)
-    if (
-      record.parent !== null &&
-      subtree.has(record.parent) &&
-      !isOwnEntrance
-    ) {
-      subtree.add(record.id)
-    }
-  }
-  return names
-    .filter((named) => subtree.has(named.record))
-    .map((named) => named.name)
-}
-
-/** Milliseconds from `500`, `500ms`, or `0.5s`, or undefined when unreadable. */
-export function millisecondsOf(value: string | undefined): number | undefined {
-  const match = /^\s*(\d+(?:\.\d+)?)\s*(ms|s)?\s*$/.exec(value ?? '')
-  if (!match?.[1]) return undefined
-  const amount = Number(match[1])
-  return Math.round(match[2] === 's' ? amount * 1000 : amount)
-}
-
-/**
- * pptxgenjs numbers a table `n * slideNumber + 1` and every other shape by its
- * index plus two, so a table can share an id with a shape beside it. A timing
- * target has to name one shape, so each repeat after the first takes a fresh id.
- */
-function uniqueIds(xml: string): string {
-  const pattern = /<p:cNvPr id="(\d+)"/g
-  let highest = Math.max(
-    0,
-    ...[...xml.matchAll(pattern)].map((match) => Number(match[1])),
-  )
-  const seen = new Set<string>()
-  return xml.replace(pattern, (whole, id: string) => {
-    if (!seen.has(id)) {
-      seen.add(id)
-      return whole
-    }
-    highest += 1
-    return `<p:cNvPr id="${highest}"`
-  })
-}
-
-function shapeIds(xml: string): Map<string, string> {
-  const ids = new Map<string, string>()
-  for (const [, id, name] of xml.matchAll(
-    /<p:cNvPr id="(\d+)" name="([^"]*)"/g,
-  )) {
-    if (id && name && !ids.has(name)) ids.set(name, id)
-  }
-  return ids
-}
-
-interface Click {
-  readonly preset: Preset
-  readonly duration: number
-  readonly spids: readonly string[]
-}
-
-function timingXml(clicks: readonly Click[]): string {
-  let counter = 2
-  const next = (): number => {
-    counter += 1
-    return counter
-  }
-  const pars = clicks.map((click) => {
-    const outer = next()
-    const inner = next()
-    const effects = click.spids.map((spid, index) => {
-      const nodeType = index === 0 ? 'clickEffect' : 'withEffect'
-      const effect = next()
-      const visible = `<p:set><p:cBhvr><p:cTn id="${next()}" dur="1" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst></p:cTn>${target(spid)}<p:attrNameLst><p:attrName>style.visibility</p:attrName></p:attrNameLst></p:cBhvr><p:to><p:strVal val="visible"/></p:to></p:set>`
-      const behaviors = click.preset.behaviors(spid, click.duration, next)
-      return `<p:par><p:cTn id="${effect}" presetID="${click.preset.id}" presetClass="entr" presetSubtype="${click.preset.subtype}" fill="hold" nodeType="${nodeType}"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${visible}${behaviors}</p:childTnLst></p:cTn></p:par>`
-    })
-    return `<p:par><p:cTn id="${outer}" fill="hold"><p:stCondLst><p:cond delay="indefinite"/></p:stCondLst><p:childTnLst><p:par><p:cTn id="${inner}" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${effects.join('')}</p:childTnLst></p:cTn></p:par></p:childTnLst></p:cTn></p:par>`
-  })
-  return `<p:timing><p:tnLst><p:par><p:cTn id="1" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst><p:seq concurrent="1" nextAc="seek"><p:cTn id="2" dur="indefinite" nodeType="mainSeq"><p:childTnLst>${pars.join('')}</p:childTnLst></p:cTn><p:prevCondLst><p:cond evt="onPrev" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:prevCondLst><p:nextCondLst><p:cond evt="onNext" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:nextCondLst></p:seq></p:childTnLst></p:cTn></p:par></p:tnLst></p:timing>`
-}
-
-/** Declared order first, then document order for ties and for no order. */
-function ordered(entrances: readonly EntranceSpec[]): EntranceSpec[] {
-  const rank = (entrance: EntranceSpec): number => {
-    const order = Number.parseFloat(entrance.order ?? '')
-    return Number.isFinite(order) ? order : Number.POSITIVE_INFINITY
-  }
-  return entrances.toSorted((a, b) => rank(a) - rank(b))
-}
-
-/**
- * Inserts the transition and an on-click main sequence after the slide's color
- * map override, where the schema orders them. Each entrance is one click, and
- * every shape drawn from its element comes in on that click together. A slide
- * missing the anchor is returned unchanged rather than patched elsewhere.
- */
-export function addMotion(xml: string, motion: SlideMotion): MotionResult {
-  const notices: string[] = []
-  let transition = ''
-  if (motion.transition) {
-    const element = TRANSITIONS[motion.transition.effect]
-    if (element) {
-      const speed = speedOf(millisecondsOf(motion.transition.duration))
-      transition = `<p:transition spd="${speed}">${element}</p:transition>`
-    } else {
-      notices.push(
-        `unknown transition ${motion.transition.effect}. Use ${list(Object.keys(TRANSITIONS))}`,
-      )
-    }
-  }
-
-  const numbered = uniqueIds(xml)
-  const ids = shapeIds(numbered)
-  const clicks: Click[] = []
-  for (const entrance of ordered(motion.entrances)) {
-    const preset = ENTRANCES[entrance.effect]
-    if (!preset) {
-      notices.push(
-        `${entrance.selector}: unknown entrance ${entrance.effect}. Use ${list(Object.keys(ENTRANCES))}`,
-      )
-      continue
-    }
-    const spids = entrance.shapes.flatMap((name) => {
-      const id = ids.get(name)
-      return id ? [id] : []
-    })
-    if (spids.length === 0) {
-      notices.push(
-        `${entrance.selector}: draws no shape, so its entrance has nothing to animate`,
-      )
-      continue
-    }
-    const duration = millisecondsOf(entrance.duration) ?? DEFAULT_ENTRANCE_MS
-    clicks.push({ preset, duration, spids })
-  }
-
-  const timing = clicks.length > 0 ? timingXml(clicks) : ''
-  if (!transition && !timing) return { xml, notices }
-  if (!xml.includes(ANCHOR)) {
-    return {
-      xml,
-      notices: [
-        ...notices,
-        `no ${ANCHOR} to anchor motion after, so none was written`,
-      ],
-    }
-  }
-  return {
-    xml: (timing ? numbered : xml).replace(
-      ANCHOR,
-      `${ANCHOR}${transition}${timing}`,
-    ),
-    notices,
-  }
-}
-
-/** Writes each slide's motion into the opened package and returns its notices. */
-export async function writeMotion(
-  zip: JSZip,
-  edits: readonly SlideMotionEdit[],
-): Promise<MotionNotice[]> {
-  const notices: MotionNotice[] = []
-  for (const { slide, motion } of edits) {
-    const path = `ppt/slides/slide${slide}.xml`
-    const xml = await zip.file(path)?.async('string')
-    if (xml === undefined) {
-      notices.push({ slide, message: `no ${path} in the written deck` })
-      continue
-    }
-    const result = addMotion(xml, motion)
-    if (result.xml !== xml) zip.file(path, result.xml)
-    notices.push(...result.notices.map((message) => ({ slide, message })))
-  }
-  return notices
-}

package/src/slides/package/test-face.ts

@@ -1,113 +0,0 @@
-/**
- * Builds the smallest sfnt the font step reads, holding only the `OS/2`,
- * `head`, and `name` tables an EOT header is built from, plus `fvar` when the
- * face should read as variable. It carries no glyphs, so it embeds and never
- * renders. Tests use it in place of a real face, whose license the repository
- * would then have to carry.
- */
-
-export interface TestFaceOptions {
-  readonly family?: string
-  readonly subfamily?: string
-  readonly weight?: number
-  readonly isItalic?: boolean
-  readonly fsType?: number
-  readonly isVariable?: boolean
-  /** The first four bytes, `0x00010000` for TrueType. */
-  readonly version?: number
-}
-
-/** Values distinct enough that a header copying the wrong field shows it. */
-export const TEST_FACE = {
-  panose: [2, 11, 5, 3, 3, 4, 3, 2, 2, 4],
-  unicodeRanges: [0xe0000aff, 0x5000e5ff, 0x00000009, 0x00000001],
-  codePages: [0x0000019f, 0x01020000],
-  checkSumAdjustment: 0x1234abcd,
-} as const
-
-function os2(options: TestFaceOptions): Buffer {
-  const table = Buffer.alloc(96)
-  table.writeUInt16BE(4, 0)
-  table.writeUInt16BE(options.weight ?? 400, 4)
-  table.writeUInt16BE(options.fsType ?? 0, 8)
-  Buffer.from(TEST_FACE.panose).copy(table, 32)
-  TEST_FACE.unicodeRanges.forEach((range, index) => {
-    table.writeUInt32BE(range, 42 + index * 4)
-  })
-  table.write('TEST', 58, 'latin1')
-  table.writeUInt16BE(options.isItalic ? 0x0001 : 0x0040, 62)
-  TEST_FACE.codePages.forEach((page, index) => {
-    table.writeUInt32BE(page, 78 + index * 4)
-  })
-  return table
-}
-
-function head(): Buffer {
-  const table = Buffer.alloc(54)
-  table.writeUInt32BE(0x00010000, 0)
-  table.writeUInt32BE(TEST_FACE.checkSumAdjustment, 8)
-  table.writeUInt32BE(0x5f0f3cf5, 12)
-  return table
-}
-
-function name(strings: ReadonlyMap<number, string>): Buffer {
-  const encoded = [...strings].map(([id, text]) => ({
-    id,
-    bytes: Buffer.from(text, 'utf16le').swap16(),
-  }))
-  const header = Buffer.alloc(6 + encoded.length * 12)
-  header.writeUInt16BE(0, 0)
-  header.writeUInt16BE(encoded.length, 2)
-  header.writeUInt16BE(header.length, 4)
-  let offset = 0
-  encoded.forEach(({ id, bytes }, index) => {
-    const at = 6 + index * 12
-    header.writeUInt16BE(3, at)
-    header.writeUInt16BE(1, at + 2)
-    header.writeUInt16BE(0x0409, at + 4)
-    header.writeUInt16BE(id, at + 6)
-    header.writeUInt16BE(bytes.length, at + 8)
-    header.writeUInt16BE(offset, at + 10)
-    offset += bytes.length
-  })
-  return Buffer.concat([header, ...encoded.map(({ bytes }) => bytes)])
-}
-
-export function testFace(options: TestFaceOptions = {}): Buffer {
-  const family = options.family ?? 'Fixture Sans'
-  const subfamily = options.subfamily ?? 'Regular'
-  const tables = new Map<string, Buffer>([
-    ['OS/2', os2(options)],
-    ['head', head()],
-    [
-      'name',
-      name(
-        new Map([
-          [1, family],
-          [2, subfamily],
-          [4, `${family} ${subfamily}`],
-          [5, 'Version 1.000'],
-        ]),
-      ),
-    ],
-  ])
-  if (options.isVariable) tables.set('fvar', Buffer.alloc(16))
-
-  const entries = [...tables].sort(([a], [b]) => a.localeCompare(b))
-  const directory = Buffer.alloc(12 + entries.length * 16)
-  directory.writeUInt32BE(options.version ?? 0x00010000, 0)
-  directory.writeUInt16BE(entries.length, 4)
-  let offset = directory.length
-  const bodies: Buffer[] = []
-  entries.forEach(([tag, table], index) => {
-    const at = 12 + index * 16
-    directory.write(tag, at, 'latin1')
-    directory.writeUInt32BE(offset, at + 8)
-    directory.writeUInt32BE(table.length, at + 12)
-    const padded = Buffer.alloc(Math.ceil(table.length / 4) * 4)
-    table.copy(padded)
-    bodies.push(padded)
-    offset += padded.length
-  })
-  return Buffer.concat([directory, ...bodies])
-}

package/src/teach/browser/compile.ts

@@ -1,44 +0,0 @@
-type BrowserFunction = (...args: never[]) => unknown
-
-const transpiler = new Bun.Transpiler({ loader: 'ts' })
-
-const MODULE_SYNTAX = /^\s*(import|export)\b/m
-
-/**
- * `</script>` inside a serialized argument would end the block early, and
- * `<` is the same character to the JavaScript parser.
- */
-function serialize(args: readonly unknown[]): string {
-  return JSON.stringify(args).slice(1, -1).replace(/</g, '\\u003c')
-}
-
-/**
- * Turns a browser module's function into the `<script>` a page carries. The
- * transpiler does not bundle, so a module is self-contained: whatever it
- * calls but does not define arrives as a named function in `helpers`, and a
- * value it needs arrives in `args`. Output holding module syntax throws, since
- * a script block with an `import` fails in the browser with nothing in the
- * type checker to say so.
- */
-export function compileScript(
-  run: BrowserFunction,
-  args: readonly unknown[] = [],
-  helpers: readonly BrowserFunction[] = [],
-): string {
-  const source = helpers.length
-    ? `(function () {\n${helpers.map(String).join('\n')}\nreturn ${run};\n})()`
-    : String(run)
-  // A bare expression statement is dead code to the transpiler and comes back
-  // empty, so the source rides an export that it must keep.
-  const code = transpiler
-    .transformSync(`export default ${source}`)
-    .trim()
-    .replace(/^export default /, '')
-    .replace(/;$/, '')
-
-  if (MODULE_SYNTAX.test(code)) {
-    throw new Error(`Browser module ${run.name} left import or export syntax`)
-  }
-
-  return `<script>(${code})(${serialize(args)})</script>`
-}

package/src/teach/browser/dismiss.ts

@@ -1,76 +0,0 @@
-export function dismiss(): void {
-  var MENUS = 'details.jump[open], details.sb-ws[open]'
-
-  function close(except: Element | null) {
-    document.querySelectorAll<HTMLDetailsElement>(MENUS).forEach(function (d) {
-      if (d !== except) d.open = false
-    })
-  }
-  document.addEventListener('click', function (e) {
-    var inside = (e.target as Element).closest('details.jump, details.sb-ws')
-    close(inside)
-  })
-  document.addEventListener('keydown', function (e) {
-    if (e.key !== 'Escape') return
-    var open = document.querySelector<HTMLDetailsElement>(MENUS)
-    if (!open) return
-    open.open = false
-    var s = open.querySelector('summary')
-    if (s) s.focus()
-  })
-
-  /* Hover intent on the breadcrumb only. The sidebar's workspace switcher stays
-     click-only on purpose: its panel opens directly over the lesson list, which
-     is where the pointer is headed, so hovering it would cover the thing
-     being reached for. The breadcrumb's panel drops over body text instead. */
-  var OPEN = 120,
-    SHUT = 260
-
-  document
-    .querySelectorAll<HTMLDetailsElement>('details.jump')
-    .forEach(function (d) {
-      var host = d.closest('.crumb-item') || d
-      var timer: ReturnType<typeof setTimeout> | undefined
-      var openedByHover = false
-
-      function arm(want: boolean) {
-        clearTimeout(timer)
-        timer = setTimeout(
-          function () {
-            if (want) close(d)
-            d.open = want
-          },
-          want ? OPEN : SHUT,
-        )
-      }
-
-      host.addEventListener('mouseenter', function () {
-        if (!d.open) openedByHover = true
-        arm(true)
-      })
-      host.addEventListener('mouseleave', function () {
-        openedByHover = false
-        arm(false)
-      })
-      /* Keeps it open while the pointer is inside the panel, without cancelling a
-       pending open, which is what silently disabled this on one of two menus. */
-      d.addEventListener('mouseenter', function () {
-        if (d.open) clearTimeout(timer)
-      })
-
-      /* Hover and click were wired to one disclosure and fought: hover opened the
-       panel, then the summary's native click toggled what hover had already
-       opened, so reaching for an item shut it. A click on a panel hover opened
-       keeps it open, and a second click closes. The click path stays live for
-       touch, where no hover exists, and for the keyboard, where Enter is the
-       only way in. */
-      var summary = d.querySelector('summary')
-      if (summary)
-        summary.addEventListener('click', function (e) {
-          if (d.open && openedByHover) {
-            e.preventDefault()
-            openedByHover = false
-          }
-        })
-    })
-}

package/src/teach/browser/focus-line.ts

@@ -1,19 +0,0 @@
-/**
- * The outline rail's focus-line ramp. It runs from near the top at scroll 0 to
- * the viewport's bottom edge at max scroll, so the last heading is reachable
- * however little content trails it. A ramp ending 120px short of the edge left
- * a heading with under 120px after it permanently unmarked, since its top never
- * fell below the line even at max scroll.
- *
- * The sidebar script embeds this function's own source, so a test exercises
- * what the browser runs.
- */
-export function focusLine(
-  scrollY: number,
-  max: number,
-  innerHeight: number,
-): number {
-  if (max <= 0) return innerHeight
-  var progress = Math.min(1, Math.max(0, scrollY / max))
-  return 120 + progress * Math.max(0, innerHeight - 120)
-}

package/src/teach/browser/glossary-filter.ts

@@ -1,44 +0,0 @@
-export function glossaryFilter(): void {
-  var input = document.getElementById('gfilter') as HTMLInputElement | null
-  var list = document.getElementById('gloss')
-  var count = document.getElementById('gloss-count')
-  if (!input || !list) return
-  var field = input
-  var terms = list
-  function updateGroups() {
-    terms.querySelectorAll('.gloss-group').forEach(function (heading) {
-      var el = heading.nextElementSibling as HTMLElement | null
-      var any = false
-      while (el && !el.classList.contains('gloss-group')) {
-        if (el.style.display !== 'none') any = true
-        el = el.nextElementSibling as HTMLElement | null
-      }
-      ;(heading as HTMLElement).style.display = any ? '' : 'none'
-    })
-  }
-  field.addEventListener('input', function () {
-    var q = field.value.toLowerCase()
-    var n = 0
-    terms.querySelectorAll<HTMLElement>('.gterm').forEach(function (entry) {
-      var match = (entry.textContent as string).toLowerCase().includes(q)
-      entry.style.display = match ? '' : 'none'
-      if (match) n++
-    })
-    terms.classList.toggle('none', n === 0)
-    updateGroups()
-    if (count) {
-      var total = terms.querySelectorAll('.gterm').length
-      count.textContent =
-        (n === total ? total : n + ' of ' + total) +
-        (total === 1 ? ' term' : ' terms')
-    }
-  })
-  var clear = terms.querySelector('.clear')
-  if (clear) {
-    clear.addEventListener('click', function () {
-      field.value = ''
-      field.dispatchEvent(new Event('input'))
-      field.focus()
-    })
-  }
-}

package/src/teach/browser/head.ts

@@ -1,30 +0,0 @@
-/**
- * The panel's state, settled before the first paint rather than after it. An
- * arm that set the narrow default afterwards slid the panel in and back out on
- * every load, and a restored custom width animated in from the default.
- *
- * A listing page starts shut because the body already lists what the panel
- * would, and a lesson starts open because there the panel is the only
- * cross-lesson navigation on the page. A stored preference beats both. A count
- * threshold on its own was built and reverted, since it hides the panel on a
- * lesson too.
- */
-export function head(page: 'index' | 'lesson', breakpoint: number): void {
-  var r = document.documentElement
-  var s: string | null = null
-  r.dataset.page = page
-  if (matchMedia('(max-width: ' + breakpoint + 'px)').matches) {
-    r.classList.add('sb-shut')
-    return
-  }
-  try {
-    s = localStorage.getItem('teach-sb')
-  } catch {}
-  var idx = r.dataset.page === 'index'
-  if (s === 'shut' || (s === null && idx)) r.classList.add('sb-shut')
-  var w: string | null = null
-  try {
-    w = localStorage.getItem('teach-sb-w')
-  } catch {}
-  if (w) r.style.setProperty('--sb-w', w + 'px')
-}

package/src/teach/browser/quiz.ts

@@ -1,19 +0,0 @@
-/**
- * What reveals feedback in a lesson written with button options. The radio
- * shape needs none of it.
- */
-export function quiz(): void {
-  document.querySelectorAll<HTMLElement>('.q').forEach(function (q) {
-    var f = q.querySelector('.fb') as HTMLElement
-    q.querySelectorAll<HTMLElement>('.opt').forEach(function (b) {
-      b.addEventListener('click', function () {
-        if (f.classList.contains('show')) return
-        q.querySelectorAll<HTMLElement>('.opt').forEach(function (o) {
-          o.dataset.state =
-            o.dataset.a === '1' ? 'right' : o === b ? 'chosen' : 'wrong'
-        })
-        f.classList.add('show')
-      })
-    })
-  })
-}

package/src/teach/browser/reload.ts

@@ -1,9 +0,0 @@
-/* Spliced in by `canon teach up` at serve time and never written to a page, so
-   the server sends a message only once a refresh has landed on disk. */
-export function reload(path: string): void {
-  var source = new EventSource(path)
-  source.onmessage = function () {
-    source.close()
-    location.reload()
-  }
-}