@reekon-tools/react-native-pdf-canvas 0.1.1 → 0.2.0

package/ios/Tests/PdfCanvasCoreTests/TestPdfs.swift

@@ -1,639 +0,0 @@
-import Foundation
-
-/**
- PDFs built in memory, so a test has no asset to ship and the content is known
- exactly rather than eyeballed.
-
- A PORT OF `android/src/androidTest/.../TestPdfs.java`, and the port is the point:
- the two backends are checked against the same geometry, the same markers and the
- same encryption scheme, so a disagreement between platforms is a disagreement
- about rendering rather than about fixtures.
-
- One thing is written by hand here that Android gets from the platform:
- `android.graphics.pdf.PdfDocument` can author a page but has no way to set
- `/Rotate`, so the Java version hand-writes the rotated fixture and uses the
- platform for the rest. There is no PDF *writer* in CoreGraphics that lets a test
- set `/Rotate` or `/CropBox` either, and `CGPDFContext` would author through the
- same drawing model being tested — so every fixture here is hand-written. That is
- strictly better for a rendering test: the bytes are the input, and nothing about
- what they mean depends on the code under test.
- */
-enum TestPdfs {
-  static let letterW = 612
-  static let letterH = 792
-  /// ARCH-D, the sheet size this package exists for.
-  static let archDW = 1728
-  static let archDH = 2592
-
-  // ---------------------------------------------------------------- //
-  // The writer
-  // ---------------------------------------------------------------- //
-
-  /// Assembles objects and writes a correct xref table, which every reader prefers.
-  final class Writer {
-    private var out = Data()
-    private var offsets: [Int] = []
-
-    init() {
-      write("%PDF-1.4\n")
-      // A binary comment line marks the file as binary, per the spec's advice.
-      out.append(contentsOf: [0x25, 0xE2, 0xE3, 0xCF, 0xD3, 0x0A])
-    }
-
-    func write(_ s: String) {
-      // Latin-1, not UTF-8: a PDF's syntax layer is bytes, and every string this
-      // writer emits is ASCII. Using UTF-8 would silently change the byte length
-      // of any non-ASCII content and invalidate a /Length.
-      out.append(s.data(using: .isoLatin1)!)
-    }
-
-    func write(_ bytes: Data) {
-      out.append(bytes)
-    }
-
-    /// How many objects have been written. The next `add` returns this plus one.
-    var count: Int { offsets.count }
-
-    /// - Returns: the object number, 1-based.
-    @discardableResult
-    func add(_ body: String) -> Int {
-      add(body.data(using: .isoLatin1)!)
-    }
-
-    @discardableResult
-    func add(_ body: Data) -> Int {
-      let number = offsets.count + 1
-      offsets.append(out.count)
-      write("\(number) 0 obj\n")
-      write(body)
-      write("\nendobj\n")
-      return number
-    }
-
-    /**
-     Writes at least `atLeast` bytes of PDF COMMENT lines.
-
-     A `%` line is legal anywhere between objects and is never drawn, so this
-     changes the file's LENGTH and nothing else — which is the only lever a
-     header-window test needs. Call it after the last `add()` and before
-     `finish()`, so the trailer moves while every recorded xref offset stays
-     correct.
-     */
-    func pad(atLeast: Int) {
-      var s = ""
-      var line = 0
-      while s.utf8.count < atLeast {
-        s += "% padding line \(line) - legal PDF comment, never drawn\n"
-        line += 1
-      }
-      write(s)
-    }
-
-    func finish(rootObject: Int, extraTrailer: String = "") -> Data {
-      let xref = out.count
-      let size = offsets.count + 1
-      write("xref\n0 \(size)\n")
-      write("0000000000 65535 f \n")
-      for offset in offsets {
-        write(String(format: "%010d 00000 n \n", offset))
-      }
-      write(
-        "trailer\n<< /Size \(size) /Root \(rootObject) 0 R \(extraTrailer) >>\n"
-          + "startxref\n\(xref)\n%%EOF\n")
-      return out
-    }
-  }
-
-  // ---------------------------------------------------------------- //
-  // Single-page fixtures
-  // ---------------------------------------------------------------- //
-
-  /// A single page with an explicit MediaBox, optional CropBox, `/Rotate` and content.
-  static func page(
-    mediaBox: (Int, Int, Int, Int),
-    cropBox: (Int, Int, Int, Int)? = nil,
-    rotate: Int = 0,
-    annots: String? = nil,
-    extraObjects: ((Writer) -> String)? = nil,
-    content: String
-  ) -> Data {
-    let w = Writer()
-    let stream = content.data(using: .isoLatin1)!
-    let contents = w.add("<< /Length \(stream.count) >>\nstream\n\(content)endstream")
-    // Whatever the caller needs to exist BEFORE the page dictionary that names it
-    // — an annotation and its appearance stream, say. It is handed the writer, so
-    // it learns its own object numbers rather than being told them.
-    let extra = extraObjects?(w) ?? ""
-    // COMPUTED, not hardcoded. `/Parent` has to name the page tree, which is
-    // written two objects from now; an earlier version of this writer wrote
-    // "3 0 R" and broke the moment `extraObjects` added anything, because a page
-    // whose /Parent points at its own annotation makes readers rebuild the tree
-    // and a test would still pass for the wrong reason.
-    let pagesNumber = w.count + 2
-    var dict = "<< /Type /Page /Parent \(pagesNumber) 0 R /MediaBox "
-      + "[\(mediaBox.0) \(mediaBox.1) \(mediaBox.2) \(mediaBox.3)]"
-    if let crop = cropBox {
-      dict += " /CropBox [\(crop.0) \(crop.1) \(crop.2) \(crop.3)]"
-    }
-    if rotate != 0 { dict += " /Rotate \(rotate)" }
-    if let annots { dict += " /Annots \(annots)" }
-    dict += extra
-    dict += " /Contents \(contents) 0 R /Resources << >> >>"
-    let pageObj = w.add(dict)
-    let pages = w.add("<< /Type /Pages /Kids [\(pageObj) 0 R] /Count 1 >>")
-    let catalog = w.add("<< /Type /Catalog /Pages \(pages) 0 R >>")
-    precondition(pages == pagesNumber, "Pages object is \(pages), not \(pagesNumber)")
-    return w.finish(rootObject: catalog)
-  }
-
-  /**
-   Four saturated quadrants in PDF user space (y-up): red bottom-left, green
-   bottom-right, blue top-left, black top-right.
-
-   Saturated is what makes a channel-order test possible at all — a grey or white
-   page reads identically in RGBA and BGRA, so the two orderings are
-   indistinguishable on it. Quadrants also make a STRIDE error visible: a raster
-   read back with the wrong row stride walks diagonally across the boundaries, so
-   the sampled colours come out wrong rather than merely shifted. And because the
-   four differ in both axes, a y-flip and an x/y transposition each move half the
-   pixels.
-   */
-  static func quadrants(width: Int, height: Int, rotate: Int = 0) -> Data {
-    let hw = width / 2
-    let hh = height / 2
-    let content = """
-      1 0 0 rg 0 0 \(hw) \(hh) re f
-      0 1 0 rg \(hw) 0 \(hw) \(hh) re f
-      0 0 1 rg 0 \(hh) \(hw) \(hh) re f
-      0 0 0 rg \(hw) \(hh) \(hw) \(hh) re f
-
-      """
-    return page(mediaBox: (0, 0, width, height), rotate: rotate, content: content)
-  }
-
-  /**
-   Detail at every spatial frequency: a `pitch`-point grid catches a scale error,
-   and the two diagonals catch an x/y transposition.
-
-   Also the fixture the timing tests use, because a page of 500+ stroked lines is
-   the shape a real drawing has — a flat colour fill measures the memory system
-   rather than the rasterizer.
-   */
-  static func grid(width: Int, height: Int, pitch: Int = 8) -> Data {
-    var content = "1 1 1 rg 0 0 \(width) \(height) re f\n0 0 0 RG 0.5 w\n"
-    for x in stride(from: 0, through: width, by: pitch) {
-      content += "\(x) 0 m \(x) \(height) l S\n"
-    }
-    for y in stride(from: 0, through: height, by: pitch) {
-      content += "0 \(y) m \(width) \(y) l S\n"
-    }
-    content += "1 0 0 RG 2 w 0 0 m \(width) \(height) l S "
-      + "\(width) 0 m 0 \(height) l S\n"
-    return page(mediaBox: (0, 0, width, height), content: content)
-  }
-
-  /**
-   A 612x792 page carrying `/Rotate 90`, red filling the UNROTATED top-left
-   112x100 points and blue the unrotated bottom-left.
-
-   `/Rotate` is "degrees the page shall be rotated CLOCKWISE when displayed", so a
-   correct renderer reports 792x612 and puts red at the displayed TOP-RIGHT and
-   blue at the displayed TOP-LEFT. Both markers matter: swapped dimensions alone
-   would also be produced by an implementation that swapped width and height and
-   drew the content unrotated, and a single marker cannot tell a 90 from a 270.
-
-   PDF user space is y-UP from the bottom-left, so the top-left 112x100 of the
-   page is the rect (0, 692) to (112, 792).
-   */
-  static func rotated(_ degrees: Int) -> Data {
-    let content = """
-      1 1 1 rg 0 0 \(letterW) \(letterH) re f
-      1 0 0 rg 0 692 112 100 re f
-      0 0 1 rg 0 0 112 100 re f
-
-      """
-    return page(mediaBox: (0, 0, letterW, letterH), rotate: degrees, content: content)
-  }
-
-  /**
-   A page whose CropBox is offset from its MediaBox, with a red marker at the crop
-   box's own top-left and a blue one at its bottom-right.
-
-   The only fixture that can tell "the box origin was subtracted" from "the box
-   origin was ignored": with MediaBox `0 0 400 400` and CropBox `100 150 300 350`,
-   a renderer that ignores the offset draws the markers 100pt too far right and
-   50pt too far down, which on a grey page is invisible unless something samples
-   the corners.
-   */
-  static func offsetCropBox() -> Data {
-    // CropBox (100, 150) to (300, 350): 200 x 200 points, top-left at (100, 350).
-    let content = """
-      0.5 0.5 0.5 rg 0 0 400 400 re f
-      1 0 0 rg 100 310 40 40 re f
-      0 0 1 rg 260 150 40 40 re f
-
-      """
-    return page(
-      mediaBox: (0, 0, 400, 400), cropBox: (100, 150, 300, 350), content: content)
-  }
-
-  /// A CropBox that overhangs its MediaBox, so the spec-mandated intersection is testable.
-  static func cropBoxOverhangingMediaBox() -> Data {
-    let content = "0.5 0.5 0.5 rg 0 0 200 200 re f\n"
-    return page(
-      mediaBox: (0, 0, 200, 200), cropBox: (50, 50, 400, 400), content: content)
-  }
-
-  /**
-   An antialiased opaque-white circle on an otherwise empty page.
-
-   Rendered with `background: transparent` this is the fixture that decides the
-   alpha encoding: a 62%-covered white edge reads `[255,255,255,158]` straight and
-   `[158,158,158,158]` premultiplied. Every pixel on the circle's boundary is
-   partially covered, so there is no need to hunt for one.
-   */
-  static func antialiasedWhiteEdge() -> Data {
-    let content = """
-      1 1 1 rg
-      50 10 m
-      72.09 10 90 27.91 90 50 c
-      90 72.09 72.09 90 50 90 c
-      27.91 90 10 72.09 10 50 c
-      10 27.91 27.91 10 50 10 c
-      f
-
-      """
-    return page(mediaBox: (0, 0, 100, 100), content: content)
-  }
-
-  /**
-   A page whose only green content is inside an ANNOTATION's appearance stream.
-
-   The fixture the `annotations` flag is decided by, and it has to be built this
-   way round: the content stream paints nothing green, so green in the raster can
-   only have come from compositing the annotation. `annotations: true` (PDFKit)
-   must show it and `annotations: false` (`CGContextDrawPDFPage`) must not — which
-   is the one capability difference between this backend and Android's, where the
-   flag cannot be honoured at all.
-
-   A `/Square` annotation with an explicit `/AP << /N ... >>` normal appearance
-   stream, because an annotation with no appearance stream is up to the reader to
-   synthesise and two readers will not agree on it.
-   */
-  static func annotatedPage() -> Data {
-    let content = "1 1 1 rg 0 0 200 200 re f\n1 0 0 rg 10 10 30 30 re f\n"
-    // The annotation and its appearance stream have to be written BEFORE the page
-    // dictionary that names them, so the `/Annots` array cannot be a literal — it
-    // is built from the object number `extraObjects` actually got. An earlier
-    // version hardcoded `[5 0 R]` and pointed at the page tree instead, which made
-    // the annotation unreachable and would have let the test pass by drawing
-    // nothing.
-    var annotsArray = ""
-    let data = page(
-      mediaBox: (0, 0, 200, 200),
-      annots: nil,
-      extraObjects: { w in
-        let appearance = "0 1 0 rg 0 0 100 100 re f\n"
-        let stream = appearance.data(using: .isoLatin1)!
-        let ap = w.add(
-          "<< /Type /XObject /Subtype /Form /BBox [0 0 100 100] "
-            + "/Length \(stream.count) >>\nstream\n\(appearance)endstream")
-        let annot = w.add(
-          "<< /Type /Annot /Subtype /Square /Rect [50 50 150 150] /F 4 "
-            + "/AP << /N \(ap) 0 R >> >>")
-        annotsArray = "[\(annot) 0 R]"
-        return " /Annots [\(annot) 0 R]"
-      },
-      content: content)
-    precondition(!annotsArray.isEmpty, "the annotation was never written")
-    return data
-  }
-
-  // ---------------------------------------------------------------- //
-  // Multi-page fixtures
-  // ---------------------------------------------------------------- //
-
-  /**
-   Pages of DIFFERENT sizes in one document, so a geometry test can catch an
-   implementation that probes page 0 and reports its size for every page.
-   */
-  static let mixedSizes: [(Int, Int)] = [
-    (letterW, letterH), (archDW, archDH), (200, 900),
-  ]
-
-  static func mixedSizeDocument() -> Data {
-    multiPage(mixedSizes.map { size in
-      (size, 0, "0.5 0.5 0.5 rg 0 0 \(size.0) \(size.1) re f\n")
-    })
-  }
-
-  /**
-   One flat colour per page.
-
-   Catches a backend that ignores `RasterRequest.page` and renders page 0 for every
-   request — which a single-page fixture cannot catch at all, and a multi-page
-   fixture with identical pages catches only by luck.
-   */
-  static func coloredPages(_ colors: [(Double, Double, Double)], width: Int, height: Int)
-    -> Data
-  {
-    multiPage(
-      colors.map { color in
-        (
-          (width, height), 0,
-          "\(color.0) \(color.1) \(color.2) rg 0 0 \(width) \(height) re f\n"
-        )
-      })
-  }
-
-  /// Pages with different `/Rotate` values, so post-rotation geometry is testable per page.
-  static func rotatedPages(_ rotations: [Int]) -> Data {
-    multiPage(
-      rotations.map { rotation in
-        ((200, 100), rotation, "1 0 0 rg 0 0 40 40 re f\n0 0 1 rg 0 60 40 40 re f\n")
-      })
-  }
-
-  /// - Parameter pages: `(size, rotate, content)` per page.
-  static func multiPage(_ pages: [((Int, Int), Int, String)]) -> Data {
-    let w = Writer()
-    // The page tree is object 1 and every page's /Parent points at it, so the
-    // pages have to be numbered afterwards. Object 1 is therefore RESERVED with a
-    // placeholder and rewritten at the end — which a linear writer cannot do, so
-    // instead the content streams and pages come first and the tree last, with
-    // /Parent naming a number computed up front.
-    let contentObjects = pages.map { page -> Int in
-      let stream = page.2.data(using: .isoLatin1)!
-      return w.add("<< /Length \(stream.count) >>\nstream\n\(page.2)endstream")
-    }
-    // After the content streams, the next `pages.count` objects are the pages, and
-    // the one after those is the tree.
-    let treeNumber = contentObjects.count + pages.count + 1
-    var pageObjects: [Int] = []
-    for (index, page) in pages.enumerated() {
-      var dict = "<< /Type /Page /Parent \(treeNumber) 0 R /MediaBox "
-        + "[0 0 \(page.0.0) \(page.0.1)]"
-      if page.1 != 0 { dict += " /Rotate \(page.1)" }
-      dict += " /Contents \(contentObjects[index]) 0 R /Resources << >> >>"
-      pageObjects.append(w.add(dict))
-    }
-    let kids = pageObjects.map { "\($0) 0 R" }.joined(separator: " ")
-    let tree = w.add("<< /Type /Pages /Kids [\(kids)] /Count \(pages.count) >>")
-    precondition(tree == treeNumber, "tree is \(tree), predicted \(treeNumber)")
-    let catalog = w.add("<< /Type /Catalog /Pages \(tree) 0 R >>")
-    return w.finish(rootObject: catalog)
-  }
-
-  // ---------------------------------------------------------------- //
-  // Not-PDFs
-  // ---------------------------------------------------------------- //
-
-  /// A valid `%PDF-` header and nothing else that parses.
-  static func headerOnlyGarbage() -> Data {
-    var s = "%PDF-1.7\n"
-    for i in 0..<200 { s += "garbage line \(i)\n" }
-    return s.data(using: .isoLatin1)!
-  }
-
-  /// No `%PDF-` header anywhere in the first 1024 bytes.
-  static func notAPdfAtAll() -> Data {
-    var s = ""
-    for i in 0..<200 { s += "this is a text file, line \(i)\n" }
-    s += "%PDF-1.7 too late to count\n"
-    return s.data(using: .isoLatin1)!
-  }
-
-  // ---------------------------------------------------------------- //
-  // Encryption (standard security handler, R=2, V=1, RC4-40)
-  // ---------------------------------------------------------------- //
-
-  static let userPassword = "secret"
-  /// Non-empty, and that is load-bearing — see the note in `encrypted()`.
-  static let ownerPassword = "owner"
-
-  private static let pad: [UInt8] = [
-    0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56,
-    0xFF, 0xFA, 0x01, 0x08, 0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80,
-    0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A,
-  ]
-
-  private static func padded(_ password: String) -> [UInt8] {
-    let pw = Array(password.data(using: .isoLatin1)!)
-    var out = [UInt8](repeating: 0, count: 32)
-    let n = min(pw.count, 32)
-    for i in 0..<n { out[i] = pw[i] }
-    for i in n..<32 { out[i] = pad[i - n] }
-    return out
-  }
-
-  /// RC4, by hand, because CommonCrypto's RC4 is deprecated and gated.
-  private static func rc4(key: [UInt8], data: [UInt8]) -> [UInt8] {
-    var s = Array(0..<256)
-    var j = 0
-    for i in 0..<256 {
-      j = (j + s[i] + Int(key[i % key.count])) & 0xFF
-      s.swapAt(i, j)
-    }
-    var out = [UInt8](repeating: 0, count: data.count)
-    var i = 0
-    j = 0
-    for k in 0..<data.count {
-      i = (i + 1) & 0xFF
-      j = (j + s[i]) & 0xFF
-      s.swapAt(i, j)
-      out[k] = data[k] ^ UInt8(s[(s[i] + s[j]) & 0xFF])
-    }
-    return out
-  }
-
-  private static func md5(_ parts: [[UInt8]]) -> [UInt8] {
-    // Insertion-sort-simple MD5, written out rather than taken from CommonCrypto:
-    // `CC_MD5` is deprecated with an availability warning that fails a
-    // warnings-as-errors build, and CryptoKit's `Insecure.MD5` is available but
-    // pulls a framework into a test target that otherwise needs none.
-    var message = [UInt8]()
-    for part in parts { message += part }
-    return MD5.digest(message)
-  }
-
-  /**
-   A 200x200 red page encrypted with the standard security handler, R=2, V=1,
-   RC4-40, user password `userPassword` and owner password `ownerPassword`.
-
-   Hand-written because nothing in CoreGraphics or PDFKit writes an encrypted PDF.
-   Without it, "password-protected produces a distinguishable error" is an
-   assertion about code that has never met an encrypted file — and on iOS it is
-   also the only way to test the `password-incorrect` branch, which Android cannot
-   reach at all (`PdfRendererPool` refuses any password with `unsupported`,
-   because `LoadParams` landed at API 35).
-   */
-  static func encrypted() -> Data {
-    let contentString = "1 0 0 rg 0 0 200 200 re f\n"
-    let content = Array(contentString.data(using: .isoLatin1)!)
-
-    // A fixed file ID, so the fixture is byte-stable across runs.
-    let fileId: [UInt8] = [
-      0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    ]
-    // -1 as a 32-bit little-endian signed int: every permission granted.
-    let permissions: Int32 = -1
-    let pBytes: [UInt8] = [
-      UInt8(truncatingIfNeeded: permissions),
-      UInt8(truncatingIfNeeded: permissions >> 8),
-      UInt8(truncatingIfNeeded: permissions >> 16),
-      UInt8(truncatingIfNeeded: permissions >> 24),
-    ]
-
-    // Algorithm 3: /O is the padded USER password, RC4'd with the MD5 of the
-    // padded OWNER password.
-    //
-    // THE OWNER PASSWORD MUST NOT BE EMPTY, and getting that wrong is how this
-    // fixture first shipped as a document that opens with no password at all.
-    // MEASURED: with `ownerPassword = ""`, CoreGraphics reported
-    // `isEncrypted = true` and `isUnlocked = true` before any password was
-    // supplied, and PDFKit reported `isLocked = false`. The reason is Algorithm 7,
-    // the OWNER authentication path every reader tries after the user one: it
-    // decrypts /O with MD5(padded(supplied)) and runs Algorithm 6 on the result.
-    // An empty owner password makes the empty string decrypt /O correctly, which
-    // recovers the real user password, which authenticates. The spec's own
-    // instruction — "if there is no owner password, use the user password
-    // instead" — exists precisely to close that hole. `"owner"` here matches the
-    // Android fixture exactly, so the two platforms are tested against the same
-    // bytes.
-    let ownerKey = Array(md5([padded(ownerPassword)])[0..<5])
-    let o = rc4(key: ownerKey, data: padded(userPassword))
-
-    // Algorithm 2: the file encryption key.
-    let userPad = padded(userPassword)
-    let fileKey = Array(md5([userPad, o, pBytes, fileId])[0..<5])
-
-    // Algorithm 4 (R=2): /U is the pad string RC4'd with the file key.
-    let u = rc4(key: fileKey, data: pad)
-
-    // Each string and stream is encrypted with a key derived from the file key
-    // plus its own object and generation number (Algorithm 1).
-    func objectKey(_ number: Int) -> [UInt8] {
-      let extra: [UInt8] = [
-        UInt8(number & 0xFF), UInt8((number >> 8) & 0xFF),
-        UInt8((number >> 16) & 0xFF), 0, 0,
-      ]
-      let digest = md5([fileKey, extra])
-      return Array(digest[0..<min(fileKey.count + 5, 16)])
-    }
-
-    let w = Writer()
-    // Object 1 is the content stream, so its key uses 1.
-    let encryptedContent = rc4(key: objectKey(1), data: content)
-    var streamObject = Data("<< /Length \(encryptedContent.count) >>\nstream\n"
-      .data(using: .isoLatin1)!)
-    streamObject.append(contentsOf: encryptedContent)
-    streamObject.append("\nendstream".data(using: .isoLatin1)!)
-    let contents = w.add(streamObject)
-    let pageObj = w.add(
-      "<< /Type /Page /Parent 3 0 R /MediaBox [0 0 200 200] /Contents "
-        + "\(contents) 0 R /Resources << >> >>")
-    let pages = w.add("<< /Type /Pages /Kids [\(pageObj) 0 R] /Count 1 >>")
-    let catalog = w.add("<< /Type /Catalog /Pages \(pages) 0 R >>")
-    let encrypt = w.add(
-      "<< /Filter /Standard /V 1 /R 2 /O <\(hex(o))> /U <\(hex(u))> /P "
-        + "\(permissions) >>")
-    precondition(pages == 3, "Pages object is \(pages), not 3")
-    return w.finish(
-      rootObject: catalog,
-      extraTrailer: "/Encrypt \(encrypt) 0 R /ID [<\(hex(fileId))> <\(hex(fileId))>]")
-  }
-
-  private static func hex(_ bytes: [UInt8]) -> String {
-    bytes.map { String(format: "%02X", $0) }.joined()
-  }
-
-  // ---------------------------------------------------------------- //
-  // Files
-  // ---------------------------------------------------------------- //
-
-  /// Writes a fixture to a temporary file and returns its URL.
-  static func write(_ data: Data, name: String) throws -> URL {
-    let dir = URL(fileURLWithPath: NSTemporaryDirectory())
-      .appendingPathComponent("pdfcanvas-tests", isDirectory: true)
-    try FileManager.default.createDirectory(
-      at: dir, withIntermediateDirectories: true)
-    let url = dir.appendingPathComponent(name)
-    try data.write(to: url)
-    return url
-  }
-}
-
-/// MD5, 60 lines, because CommonCrypto's is deprecated and CryptoKit is a framework.
-enum MD5 {
-  private static let s: [UInt32] = [
-    7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
-    5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
-    4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
-    6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
-  ]
-
-  private static let k: [UInt32] = (0..<64).map {
-    UInt32(truncatingIfNeeded: Int64(abs(sin(Double($0 + 1))) * 4294967296.0))
-  }
-
-  static func digest(_ message: [UInt8]) -> [UInt8] {
-    var msg = message
-    let bitLength = UInt64(message.count) * 8
-    msg.append(0x80)
-    while msg.count % 64 != 56 { msg.append(0) }
-    for i in 0..<8 { msg.append(UInt8(truncatingIfNeeded: bitLength >> (8 * UInt64(i)))) }
-
-    var a0: UInt32 = 0x6745_2301
-    var b0: UInt32 = 0xefcd_ab89
-    var c0: UInt32 = 0x98ba_dcfe
-    var d0: UInt32 = 0x1032_5476
-
-    for chunk in stride(from: 0, to: msg.count, by: 64) {
-      var m = [UInt32](repeating: 0, count: 16)
-      for i in 0..<16 {
-        let o = chunk + i * 4
-        m[i] =
-          UInt32(msg[o]) | (UInt32(msg[o + 1]) << 8) | (UInt32(msg[o + 2]) << 16)
-          | (UInt32(msg[o + 3]) << 24)
-      }
-      var a = a0
-      var b = b0
-      var c = c0
-      var d = d0
-      for i in 0..<64 {
-        var f: UInt32
-        var g: Int
-        switch i / 16 {
-        case 0:
-          f = (b & c) | (~b & d)
-          g = i
-        case 1:
-          f = (d & b) | (~d & c)
-          g = (5 * i + 1) % 16
-        case 2:
-          f = b ^ c ^ d
-          g = (3 * i + 5) % 16
-        default:
-          f = c ^ (b | ~d)
-          g = (7 * i) % 16
-        }
-        f = f &+ a &+ k[i] &+ m[g]
-        a = d
-        d = c
-        c = b
-        b = b &+ ((f << s[i]) | (f >> (32 - s[i])))
-      }
-      a0 = a0 &+ a
-      b0 = b0 &+ b
-      c0 = c0 &+ c
-      d0 = d0 &+ d
-    }
-
-    var out = [UInt8]()
-    for word in [a0, b0, c0, d0] {
-      for i in 0..<4 { out.append(UInt8(truncatingIfNeeded: word >> (8 * UInt32(i)))) }
-    }
-    return out
-  }
-}