imsg-grep 0.1.2-darwin

data/ext/img2png.swift

@@ -0,0 +1,325 @@
+// Image to PNG conversion - both CLI and library versions
+// Applies rotation metadata to actual pixels, strips orientation from output.
+// Optional: resample to fit dimensions, place in centered box with black background.
+//
+// CLI Usage: ./img2png < input.jpg > output.png
+//        ./img2png --fit 800x600 < input.jpg > output.png
+//        ./img2png --fit 800x600 --box 1024x768 < input.jpg > output.png
+//        ./img2png --info < input.jpg   # prints WxH to stdout
+//
+// Build CLI:    swiftc -O -whole-module-optimization -lto=llvm-full -o bin/img2png ext/img2png.swift
+// Build dylib:  swiftc -O -whole-module-optimization -lto=llvm-full -emit-library -D LIBRARY -o lib/imsg-grep/images/img2png.dylib ext/img2png.swift
+
+import Foundation
+import ImageIO
+import UniformTypeIdentifiers
+
+let VERSION = "1.0.0"
+
+// Shared image processing functions
+
+func loadImage(from data: Data) -> (CGImage, Int, Int)? {
+    guard let imageSource = CGImageSourceCreateWithData(data as CFData, nil),
+          let image = CGImageSourceCreateImageAtIndex(imageSource, 0, nil) else {
+        return nil
+    }
+
+    let orientation = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil)
+        .flatMap { $0 as? [String: Any] }
+        .flatMap { $0[kCGImagePropertyOrientation as String] as? UInt32 }
+        .flatMap { CGImagePropertyOrientation(rawValue: $0) } ?? .up
+
+    let rotatedWidth  = orientation.rawValue > 4 ? image.height : image.width
+    let rotatedHeight = orientation.rawValue > 4 ? image.width : image.height
+
+    guard let rotateContext = CGContext(data: nil, width: rotatedWidth, height: rotatedHeight,
+                                        bitsPerComponent: 8, bytesPerRow: 0,
+                                        space: CGColorSpaceCreateDeviceRGB(),
+                                        bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
+        return nil
+    }
+
+    rotateContext.interpolationQuality = .high
+
+    let w = CGFloat(rotatedWidth)
+    let h = CGFloat(rotatedHeight)
+
+    let transforms: [CGImagePropertyOrientation: (CGFloat, CGFloat, CGFloat, CGFloat, CGFloat)] = [
+        .down:          (w, h,  1,  1,  .pi),
+        .downMirrored:  (w, h, -1,  1,  .pi),
+        .left:          (w, 0,  1,  1,  .pi / 2),
+        .leftMirrored:  (w, 0, -1,  1,  .pi / 2),
+        .right:         (0, h,  1,  1, -.pi / 2),
+        .rightMirrored: (0, h, -1,  1, -.pi / 2),
+        .upMirrored:    (w, 0, -1,  1,  0),
+    ]
+    let (tx, ty, sx, sy, rot) = transforms[orientation] ?? (0, 0, 1, 1, 0)
+
+    if tx != 0 || ty != 0 { rotateContext.translateBy(x: tx, y: ty) }
+    if sx != 1 || sy != 1 { rotateContext.scaleBy(x: sx, y: sy) }
+    if rot != 0           { rotateContext.rotate(by: rot) }
+
+    rotateContext.draw(image, in: CGRect(x: 0, y: 0, width: image.width, height: image.height))
+
+    guard let rotatedImage = rotateContext.makeImage() else {
+        return nil
+    }
+
+    return (rotatedImage, rotatedWidth, rotatedHeight)
+}
+
+func emitPNG(image: CGImage, fitW: Int = 0, fitH: Int = 0, boxW: Int = 0, boxH: Int = 0) -> Data? {
+    var finalImage  = image
+    var finalWidth  = image.width
+    var finalHeight = image.height
+
+    // Fit if requested
+    if fitW > 0 && fitH > 0 {
+        let scale = min(Double(fitW) / Double(image.width), Double(fitH) / Double(image.height))
+        let scaledW = Int(Double(image.width) * scale)
+        let scaledH = Int(Double(image.height) * scale)
+
+        guard let fitContext = CGContext(data: nil, width: scaledW, height: scaledH,
+                                         bitsPerComponent: 8, bytesPerRow: 0,
+                                         space: CGColorSpaceCreateDeviceRGB(),
+                                         bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
+            return nil
+        }
+
+        fitContext.interpolationQuality = .high
+        fitContext.draw(image, in: CGRect(x: 0, y: 0, width: scaledW, height: scaledH))
+
+        guard let fittedImage = fitContext.makeImage() else {
+            return nil
+        }
+
+        finalImage  = fittedImage
+        finalWidth  = scaledW
+        finalHeight = scaledH
+    }
+
+    // Box if requested
+    if boxW > 0 && boxH > 0 {
+        guard let boxContext = CGContext(data: nil, width: boxW, height: boxH,
+                                         bitsPerComponent: 8, bytesPerRow: 0,
+                                         space: CGColorSpaceCreateDeviceRGB(),
+                                         bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
+            return nil
+        }
+
+        boxContext.setFillColor(CGColor(red: 0, green: 0, blue: 0, alpha: 1))
+        boxContext.fill(CGRect(x: 0, y: 0, width: boxW, height: boxH))
+
+        let x = (boxW - finalWidth) / 2
+        let y = (boxH - finalHeight) / 2
+        boxContext.draw(finalImage, in: CGRect(x: x, y: y, width: finalWidth, height: finalHeight))
+
+        guard let boxedImage = boxContext.makeImage() else {
+            return nil
+        }
+
+        finalImage = boxedImage
+    }
+
+    let outputData = NSMutableData()
+    guard let destination = CGImageDestinationCreateWithData(outputData, UTType.png.identifier as CFString, 1, nil) else {
+        return nil
+    }
+
+    let options: [CFString: Any] = [kCGImagePropertyPNGCompressionFilter: 9]
+    CGImageDestinationAddImage(destination, finalImage, options as CFDictionary)
+
+    guard CGImageDestinationFinalize(destination) else {
+        return nil
+    }
+
+    return outputData as Data
+}
+
+// MARK: - Library API
+
+// Opaque image handle
+public class ImageHandle {
+    let image: CGImage
+    let width: Int
+    let height: Int
+
+    init(image: CGImage, width: Int, height: Int) {
+        self.image  = image
+        self.width  = width
+        self.height = height
+    }
+}
+
+// Load image from file path, apply rotation. Returns opaque handle or null on error.
+@_cdecl("img2png_load_path")
+public func img2png_load_path(path: UnsafePointer<CChar>,
+                              outW: UnsafeMutablePointer<Int>,
+                              outH: UnsafeMutablePointer<Int>) -> UnsafeMutableRawPointer? {
+    let pathStr = String(cString: path)
+    let url = URL(fileURLWithPath: pathStr)
+
+    guard let data = try? Data(contentsOf: url) else {
+        return nil
+    }
+
+    return img2png_load(inputData: data.withUnsafeBytes { $0.bindMemory(to: UInt8.self).baseAddress! },
+                        inputLen: data.count, outW: outW, outH: outH)
+}
+
+// Load image from data, apply rotation. Returns opaque handle or null on error.
+@_cdecl("img2png_load")
+public func img2png_load(inputData: UnsafePointer<UInt8>, inputLen: Int,
+                         outW: UnsafeMutablePointer<Int>,
+                         outH: UnsafeMutablePointer<Int>) -> UnsafeMutableRawPointer? {
+    let data = Data(bytes: inputData, count: inputLen)
+
+    guard let (rotatedImage, rotatedWidth, rotatedHeight) = loadImage(from: data) else {
+        return nil
+    }
+
+    let handle = ImageHandle(image: rotatedImage, width: rotatedWidth, height: rotatedHeight)
+    outW.pointee = rotatedWidth
+    outH.pointee = rotatedHeight
+    return Unmanaged.passRetained(handle).toOpaque()
+}
+
+// Convert to PNG with optional fitting and boxing.
+// fitW, fitH: scale to fit within these dimensions (0 = skip)
+// boxW, boxH: place in centered box with black background (0 = skip)
+// Returns PNG data and length via out parameters. Caller must free data.
+@_cdecl("img2png_convert")
+public func img2png_convert(
+    handle: UnsafeMutableRawPointer,
+    fitW: Int, fitH: Int,
+    boxW: Int, boxH: Int,
+    outData: UnsafeMutablePointer<UnsafeMutablePointer<UInt8>?>,
+    outLen: UnsafeMutablePointer<Int>
+) -> Bool {
+    let img = Unmanaged<ImageHandle>.fromOpaque(handle).takeUnretainedValue()
+
+    guard let pngData = emitPNG(image: img.image, fitW: fitW, fitH: fitH, boxW: boxW, boxH: boxH) else {
+        return false
+    }
+
+    let bytes = malloc(pngData.count)!
+    _ = pngData.withUnsafeBytes { memcpy(bytes, $0.baseAddress!, pngData.count) }
+
+    outData.pointee = bytes.assumingMemoryBound(to: UInt8.self)
+    outLen.pointee  = pngData.count
+
+    return true
+}
+
+// Release image handle
+@_cdecl("img2png_release")
+public func img2png_release(handle: UnsafeMutableRawPointer) {
+    Unmanaged<ImageHandle>.fromOpaque(handle).release()
+}
+
+// Free memory allocated by library
+@_cdecl("img2png_free")
+public func img2png_free(ptr: UnsafeMutableRawPointer?) {
+    free(ptr)
+}
+
+// MARK: - CLI Main
+
+func parseDimensions(_ str: String) -> (Int, Int)? {
+    let parts = str.split(separator: "x")
+    guard parts.count == 2,
+          let w = Int(parts[0]),
+          let h = Int(parts[1]) else { return nil }
+    return (w, h)
+}
+
+#if !LIBRARY
+@main
+struct CLI {
+    static func main() {
+    // Parse arguments
+    var fit: (Int, Int)?
+    var box: (Int, Int)?
+    var infoMode = false
+    var i = 1
+
+    while i < CommandLine.arguments.count {
+        switch CommandLine.arguments[i] {
+        case "--version":
+            print(VERSION)
+            exit(0)
+        case "--fit":
+            guard i + 1 < CommandLine.arguments.count,
+                  let dims = parseDimensions(CommandLine.arguments[i + 1]) else {
+                fputs("Invalid --fit WxH\n", stderr)
+                exit(1)
+            }
+            fit = dims
+            i += 2
+        case "--box":
+            guard i + 1 < CommandLine.arguments.count,
+                  let dims = parseDimensions(CommandLine.arguments[i + 1]) else {
+                fputs("Invalid --box WxH\n", stderr)
+                exit(1)
+            }
+            box = dims
+            i += 2
+        case "--info":
+            infoMode = true
+            i += 1
+        default:
+            fputs("Unknown option: \(CommandLine.arguments[i])\n", stderr)
+            exit(1)
+        }
+    }
+
+    // Read entire stdin into memory
+    let inputData = FileHandle.standardInput.readDataToEndOfFile()
+
+    guard !inputData.isEmpty else {
+        if CommandLine.arguments.count == 1 {
+            print("Usage: img2png [OPTIONS] < input > output")
+            print("")
+            print("Options:")
+            print("  --fit WxH        Scale to fit within dimensions")
+            print("  --box WxH        Place in centered box with black background")
+            print("  --info           Print dimensions only")
+            print("  --version        Print version")
+            print("")
+            print("Examples:")
+            print("  img2png < input.jpg > output.png")
+            print("  img2png --fit 800x600 < input.jpg > output.png")
+            print("  img2png --fit 800x600 --box 1024x768 < input.jpg > output.png")
+            exit(0)
+        } else {
+            fputs("No input data\n", stderr)
+            exit(1)
+        }
+    }
+
+    guard let (rotatedImage, rotatedWidth, rotatedHeight) = loadImage(from: inputData) else {
+        fputs("Failed to load image\n", stderr)
+        exit(1)
+    }
+
+    // If info mode, print dimensions and exit
+    if infoMode {
+        print("\(rotatedWidth)x\(rotatedHeight)")
+        exit(0)
+    }
+
+    let fitW = fit?.0 ?? 0
+    let fitH = fit?.1 ?? 0
+    let boxW = box?.0 ?? 0
+    let boxH = box?.1 ?? 0
+
+    guard let pngData = emitPNG(image: rotatedImage, fitW: fitW, fitH: fitH, boxW: boxW, boxH: boxH) else {
+        fputs("Failed to convert to PNG\n", stderr)
+        exit(1)
+    }
+
+    // Write to stdout
+    FileHandle.standardOutput.write(pngData)
+    }
+}
+#endif

