stationery 0.11.0 → 0.12.0

data/examples/shipping_label.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# A 4 × 6 in shipping label for a thermal label printer, in black and white
+# only, with a Code 128 and a QR code, written as a PDF and as ZPL whose
+# barcodes the printer draws itself (`native: true`). Run it to write
+# examples/shipping_label.pdf and examples/shipping_label.zpl:
+#
+#   ruby -Ilib examples/shipping_label.rb
+#   ruby -Ilib exe/stationery render examples/shipping_label.rb --zpl --dpi 203
+require "stationery"
+
+class ExampleShippingLabel < Stationery::Document
+  page size: "4in x 6in", margin: mm(4)
+  max_pages 1 # one label: what does not fit warns, and to_zpl writes no second label
+  monochrome dpi: 203
+  default_text size: 10
+  metadata title: "Shipping label", creator: "stationery example"
+
+  def self.preview
+    new(parcel: "SX 0042 7719 03", service: "EXPRESS", weight: "2.4 kg", route: "R-07",
+        from: ["Northwind Supplies", "Unit 5, Harbour Road", "40115 Gothenburg", "Sweden"],
+        to: ["Ada Example", "Example Workshop Ltd", "12 Sample Street", "3011 Testville", "Netherlands"])
+  end
+
+  def initialize(parcel:, service:, weight:, route:, from:, to:)
+    super()
+    @parcel = parcel
+    @service = service
+    @weight = weight
+    @route = route
+    @from = from
+    @to = to
+  end
+
+  def view_template
+    row(gap: 8) do
+      column(width: 0.62) { address("FROM", @from, size: 9) }
+      column { service }
+    end
+    spacer 8
+    rule height: 2
+    spacer 10
+    address("SHIP TO", @to, size: 14)
+    spacer 12
+    rule height: 2
+    spacer 10
+    row(gap: 8, align: :center) do
+      column(width: 0.36) { detail("ROUTE", @route) }
+      column(width: 0.36) { detail("WEIGHT", @weight) }
+      column { barcode "https://track.example/#{code}", type: :qr, module_size: 1.4, align: :right, native: true }
+    end
+    spacer 10
+    box(border: { width: 3 }, padding: 10) do
+      text "PARCEL", size: 8, weight: :bold
+      spacer 6
+      barcode code, module_size: 1.5, height: 44, align: :center, native: true
+      spacer 4
+      text @parcel, size: 14, weight: :bold, letter_spacing: 1, align: :center
+    end
+    spacer 10
+    text "Keep dry · This side up", size: 9, align: :center
+  end
+
+  private
+
+  def code = @parcel.delete(" ")
+
+  def address(label, lines, size:)
+    text label, size: 8, weight: :bold, letter_spacing: 0.6
+    spacer 3
+    text "<b>#{lines.first}</b>\n#{lines.drop(1).join("\n")}", size:, markup: true, leading: 1.5
+  end
+
+  def service
+    box(background: "#000000", padding: [10, 6]) do
+      text @service, size: 16, weight: :bold, color: "#FFFFFF", align: :center
+    end
+  end
+
+  def detail(label, value)
+    text label, size: 8, weight: :bold, letter_spacing: 0.6
+    spacer 2
+    text value, size: 20, weight: :bold
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  label = ExampleShippingLabel.preview
+  label.to_pdf(File.expand_path("shipping_label.pdf", __dir__))
+  label.to_zpl(File.expand_path("shipping_label.zpl", __dir__))
+  warn label.warnings.map(&:message) if label.warnings.any?
+  puts "wrote examples/shipping_label.pdf and examples/shipping_label.zpl"
+end

data/lib/stationery/barcode/code128.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Barcode
+    # Code 128 (ISO/IEC 15417) of printable ASCII (" " to "~"): code set B,
+    # switching to code set C (two digits a symbol) for a run of at least six
+    # digits, or four at either end. Bars and spaces are 1 to 4 modules wide;
+    # the symbol is 11 modules a character, 13 for the stop, with a quiet
+    # zone of 10 modules on either side.
+    class Code128
+      PATTERNS = %w[
+        212222 222122 222221 121223 121322 131222 122213 122312 132212 221213 221312 231212 112232 122132 122231
+        113222 123122 123221 223211 221132 221231 213212 223112 312131 311222 321122 321221 312212 322112 322211
+        212123 212321 232121 111323 131123 131321 112313 132113 132311 211313 231113 231311 112133 112331 132131
+        113123 113321 133121 313121 211331 231131 213113 213311 213131 311123 311321 331121 312113 312311 332111
+        314111 221411 431111 111224 111422 121124 121421 141122 141221 112214 112412 122114 122411 142112 142211
+        241211 221114 413111 241112 134111 111242 121142 121241 114212 124112 124211 411212 421112 421211 212141
+        214121 412121 111143 111341 131141 114113 114311 411113 411311 113141 114131 311141 411131 211412 211214
+        211232 2331112
+      ].freeze
+      START_B = 104
+      START_C = 105
+      CODE_B = 100
+      CODE_C = 99
+      STOP = 106
+      QUIET = 10
+      # How ZPL's ^BC (mode N) is told to start or change code set.
+      ZPL_SET = { START_B => ">:", START_C => ">;", CODE_B => ">6", CODE_C => ">5" }.freeze
+
+      attr_reader :data, :codes
+
+      def initialize(data)
+        @data = data.to_s
+        raise ArgumentError, "a Code 128 barcode needs data" if @data.empty?
+
+        bad = @data.each_char.find { |char| !char.ord.between?(32, 126) }
+        raise ArgumentError, "Code 128 takes printable ASCII (\" \" to \"~\"), not #{bad.inspect}" if bad
+
+        @parts = parts
+        @codes = checked(@parts.flat_map { |set, text| [set, *values(set, text)] })
+      end
+
+      def linear? = true
+      def native? = true
+      # Dots ZPL draws the symbol below its ^FO.
+      def zpl_top = 0
+      def quiet = QUIET
+
+      # Modules across, without the quiet zones.
+      def width = ((@codes.size - 1) * 11) + 13
+
+      # The bars, as [first module, modules wide].
+      def bars
+        x = 0
+        @codes.flat_map { |code| PATTERNS[code].chars.map(&:to_i) }.each_slice(2).filter_map do |bar, space|
+          [x, bar].tap { x += bar + space.to_i }
+        end
+      end
+
+      # The ^BC command drawing the same symbol: its code sets named, so the
+      # printer does not choose others.
+      def zpl(module_dots:, height_dots:)
+        text = @parts.map { |set, part| ZPL_SET.fetch(set) + part.gsub(">", "><") }.join
+        "^BY#{module_dots}^BCN,#{height_dots},N,N,N,N#{Barcode.field(text)}"
+      end
+
+      private
+
+      # The data as [set, text] runs, the first set being a start code.
+      def parts
+        runs = @data.scan(/\d+|\D+/)
+        pieces = runs.each_with_index.flat_map do |run, index|
+          edge = index.zero? || index == runs.size - 1
+          next [[CODE_B, run]] unless run.match?(/\A\d+\z/) && run.size >= (edge ? 4 : 6)
+
+          even = run.size.even? ? run : run[...-1]
+          [[CODE_C, even], *([[CODE_B, run[-1]]] if even.size < run.size)]
+        end
+        list = pieces.chunk_while { |a, b| a[0] == b[0] }.map { |group| [group[0][0], group.map(&:last).join] }
+        list[0][0] = list[0][0] == CODE_C ? START_C : START_B
+        list
+      end
+
+      def values(set, text)
+        return text.scan(/\d\d/).map(&:to_i) if [START_C, CODE_C].include?(set)
+
+        text.each_char.map { |char| char.ord - 32 }
+      end
+
+      def checked(codes)
+        sum = codes.each_with_index.sum { |code, index| code * [index, 1].max }
+        [*codes, sum % 103, STOP]
+      end
+    end
+  end
+end