data/lib/imsg-grep/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/imsg-grep/apple/attr_str.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Extract NSString value from unkeyed-archived (typedstream) NSAttributedString
+
+class AttributedStringExtractor
+  def self.extract(data) = (new(data).extract if data)
+
+  TAG_INTEGER_2 = -127  # Indicates 2-byte integer follows
+  TAG_INTEGER_4 = -126  # Indicates 4-byte integer follows
+
+  def initialize(data)
+    return if data.nil?
+    # Find NSString position first and fail fast if not found
+    @nsstring_pos = data.index("NSString") or raise "NSString not found in data"
+    @data = data.b
+    @pos = 0
+
+    # Read and validate header
+    version = read.ord
+    sig_length = read.ord
+    raise "Only version 4 supported, got #{version}" unless version == 4
+    raise "Invalid signature length #{sig_length}" unless sig_length == 11
+
+    signature = read(sig_length)
+    case signature
+    when "streamtyped" then @int16_format, @int32_format = "v", "V"
+    when "typedstream" then @int16_format, @int32_format = "n", "N"
+    else raise "Invalid signature: #{signature.inspect}"
+    end
+  end
+
+  def extract
+    return if @data.nil?
+
+    # Jump to after NSString and look for '+' string marker
+    marker_pos = @data.index(?+, @nsstring_pos + 8)
+    return unless marker_pos
+
+    @pos = marker_pos + 1  # Skip '+' marker
+
+    length_byte = read.ord                                             # Read string length
+    length_byte = length_byte > 127 ? length_byte - 256 : length_byte  # Convert to signed byte for tag comparison
+
+    length = case length_byte
+    when TAG_INTEGER_2 then read(2).unpack1(@int16_format) # 2-byte length
+    when TAG_INTEGER_4 then read(4).unpack1(@int32_format) # 4-byte length
+    else length_byte                                       # Single byte length
+    end
+
+    return unless length && length > 0
+
+    read(length).force_encoding("UTF-8") # Extract and return string
+  end
+
+  private
+
+  def read(n = 1)
+    bytes = @data[@pos, n]
+    @pos += n
+    bytes
+  end
+end
+
+puts AttributedStringExtractor.extract(STDIN.read) if __FILE__ == $0 && STDIN.stat.size > 0