data/lib/stationery/barcode/data_matrix.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Barcode
+    # A Data Matrix symbol (ISO/IEC 16022, ECC 200) of the data's bytes in
+    # ASCII encodation (a character a codeword, two digits in one, a byte
+    # above 127 after an upper shift), in the smallest of the 24 square
+    # sizes from 10 × 10 to 144 × 144 that holds it. The codewords are laid
+    # out by the placement of the standard's annex F, in data regions each
+    # framed by its finder (solid left and bottom) and clock track
+    # (alternating top and right). The quiet zone is 1 module.
+    class DataMatrix
+      # Symbol size => [data codewords, error correction codewords, data
+      # regions across, modules across a region, interleaved blocks].
+      SIZES = {
+        10 => [3, 5, 1, 8, 1], 12 => [5, 7, 1, 10, 1], 14 => [8, 10, 1, 12, 1], 16 => [12, 12, 1, 14, 1],
+        18 => [18, 14, 1, 16, 1], 20 => [22, 18, 1, 18, 1], 22 => [30, 20, 1, 20, 1], 24 => [36, 24, 1, 22, 1],
+        26 => [44, 28, 1, 24, 1], 32 => [62, 36, 2, 14, 1], 36 => [86, 42, 2, 16, 1], 40 => [114, 48, 2, 18, 1],
+        44 => [144, 56, 2, 20, 1], 48 => [174, 68, 2, 22, 1], 52 => [204, 84, 2, 24, 2], 64 => [280, 112, 4, 14, 2],
+        72 => [368, 144, 4, 16, 4], 80 => [456, 192, 4, 18, 4], 88 => [576, 224, 4, 20, 4],
+        96 => [696, 272, 4, 22, 4], 104 => [816, 336, 4, 24, 6], 120 => [1050, 408, 6, 18, 6],
+        132 => [1304, 496, 6, 20, 8], 144 => [1558, 620, 6, 22, 10]
+      }.freeze
+      PAD = 129
+      UPPER_SHIFT = 235
+      QUIET = 1
+      # The escape character ^BX is given: data holding it is left to the picture.
+      ZPL_ESCAPE = "_"
+
+      attr_reader :data, :size, :data_codewords, :codewords, :modules
+
+      # ASCII encodation of `data`'s bytes.
+      def self.codewords(data)
+        data.to_s.b.scan(/\d\d|./mn).flat_map do |chunk|
+          next [130 + chunk.to_i] if chunk.size == 2
+
+          byte = chunk.ord
+          byte < 128 ? [byte + 1] : [UPPER_SHIFT, byte - 127]
+        end
+      end
+
+      def initialize(data)
+        @data = data.to_s
+        raise ArgumentError, "a Data Matrix needs data" if @data.empty?
+
+        encoded = self.class.codewords(@data)
+        @size, (capacity, ecc, regions, region, blocks) = SIZES.find { |_, spec| encoded.size <= spec[0] }
+        raise ArgumentError, "#{encoded.size} codewords are more than a Data Matrix holds (1558)" unless @size
+
+        @data_codewords = padded(encoded, capacity)
+        @codewords = @data_codewords + check(@data_codewords, ecc, blocks)
+        @modules = frame(place(regions * region), region)
+      end
+
+      def linear? = false
+      def quiet = QUIET
+      def native? = !@data.include?(ZPL_ESCAPE)
+      def zpl_top = 0
+
+      # ^BX at this size, so the printer draws as many modules.
+      def zpl(module_dots:, height_dots: nil) # rubocop:disable Lint/UnusedMethodArgument
+        "^BXN,#{module_dots},200,#{@size},#{@size},6,#{ZPL_ESCAPE},1#{Barcode.field(@data)}"
+      end
+
+      private
+
+      # The first pad is 129, the others scrambled by their position (the
+      # 253-state algorithm, annex B.1.2).
+      def padded(encoded, capacity)
+        result = encoded.dup
+        result << PAD if result.size < capacity
+        while result.size < capacity
+          value = PAD + ((149 * (result.size + 1)) % 253) + 1
+          result << (value > 254 ? value - 254 : value)
+        end
+        result
+      end
+
+      # The error correction of each block (the data taken a codeword to a
+      # block in turn), interleaved the same way.
+      def check(data, ecc, blocks)
+        per_block = ecc / blocks
+        checks = Array.new(blocks) do |block|
+          ReedSolomon::DATA_MATRIX.remainder(data.select.with_index { |_, i| i % blocks == block }, per_block)
+        end
+        (0...per_block).flat_map { |i| checks.map { |block| block[i] } }
+      end
+
+      # The mapping matrix (the data regions without their frames) of
+      # `count` modules across, true for dark.
+      def place(count)
+        Placement.new(count, @codewords).grid
+      end
+
+      def frame(grid, region)
+        step = region + 2
+        Array.new(@size) do |y|
+          Array.new(@size) do |x|
+            ry, dy = y.divmod(step)
+            rx, dx = x.divmod(step)
+            if dx.zero? || dy == step - 1 then true
+            elsif dy.zero? then dx.even?
+            elsif dx == step - 1 then dy.odd?
+            else grid[(ry * region) + dy - 1][(rx * region) + dx - 1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/barcode/data_matrix_placement.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Barcode
+    class DataMatrix
+      # The ECC 200 placement of ISO/IEC 16022 annex F: codewords laid on a
+      # mapping matrix of `count` × `count` modules along diagonal strokes,
+      # eight modules each (the "utah" shape), with the four corner shapes
+      # where a stroke meets the edge, and the fixed pattern in the corner
+      # left over.
+      class Placement
+        UTAH = [[-2, -2], [-2, -1], [-1, -2], [-1, -1], [-1, 0], [0, -2], [0, -1], [0, 0]].freeze
+
+        attr_reader :grid
+
+        def initialize(count, codewords)
+          @rows = @cols = count
+          @codewords = codewords
+          @grid = Array.new(count) { Array.new(count) }
+          place
+          @grid.each { |row| row.map! { |cell| cell == true } }
+        end
+
+        private
+
+        def place
+          chr = 0
+          row = 4
+          col = 0
+          loop do
+            chr = corners(row, col, chr)
+            loop do
+              chr = utah(row, col, chr) if row < @rows && col >= 0 && @grid[row][col].nil?
+              row -= 2
+              col += 2
+              break unless row >= 0 && col < @cols
+            end
+            row += 1
+            col += 3
+            loop do
+              chr = utah(row, col, chr) if row >= 0 && col < @cols && @grid[row][col].nil?
+              row += 2
+              col -= 2
+              break unless row < @rows && col >= 0
+            end
+            row += 3
+            col += 1
+            break unless row < @rows || col < @cols
+          end
+          fill_corner
+        end
+
+        def corners(row, col, chr)
+          shape = col.zero? ? left_corner(row) : (corner4 if col == 2 && row == @rows + 4 && (@cols % 8).zero?)
+          return chr unless shape
+
+          shape.each_with_index { |(r, c), bit| put(r, c, chr, bit) }
+          chr + 1
+        end
+
+        def left_corner(row)
+          if row == @rows then corner1
+          elsif row == @rows - 2 && (@cols % 4).positive? then corner2
+          elsif row == @rows - 2 && @cols % 8 == 4 then corner3
+          end
+        end
+
+        def corner1
+          [[@rows - 1, 0], [@rows - 1, 1], [@rows - 1, 2], [0, @cols - 2], [0, @cols - 1], [1, @cols - 1],
+           [2, @cols - 1], [3, @cols - 1]]
+        end
+
+        def corner2
+          [[@rows - 3, 0], [@rows - 2, 0], [@rows - 1, 0], [0, @cols - 4], [0, @cols - 3], [0, @cols - 2],
+           [0, @cols - 1], [1, @cols - 1]]
+        end
+
+        def corner3
+          [[@rows - 3, 0], [@rows - 2, 0], [@rows - 1, 0], [0, @cols - 2], [0, @cols - 1], [1, @cols - 1],
+           [2, @cols - 1], [3, @cols - 1]]
+        end
+
+        def corner4
+          [[@rows - 1, 0], [@rows - 1, @cols - 1], [0, @cols - 3], [0, @cols - 2], [0, @cols - 1], [1, @cols - 3],
+           [1, @cols - 2], [1, @cols - 1]]
+        end
+
+        def utah(row, col, chr)
+          UTAH.each_with_index { |(dr, dc), bit| put(row + dr, col + dc, chr, bit) }
+          chr + 1
+        end
+
+        # Bit `bit` (0 the most significant) of codeword `chr` at (row, col),
+        # wrapped around the edges as the annex wraps them.
+        def put(row, col, chr, bit)
+          if row.negative?
+            row += @rows
+            col += 4 - ((@rows + 4) % 8)
+          end
+          if col.negative?
+            col += @cols
+            row += 4 - ((@cols + 4) % 8)
+          end
+          codeword = @codewords[chr] || 0
+          @grid[row][col] = codeword[7 - bit] == 1
+        end
+
+        # The bottom right corner, when no codeword reached it.
+        def fill_corner
+          return unless @grid[@rows - 1][@cols - 1].nil?
+
+          @grid[@rows - 1][@cols - 1] = @grid[@rows - 2][@cols - 2] = true
+          @grid[@rows - 1][@cols - 2] = @grid[@rows - 2][@cols - 1] = false
+        end
+      end
+    end
+  end
+end

data/lib/stationery/barcode/ean13.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Barcode
+    # EAN-13 (ISO/IEC 15420): twelve digits and the check digit, which is
+    # computed when twelve are given and checked when thirteen are. 95
+    # modules across between guard bars, with a quiet zone of 11 modules on
+    # the left and 7 on the right; the digits under it are not drawn (write
+    # them with `text` when they are wanted).
+    class EAN13
+      L = %w[0001101 0011001 0010011 0111101 0100011 0110001 0101111 0111011 0110111 0001011].freeze
+      R = L.map { |code| code.tr("01", "10") }.freeze
+      G = R.map(&:reverse).freeze
+      # Which of L and G the six digits on the left use, by the first digit.
+      PARITY = %w[LLLLLL LLGLGG LLGGLG LLGGGL LGLLGG LGGLLG LGGGLL LGLGLG LGLGGL LGGLGL].freeze
+      QUIET = 11
+
+      attr_reader :data
+
+      def self.check_digit(digits)
+        sum = digits.chars.each_with_index.sum { |digit, index| digit.to_i * (index.odd? ? 3 : 1) }
+        ((10 - (sum % 10)) % 10).to_s
+      end
+
+      def initialize(data)
+        digits = data.to_s
+        raise ArgumentError, "EAN-13 takes 12 or 13 digits, not #{data.inspect}" unless digits.match?(/\A\d{12,13}\z/)
+
+        check = self.class.check_digit(digits[0, 12])
+        if digits.size == 13 && digits[12] != check
+          raise ArgumentError, "the check digit of #{digits} is #{check}, not #{digits[12]}"
+        end
+
+        @data = digits[0, 12] + check
+      end
+
+      def linear? = true
+      def native? = true
+      # Dots ZPL draws the symbol below its ^FO.
+      def zpl_top = 0
+      def quiet = QUIET
+      def width = 95
+
+      def bars
+        pattern.chars.each_with_index.chunk_while { |a, b| a[0] == b[0] }.filter_map do |run|
+          [run[0][1], run.size] if run[0][0] == "1"
+        end
+      end
+
+      # ^BE, which adds the check digit itself.
+      def zpl(module_dots:, height_dots:)
+        "^BY#{module_dots}^BEN,#{height_dots},N,N#{Barcode.field(@data[0, 12])}"
+      end
+
+      private
+
+      def pattern
+        left = @data[1, 6].chars.each_with_index.map do |digit, index|
+          (PARITY[@data[0].to_i][index] == "L" ? L : G)[digit.to_i]
+        end
+        right = @data[7, 6].chars.map { |digit| R[digit.to_i] }
+        "101#{left.join}01010#{right.join}101"
+      end
+    end
+  end
+end

data/lib/stationery/barcode/qr.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Barcode
+    # A QR Code (ISO/IEC 18004, model 2) of the data's bytes (UTF-8 for a
+    # String, marked as UTF-8 with an ECI when it is not ASCII), in byte
+    # mode, at the smallest version (1 to 40) that holds it at the error
+    # correction `level:` (:l, :m, :q or :h: 7, 15, 25 or 30 % of the
+    # symbol may be lost). The modules are laid out by QR::Matrix, which
+    # also picks the mask; the quiet zone is 4 modules.
+    class QR
+      LEVELS = %i[l m q h].freeze
+      # Error correction codewords a block, and blocks, by level and version.
+      ECC_PER_BLOCK = {
+        l: [7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30,
+            30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+        m: [10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28,
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+        q: [13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28,
+            30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+        h: [17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30,
+            30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]
+      }.freeze
+      BLOCKS = {
+        l: [1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18,
+            19, 19, 20, 21, 22, 24, 25],
+        m: [1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29,
+            31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+        q: [1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38,
+            40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+        h: [1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45,
+            48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81]
+      }.freeze
+      QUIET = 4
+      PADS = [0xEC, 0x11].freeze
+      # An ECI segment naming UTF-8 (assignment 26), before text that is not ASCII.
+      ECI_UTF8 = "011100011010"
+
+      attr_reader :data, :level, :version, :matrix
+
+      # The data codewords of `version` at `level`.
+      def self.capacity(version, level)
+        (Matrix.raw_modules(version) / 8) - (ECC_PER_BLOCK.fetch(level)[version - 1] * BLOCKS.fetch(level)[version - 1])
+      end
+
+      # The bytes byte mode holds at `version` and `level`: 4 bits of mode
+      # and 8 or 16 of length come first, and 12 of ECI with `eci:`.
+      def self.bytes(version, level, eci: false)
+        ((capacity(version, level) * 8) - 4 - (version < 10 ? 8 : 16) - (eci ? 12 : 0)) / 8
+      end
+
+      def initialize(data, level: :m)
+        raise ArgumentError, "a QR code's level: is :l, :m, :q or :h, not #{level.inspect}" unless
+          LEVELS.include?(level)
+
+        @data = data.to_s
+        @level = level
+        bytes = @data.b
+        raise ArgumentError, "a QR code needs data" if bytes.empty?
+
+        @eci = !bytes.ascii_only? && @data.encoding == Encoding::UTF_8
+        @version = (1..40).find { |version| bytes.bytesize <= self.class.bytes(version, level, eci: @eci) } or
+          raise ArgumentError, "#{bytes.bytesize} bytes are more than a QR code holds at level #{level.inspect}"
+        @matrix = Matrix.new(@version, level, codewords(bytes))
+      end
+
+      def linear? = false
+      # Whether a printer's ^BQ draws the same data: not UTF-8 text, which
+      # this symbol marks with an ECI (26) that ^BQ has no field for.
+      def native? = !@eci
+      # Dots ^BQ draws the symbol below its ^FO (as Labelary renders it,
+      # at any magnification and resolution).
+      def zpl_top = 10
+      def quiet = QUIET
+      def size = @matrix.size
+
+      # The dark modules, row by row, true for dark.
+      def modules = @matrix.modules
+
+      # ^BQ in manual byte mode, so the printer encodes the bytes as they
+      # are, at this level and so this version (its mask may differ).
+      def zpl(module_dots:, height_dots: nil) # rubocop:disable Lint/UnusedMethodArgument
+        bytes = @data.b
+        "^BQN,2,#{module_dots}#{Barcode.field("#{@level.upcase}M,B#{format("%04d", bytes.bytesize)}#{bytes}")}"
+      end
+
+      private
+
+      def codewords(bytes)
+        bits = [(@eci ? ECI_UTF8 : ""), "0100", bytes.bytesize.to_s(2).rjust(@version < 10 ? 8 : 16, "0"),
+                bytes.unpack1("B*")].join
+        capacity = self.class.capacity(@version, @level)
+        bits << ("0" * [4, (capacity * 8) - bits.size].min)
+        bits << ("0" * (-bits.size % 8))
+        data = [bits].pack("B*").bytes
+        data << PADS[(data.size - (bits.size / 8)) % 2] while data.size < capacity
+        interleave(data)
+      end
+
+      # The data split into blocks, each followed by its error correction,
+      # read a codeword from each block in turn.
+      def interleave(data)
+        count = BLOCKS.fetch(@level)[@version - 1]
+        ecc = ECC_PER_BLOCK.fetch(@level)[@version - 1]
+        raw = Matrix.raw_modules(@version) / 8
+        short = count - (raw % count)
+        short_length = (raw / count) - ecc
+        offset = 0
+        blocks = Array.new(count) do |index|
+          length = short_length + (index < short ? 0 : 1)
+          block = data[offset, length]
+          offset += length
+          [block, ReedSolomon::QR.remainder(block, ecc)]
+        end
+        (0..short_length).flat_map { |i| blocks.filter_map { |block, _| block[i] } } +
+          (0...ecc).flat_map { |i| blocks.map { |_, check| check[i] } }
+      end
+    end
+  end
+end