data/lib/imsg-grep/apple/bplist.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+# Binary property list (bplist) parser for decoding Apple's binary plist format
+
+require 'set'
+
+module BPList
+  APPLE_EPOCH = 978307200  # Apple's epoch offset from Unix epoch
+
+  # Read big-endian integer from data at position
+  def self.read_int(data, pos, size)
+    raise "Position #{pos} + #{size} beyond data size" if pos + size > data.bytesize
+    case size
+    when 1 then data[pos].unpack1("C")
+    when 2 then data[pos, 2].unpack1("n")
+    when 4 then data[pos, 4].unpack1("N")
+    when 8 then data[pos, 8].unpack1("Q>")
+    else
+      # Fallback for other sizes
+      bytes = data[pos, size].unpack("C*")
+      bytes.reduce(0) { |a, b|
+        raise "nil value in read_int: a=#{a.inspect}, b=#{b.inspect}" if a.nil? || b.nil?
+        (a << 8) | b
+      }
+    end
+  end
+
+  # Get count/length (handles 0xF continuation)
+  def self.get_count(data, pos, low)
+    return [low, pos + 1] if low != 0x0F
+
+    raise "Position #{pos + 1} beyond data size" if pos + 1 >= data.bytesize
+    int_marker = data[pos + 1].ord
+    int_high   = int_marker >> 4
+    raise "Invalid count marker" unless int_high == 0x1
+
+    byte_count = 1 << (int_marker & 0x0F)
+    count = read_int(data, pos + 2, byte_count)
+    [count, pos + 2 + byte_count]
+  end
+
+  def self.parse(data)
+    data = data.dup.force_encoding("BINARY")
+    raise "Invalid header" unless data.start_with?("bplist00")
+
+    # Parse trailer (last 32 bytes)
+    trailer_start     = data.bytesize - 32
+    offset_int_size   = data[trailer_start + 6].ord
+    objref_size       = data[trailer_start + 7].ord
+    num_objects       = data.unpack1("Q>", offset: trailer_start + 8)
+    root_object_index = data.unpack1("Q>", offset: trailer_start + 16)
+    offset_table_pos  = data.unpack1("Q>", offset: trailer_start + 24)
+
+    raise "Invalid trailer" if offset_int_size < 1 || objref_size < 1
+    raise "Invalid object count" if num_objects < 1 || root_object_index >= num_objects
+
+    # Read offset table
+    offsets = Array.new(num_objects) do |i|
+      pos = offset_table_pos + i * offset_int_size
+      read_int(data, pos, offset_int_size)
+    end
+
+    # Parse objects recursively
+    objects = Array.new(num_objects)
+    object_cache = {}
+
+    parse_object = lambda do |index|
+      raise "Invalid object ref: #{index}" if index >= num_objects
+      return objects[index] if objects[index]
+
+      # Check cache first
+      offset = offsets[index]
+      return object_cache[offset] if object_cache.has_key?(offset)
+
+      # Set placeholder to detect circular refs
+      objects[index] = :parsing
+
+      pos    = offsets[index]
+      raise "Position #{pos} beyond data size #{data.bytesize}" if pos >= data.bytesize
+      marker = data[pos].ord
+      high   = marker >> 4
+      low    = marker & 0x0F
+
+      result = case high
+      when 0x0  # Null, Bool, Fill
+        case marker
+        when 0x00 then nil
+        when 0x08 then false
+        when 0x09 then true
+        else raise "Unknown null type: 0x#{marker.to_s(16)}"
+        end
+
+      when 0x1  # Integer
+        byte_count = 1 << low
+        raise "Invalid int size" if byte_count > 16
+        raise "Position #{pos + 1} + #{byte_count} beyond data size" if pos + 1 + byte_count > data.bytesize
+
+        if byte_count == 16
+          # 128-bit integer - read as two 64-bit values (high, low)
+          high = data[pos + 1, 8].unpack1("Q>")
+          low = data[pos + 9, 8].unpack1("Q>")
+          # Convert to signed if high MSB is set
+          if high >= (1 << 63)
+            high = high - (1 << 64)
+          end
+          # Ruby handles big integers automatically
+          (high << 64) | low
+        else
+          value = read_int(data, pos + 1, byte_count)
+          # Per Apple spec: only 8+ byte integers are signed, 1/2/4 byte are unsigned
+          if byte_count >= 8 && value >= (1 << (byte_count * 8 - 1))
+            value - (1 << (byte_count * 8))
+          else
+            value
+          end
+        end
+
+      when 0x2  # Real
+        byte_count = 1 << low
+        raise "Position #{pos + 1} + #{byte_count} beyond data size" if pos + 1 + byte_count > data.bytesize
+        case byte_count
+        when 4 then data[pos + 1, 4].unpack1("g")
+        when 8 then data[pos + 1, 8].unpack1("G")
+        else raise "Invalid real size: #{byte_count}"
+        end
+
+      when 0x3  # Date
+        raise "Invalid date marker" unless marker == 0x33
+        raise "Position #{pos + 1} + 8 beyond data size" if pos + 1 + 8 > data.bytesize
+        seconds = data[pos + 1, 8].unpack1("G")
+        Time.at(APPLE_EPOCH + seconds)
+
+      when 0x4  # Data
+        count, start = get_count(data, pos, low)
+        raise "Position #{start} + #{count} beyond data size" if start + count > data.bytesize
+        data[start, count]
+
+      when 0x5  # ASCII string
+        count, start = get_count(data, pos, low)
+        raise "Position #{start} + #{count} beyond data size" if start + count > data.bytesize
+        ascii_data = data[start, count]
+        # Validate ASCII - check for non-ASCII bytes
+        ascii_data.force_encoding("US-ASCII")
+        if ascii_data.valid_encoding?
+          ascii_data.encode!("UTF-8")
+        else
+          # Invalid ASCII, keep as binary for later Base64 encoding
+          ascii_data.force_encoding("BINARY")
+        end
+
+      when 0x6  # UTF-16 string
+        count, start = get_count(data, pos, low)
+        raise "Position #{start} + #{count * 2} beyond data size" if start + count * 2 > data.bytesize
+        utf16_data = data[start, count * 2]
+        # Convert UTF-16BE to UTF-8
+        begin
+          utf16_data.force_encoding("UTF-16BE").encode!("UTF-8")
+        rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+          # Invalid UTF-16, keep as binary for later Base64 encoding
+          utf16_data.force_encoding("BINARY")
+        end
+
+      when 0x8  # UID
+        byte_count = low + 1
+        raise "Position #{pos + 1} + #{byte_count} beyond data size" if pos + 1 + byte_count > data.bytesize
+        { "CF$UID" => read_int(data, pos + 1, byte_count)}
+
+      when 0xA  # Array
+        count, start = get_count(data, pos, low)
+        raise "Position #{start} + #{count * objref_size} beyond data size" if start + count * objref_size > data.bytesize
+        Array.new(count) { |i| parse_object.call(read_int(data, start + i * objref_size, objref_size)) }
+
+      when 0xC  # Set
+        count, start = get_count(data, pos, low)
+        raise "Position #{start} + #{count * objref_size} beyond data size" if start + count * objref_size > data.bytesize
+        Set.new(Array.new(count) { |i| parse_object.call(read_int(data, start + i * objref_size, objref_size)) })
+
+      when 0xD  # Dict
+        count, start = get_count(data, pos, low)
+        raise "Position #{start} + #{count * objref_size * 2} beyond data size" if start + count * objref_size * 2 > data.bytesize
+        Array.new(count) { |i|
+          [ parse_object.call(read_int(data, start + i * objref_size, objref_size)),
+            parse_object.call(read_int(data, start + (count + i) * objref_size, objref_size))]
+        }.to_h
+
+      else
+        raise "Unknown marker: 0x#{marker.to_s(16)}"
+      end
+
+      objects[index] = result
+      # Cache the parsed object by its offset for reuse
+      object_cache[offset] = result
+    end
+
+    parse_object.call(root_object_index)
+  end
+
+end
+
+
+__END__
+
+Binary plist format specification (based on Apple CFBinaryPList.c):
+
+HEADER
+	magic number ("bplist")
+	file format version (currently "0?")
+
+OBJECT TABLE
+	variable-sized objects
+
+	Object Formats (marker byte followed by additional info in some cases)
+	null	0000 0000			// null object [v"1?"+ only]
+	bool	0000 1000			// false
+	bool	0000 1001			// true
+	url	0000 1100	string		// URL with no base URL, recursive encoding of URL string [v"1?"+ only]
+	url	0000 1101	base string	// URL with base URL, recursive encoding of base URL, then recursive encoding of URL string [v"1?"+ only]
+	uuid	0000 1110			// 16-byte UUID [v"1?"+ only]
+	fill	0000 1111			// fill byte
+	int	0001 0nnn	...		// # of bytes is 2^nnn, big-endian bytes
+	real	0010 0nnn	...		// # of bytes is 2^nnn, big-endian bytes
+	date	0011 0011	...		// 8 byte float follows, big-endian bytes
+	data	0100 nnnn	[int]	...	// nnnn is number of bytes unless 1111 then int count follows, followed by bytes
+	string	0101 nnnn	[int]	...	// ASCII string, nnnn is # of chars, else 1111 then int count, then bytes
+	string	0110 nnnn	[int]	...	// Unicode string, nnnn is # of chars, else 1111 then int count, then big-endian 2-byte uint16_t
+	string	0111 nnnn	[int]	...	// UTF8 string, nnnn is # of chars, else 1111 then int count, then bytes [v"1?"+ only]
+	uid	1000 nnnn	...		// nnnn+1 is # of bytes
+		1001 xxxx			// unused
+	array	1010 nnnn	[int]	objref*	// nnnn is count, unless '1111', then int count follows
+	ordset	1011 nnnn	[int]	objref* // nnnn is count, unless '1111', then int count follows [v"1?"+ only]
+	set	1100 nnnn	[int]	objref* // nnnn is count, unless '1111', then int count follows [v"1?"+ only]
+	dict	1101 nnnn	[int]	keyref* objref*	// nnnn is count, unless '1111', then int count follows
+		1110 xxxx			// unused
+		1111 xxxx			// unused
+
+OFFSET TABLE
+	list of ints, byte size of which is given in trailer
+	-- these are the byte offsets into the file
+	-- number of these is in the trailer
+
+TRAILER
+	byte size of offset ints in offset table
+	byte size of object refs in arrays and dicts
+	number of offsets in offset table (also is number of objects)
+	element # in offset table which is top level object
+	offset table offset
+
+**Integer Signedness (per Apple spec):**
+- 1, 2, 4-byte integers: Always unsigned
+- 8+ byte integers: Signed when MSB is set (two's complement)
+- 16-byte integers: 128-bit signed (high 64-bit + low 64-bit)
+
+**Encoding:**
+- Big-endian byte order throughout
+- Length in low nibble (0-14 direct, 0xF = follow-on integer)
+- Object references are indices into offset table
+- Strings: ASCII (0x5X), UTF-16BE (0x6X), UTF-8 (0x7X, v1+ only)