sevgi-graphics 0.93.1 → 0.95.0

data/lib/sevgi/graphics/auxiliary/content.rb

@@ -2,16 +2,101 @@
 
 module Sevgi
   module Graphics
-    # Renderable text-like content inside an SVG element.
+    # Renderable text-like content inside an SVG element. Content owns an immutable deep snapshot: strings and containers
+    # are copied, mutable leaf objects are stringified once during construction, and {#content} returns caller-owned
+    # copies. Later mutations cannot change rendering or invalidate the construction-time XML checks.
     class Content
-      # @!attribute [r] content
-      #   @return [Object] wrapped content
-      attr_reader :content
+      # Immutable payload capture and caller-owned copy helpers.
+      # @api private
+      module Snapshot
+        SCALARS = [::NilClass, ::TrueClass, ::FalseClass, ::Symbol, ::Integer, ::Float, ::Rational, ::Complex].freeze
+        private_constant :SCALARS
 
-      # Creates content.
+        class << self
+          def capture(value, seen = {}.compare_by_identity)
+            case value
+            when ::String
+              XML.text(value).freeze
+            when ::Hash
+              nested(value, seen) { capture_hash(value, seen) }.freeze
+            when ::Array
+              nested(value, seen) { value.map { capture(it, seen) } }.freeze
+            else
+              SCALARS.include?(value.class) ? value : stringify(value).freeze
+            end
+          end
+
+          def copy(value)
+            case value
+            when ::String
+              value.dup
+            when ::Hash
+              value.to_h { |key, item| [copy(key), copy(item)] }
+            when ::Array
+              value.map { copy(it) }
+            else
+              value
+            end
+          end
+
+          private
+
+          def capture_hash(value, seen)
+            value.each_with_object({}) do |(key, item), captured|
+              key = capture(key, seen)
+              ArgumentError.("XML content keys collide after stringification") if captured.key?(key)
+
+              captured[key] = capture(item, seen)
+            end
+          end
+
+          def nested(value, seen)
+            ArgumentError.("Cyclic XML content is not supported") if seen.key?(value)
+
+            seen[value] = true
+            yield
+          ensure
+            seen.delete(value)
+          end
+
+          def stringify(value)
+            text = value.to_s
+            ArgumentError.("XML content stringification must return a String") unless text.is_a?(::String)
+
+            XML.text(text)
+          rescue Sevgi::ArgumentError
+            raise
+          rescue ::StandardError => e
+            ArgumentError.("XML content cannot be stringified: #{e.class}: #{e.message}")
+          end
+        end
+      end
+
+      private_constant :Snapshot
+
+      # Returns a recursively independent, caller-owned payload snapshot.
+      # @return [Object] wrapped content snapshot
+      def content = Snapshot.copy(@content)
+
+      # Creates immutable content from a deep payload snapshot. Strings and containers are copied recursively; mutable
+      # non-container objects are stringified once during construction. The caller's objects are never retained.
       # @param content [Object] wrapped content
       # @return [void]
-      def initialize(content) = @content = content
+      # @raise [Sevgi::ArgumentError] when content cannot be stringified, contains invalid encoding or illegal XML
+      #   characters, contains cycles, or has keys that collide after stringification
+      def initialize(content)
+        @content = Snapshot.capture(content)
+        XML.validate(@content)
+      end
+
+      # Copies content payload ownership for duplicated element trees.
+      # @param original [Sevgi::Graphics::Content] source content
+      # @return [void]
+      # @api private
+      def initialize_copy(original)
+        @content = Snapshot.capture(original.content)
+        super
+      end
 
       # Renders content with a renderer.
       # @abstract Subclasses implement content rendering.
@@ -23,30 +108,45 @@ module Sevgi
 
       # Returns content as a string.
       # @return [String]
-      def to_s = content.to_s
+      def to_s = XML.text(payload)
+
+      def payload = @content
+
+      private :payload
 
       # @overload cdata(content)
       #   Builds CDATA content.
+      #   Mutable objects are stringified during construction, and embedded CDATA terminators are split safely.
       #   @param content [Object] wrapped content
       #   @return [Sevgi::Graphics::Content::CData]
+      #   @raise [Sevgi::ArgumentError] when content cannot be stringified, contains invalid encoding or illegal XML 1.0
+      #     characters, contains cycles, or has keys that collide after stringification
       def self.cdata(...) = CData.new(...)
 
       # Wraps content arguments, encoding non-content values.
+      # Mutable non-content values are stringified by encoded content during construction, before XML text escaping.
       # @param args [Array<Object>] content arguments
       # @return [Array<Sevgi::Graphics::Content>]
+      # @raise [Sevgi::ArgumentError] when an argument cannot be stringified, contains invalid encoding or illegal XML
+      #   1.0 characters, contains cycles, or has keys that collide after stringification
       def self.contents(*args) = args.map { it.is_a?(Content) ? it : encoded(it) }
 
       # @overload css(content)
       #   Builds CSS content.
       #   @param content [Hash] CSS rules
       #   @return [Sevgi::Graphics::Content::CSS]
-      #   @raise [Sevgi::ArgumentError] when content is not a hash
+      #   @raise [Sevgi::ArgumentError] when content is not a hash, contains a malformed style, cannot be stringified,
+      #     contains invalid encoding or illegal XML 1.0 characters, contains cycles, or has keys that collide after
+      #     stringification
       def self.css(...) = CSS.new(...)
 
       # @overload encoded(content)
       #   Builds XML text-encoded content.
+      #   Mutable objects are stringified during construction before XML text escaping.
       #   @param content [Object] wrapped content
       #   @return [Sevgi::Graphics::Content::Encoded]
+      #   @raise [Sevgi::ArgumentError] when content cannot be stringified, contains invalid encoding or illegal XML 1.0
+      #     characters, contains cycles, or has keys that collide after stringification
       def self.encoded(...) = Encoded.new(...)
 
       # Joins content lines with newlines.
@@ -56,13 +156,19 @@ module Sevgi
 
       # @overload verbatim(content)
       #   Builds verbatim content.
+      #   Mutable objects are stringified during construction.
       #   @param content [Object] wrapped content
       #   @return [Sevgi::Graphics::Content::Verbatim]
+      #   @raise [Sevgi::ArgumentError] when content cannot be stringified, contains invalid encoding or illegal XML 1.0
+      #     characters, contains cycles, or has keys that collide after stringification
       def self.verbatim(...) = Verbatim.new(...)
 
-      # CDATA section content.
+      # CDATA section content backed by an immutable payload snapshot. Mutable leaf objects are stringified during
+      # construction; embedded terminators are split during rendering.
+      # @see Content.cdata
       class CData < Content
         # Renders CDATA content.
+        # Embedded `]]>` terminators are split across adjacent CDATA sections so the output remains valid XML.
         # @param renderer [Object] renderer receiving output
         # @param depth [Integer] current render depth
         # @return [void]
@@ -70,19 +176,28 @@ module Sevgi
           depth += 1
 
           renderer.append(depth, "<![CDATA[")
-          renderer.append(depth + 1, *Array(content))
+          renderer.append(depth + 1, *Array(payload).map { safe(it) })
           renderer.append(depth, "]]>")
         end
+
+        private
+
+        def safe(value) = XML.cdata(value)
       end
 
-      # CSS content rendered inside a CDATA section.
+      # CSS content rendered inside a CDATA section. Rules are captured recursively during construction; mutable
+      # selectors, property names, and values are stringified once, and embedded CDATA terminators are split safely.
+      # @see Content.css
       class CSS < Content
         # Creates CSS content.
         # @param content [Hash] CSS rules
         # @return [void]
-        # @raise [Sevgi::ArgumentError] when content is not a hash
+        # @raise [Sevgi::ArgumentError] when content is not a hash, contains a malformed style, cannot be stringified,
+        #   contains invalid encoding or illegal XML 1.0 characters, contains cycles, or has keys that collide after
+        #   stringification
         def initialize(content)
-          ArgumentError.("CSS content must be a hash: #{content}") unless content.is_a?(::Hash)
+          ArgumentError.("CSS content must be a hash") unless content.is_a?(::Hash)
+          validate_styles(content)
 
           super
         end
@@ -92,21 +207,20 @@ module Sevgi
         # @param renderer [Object] renderer receiving output
         # @param depth [Integer] current render depth
         # @return [void]
-        # @raise [Sevgi::ArgumentError] when a style value cannot be rendered
         def render(renderer, depth)
           depth += 1
 
           renderer.append(depth, "<![CDATA[")
 
           depth += 1
-          content.each do |rule, styles|
+          payload.each do |rule, styles|
             case styles
             when ::Hash
-              renderer.append(depth, "#{rule} {")
-              renderer.append(depth + 1, *styles.map { |key, value| "#{key}: #{value};" })
+              renderer.append(depth, safe("#{rule} {"))
+              renderer.append(depth + 1, *styles.map { |key, value| safe("#{key}: #{value};") })
               renderer.append(depth, "}")
             when ::String, ::Symbol, ::Numeric
-              renderer.append(depth, "#{rule}: #{styles};")
+              renderer.append(depth, safe("#{rule}: #{styles};"))
             else
               ArgumentError.("Malformed style: #{styles}")
             end
@@ -117,13 +231,27 @@ module Sevgi
           renderer.append(depth, "]]>")
         end
         # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def safe(value) = XML.cdata(value)
+
+        def validate_styles(content)
+          content.each_value do |styles|
+            next if styles.is_a?(::Hash) || styles.is_a?(::String) || styles.is_a?(::Symbol) || styles.is_a?(::Numeric)
+
+            ArgumentError.("Malformed style type: #{styles.class}")
+          end
+        end
       end
 
-      # XML text-encoded content.
+      # XML text-encoded content backed by an immutable payload snapshot. Mutable leaf objects are stringified during
+      # construction, before XML escaping.
+      # @see Content.encoded
       class Encoded < Content
         # Returns XML text-encoded content.
         # @return [String]
-        def to_s = content.encode(xml: :text)
+        def to_s = XML.text(payload).encode(xml: :text)
 
         # Renders encoded text content.
         # @param renderer [Object] renderer receiving output
@@ -132,8 +260,15 @@ module Sevgi
         def render(renderer, depth) = renderer.append(depth + 1, to_s)
       end
 
-      # Verbatim content rendered without XML text encoding.
+      # Verbatim content backed by an immutable payload snapshot. Mutable leaf objects are stringified during
+      # construction. Verbatim content bypasses XML escaping; validation guarantees encoding and legal XML 1.0 code
+      # points, not well-formed markup supplied by the caller.
+      # @see Content.verbatim
       class Verbatim < Content
+        # Returns validated verbatim content.
+        # @return [String]
+        def to_s = XML.text(payload)
+
         # Renders verbatim content.
         # @param renderer [Object] renderer receiving output
         # @param depth [Integer] current render depth

data/lib/sevgi/graphics/auxiliary/margin.rb

@@ -15,12 +15,14 @@ module Sevgi
       # @!attribute [r] left
       #   @return [Float] left margin
 
-      # Creates a margin from one to four shorthand values.
+      # Creates a margin from one to four shorthand values. Values must be finite real numbers greater than or equal to
+      # zero.
       # @param top [Numeric, nil] top value or all-sides shorthand
       # @param right [Numeric, nil] right value or horizontal shorthand
       # @param bottom [Numeric, nil] bottom value
       # @param left [Numeric, nil] left value
       # @return [void]
+      # @raise [Sevgi::ArgumentError] when a supplied margin is not a finite, non-negative real number
       def initialize(top: nil, right: nil, bottom: nil, left: nil)
         super(**normalize(top, right, bottom, left))
       end
@@ -54,6 +56,9 @@ module Sevgi
       def vertical = top + bottom
 
       alias_method :==, :eql?
+
+      # Returns margin values in top, right, bottom, left order.
+      # @return [Array<Float>]
       alias_method :to_a, :deconstruct
 
       # Builds a margin from an array-like shorthand.
@@ -74,7 +79,14 @@ module Sevgi
       def normalize(top, right, bottom, left)
         values = [top, right, bottom, left]
 
-        Margin.members.zip(values_for(values.compact.size, values).map { Float(it) }).to_h
+        Margin
+          .members
+          .zip(
+            values_for(values.compact.size, values).map do |value|
+              Scalar.finite(value, context: "margin", field: :value, nonnegative: true)
+            end
+          )
+          .to_h
       end
 
       def values_for(size, values)

data/lib/sevgi/graphics/auxiliary/paper.rb

@@ -15,26 +15,30 @@ module Sevgi
       # @!attribute [r] name
       #   @return [Symbol] profile name
 
-      # Creates a paper profile.
+      # Creates a paper profile. Dimensions must be finite real numbers greater than zero.
       # @param width [Numeric] paper width
       # @param height [Numeric] paper height
       # @param unit [Symbol, String] SVG unit
       # @param name [Symbol, String] profile name
+      # @param options [Hash] unsupported extra options
       # @return [void]
-      # @raise [Sevgi::ArgumentError] when dimensions, unit, or profile name are invalid
-      def initialize(width:, height:, unit: "mm", name: :custom)
+      # @raise [Sevgi::ArgumentError] when dimensions, unit, name, or options are invalid
+      def initialize(width:, height:, unit: "mm", name: :custom, **options)
+        self.class.send(:options!, options)
         super(
           width: self.class.send(:dimension!, :width, width),
           height: self.class.send(:dimension!, :height, height),
-          unit: self.class.send(:symbol!, :unit, unit),
-          name: self.class.send(:symbol!, :name, name)
+          unit: self.class.send(:normalize!, :unit, unit),
+          name: self.class.send(:normalize!, :name, name)
         )
       end
 
       # Compares papers by width, height, unit, then name.
       # @param other [Sevgi::Graphics::Paper] paper to compare
-      # @return [Integer, nil]
-      def <=>(other) = deconstruct <=> other.deconstruct
+      # @return [Integer, nil] comparison result, or nil for a non-Paper operand
+      def <=>(other)
+        deconstruct <=> other.deconstruct if other.is_a?(self.class)
+      end
 
       # Reports strict paper equality.
       # @param other [Object] object to compare
@@ -56,108 +60,111 @@ module Sevgi
       alias_method :==, :eql?
 
       @profiles = {}
+      @accessors = {}
+      @mutex = ::Mutex.new
 
-      # Reports whether a named paper profile exists.
+      # Reports whether a normalizable named paper profile exists. Invalid converters return false.
       # @param name [Object] profile name
       # @return [Boolean]
-      def self.exist?(name) = name.respond_to?(:to_sym) && profiles.key?(name.to_sym)
+      def self.exist?(name)
+        name = normalize(name)
+        name ? @mutex.synchronize { @profiles.key?(name) } : false
+      end
 
-      # Defines or replaces a named paper profile.
+      # Defines a named paper profile after complete validation. Registration is process-global and thread-atomic.
+      # Existing profiles are replaced by default; with `overwrite: false`, identical definitions return the canonical
+      # profile and conflicting definitions raise. Names that are not Ruby call syntax remain accessible through
+      # `public_send`.
       # @param name [Symbol, String] profile name
+      # @param overwrite [Boolean] true to replace an existing profile
       # @param spec [Hash] paper dimensions and unit
       # @option spec [Numeric] :width paper width
       # @option spec [Numeric] :height paper height
       # @option spec [Symbol, String] :unit SVG unit
       # @return [Sevgi::Graphics::Paper]
-      # @raise [Sevgi::ArgumentError] when the profile name is reserved or invalid
-      def self.define(name, **spec)
-        name = symbol!(:name, name)
+      # @raise [Sevgi::ArgumentError] when the name, dimensions, unit, overwrite flag, or options are reserved or invalid,
+      #   or a non-bang definition conflicts with the registered profile
+      def self.define(name, overwrite: true, **spec)
+        name = normalize!(:name, name)
+        ArgumentError.("Paper name is reserved: #{name}") if reserved?(name)
+        overwrite = overwrite!(overwrite)
+        profile = new(name:, **spec)
+
+        register(name, profile, overwrite:)
+      end
 
-        ArgumentError.("Paper name is reserved: #{name}") if reserved?(name) && !exist?(name)
+      def self.install(name)
+        return if @accessors.key?(name)
 
-        singleton_class.remove_method(name) if singleton_class.method_defined?(name, false)
-        singleton_class.attr_reader(name)
-        profiles[name] = instance_variable_set("@#{name}", new(name:, **spec))
+        define_singleton_method(name) { @mutex.synchronize { @profiles.fetch(name) } }
+        @accessors[name] = true
       end
 
-      def self.reserved?(name) = @reserved.include?(name.to_sym)
+      def self.register(name, profile, overwrite:)
+        @mutex.synchronize do
+          if !overwrite && (current = @profiles[name])
+            ArgumentError.("Paper already defined differently: #{name}") unless current == profile
 
-      def self.profiles = @profiles
+            next current
+          end
+
+          install(name)
+          @profiles[name] = profile
+        end
+      end
+
+      def self.reserved?(name) = @reserved.include?(name)
 
       def self.dimension!(field, value)
-        Float(value)
-      rescue ::ArgumentError, ::TypeError
-        ArgumentError.("Invalid paper #{field}: #{value.inspect}")
+        Scalar.finite(value, context: "paper", field:, positive: true)
       end
 
-      def self.symbol!(field, value)
-        value.to_sym
-      rescue ::NoMethodError, ::TypeError
-        ArgumentError.("Invalid paper #{field}: #{value.inspect}")
+      def self.options!(options)
+        return if options.empty?
+
+        ArgumentError.("Unknown paper options: #{options.keys.join(", ")}")
+      end
+
+      def self.overwrite!(value)
+        return value if [true, false].include?(value)
+
+        ArgumentError.("Paper overwrite must be true or false")
+      end
+
+      def self.normalize(value)
+        normalized = value.to_sym if value.respond_to?(:to_sym)
+        normalized if normalized.is_a?(::Symbol)
+      rescue ::StandardError
+        nil
+      end
+
+      def self.normalize!(field, value)
+        normalize(value) || ArgumentError.("Invalid paper #{field}")
       end
 
       @reserved = methods.map(&:to_sym).freeze
 
-      private_class_method :dimension!, :profiles, :reserved?, :symbol!
-
-      {
-        a0: [841, 1189, "mm"],
-        a1: [594, 841, "mm"],
-        a2: [420, 594, "mm"],
-        a3: [297, 420, "mm"],
-        a4: [210, 297, "mm"],
-        a5: [148, 210, "mm"],
-        a6: [105, 148, "mm"],
-        a7: [74, 105, "mm"],
-        a8: [52, 74, "mm"],
-        a9: [37, 52, "mm"],
-        a10: [26, 37, "mm"],
-
-        b0: [1000, 1414, "mm"],
-        b1: [707, 1000, "mm"],
-        b2: [500, 707, "mm"],
-        b3: [353, 500, "mm"],
-        b4: [250, 353, "mm"],
-        b5: [176, 250, "mm"],
-        b6: [125, 176, "mm"],
-        b7: [88, 125, "mm"],
-        b8: [62, 88, "mm"],
-        b9: [44, 62, "mm"],
-        b10: [31, 44, "mm"],
-
-        c0: [917, 1297, "mm"],
-        c1: [648, 917, "mm"],
-        c2: [458, 648, "mm"],
-        c3: [324, 458, "mm"],
-        c4: [229, 324, "mm"],
-        c5: [162, 229, "mm"],
-        c6: [114, 162, "mm"],
-        c7: [81, 114, "mm"],
-        c8: [57, 81, "mm"],
-        c9: [40, 57, "mm"],
-        c10: [28, 40, "mm"],
-
-        business: [85, 55, "mm"],
-        large: [130, 210, "mm"],
-        passport: [88, 125, "mm"],
-        pocket: [90, 140, "mm"],
-        travelers: [110, 210, "mm"],
-        us: [216, 279, "mm"],
-        xlarge: [190, 250, "mm"],
-
-        icon16: [16, 16, "px"],
-        icon32: [32, 32, "px"],
-        icon64: [64, 64, "px"],
-        icon128: [128, 128, "px"],
-        icon256: [256, 256, "px"],
-        icon512: [512, 512, "px"]
-      }.each { |name, (width, height, unit)| define(name, width:, height:, unit:) }
-
-      class << self
-        alias_method :default, :a4
+      private_class_method(
+        :dimension!,
+        :install,
+        :normalize,
+        :normalize!,
+        :options!,
+        :overwrite!,
+        :register,
+        :reserved?
+      )
+
+      PAPER_SIZES.each { |name, (width, height, unit)| define(name, width:, height:, unit:) }
+
+      # Returns the default paper profile.
+      # @return [Sevgi::Graphics::Paper]
+      def self.default
+        @mutex.synchronize { @profiles.fetch(:default) }
       end
 
-      profiles[:default] = profiles.fetch(:a4)
+      @accessors[:default] = true
+      @profiles[:default] = @profiles.fetch(:a4)
     end
   end
 end

data/lib/sevgi/graphics/auxiliary/scalar.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    # Validates finite real numeric values used by graphics auxiliaries.
+    # @api private
+    module Scalar
+      # Converts one finite real value.
+      # @param value [Numeric] value to validate
+      # @param context [String] error context
+      # @param field [Symbol] field name
+      # @param positive [Boolean] require a strictly positive value
+      # @param nonnegative [Boolean] require a non-negative value
+      # @return [Float] validated value
+      # @raise [Sevgi::ArgumentError] when value is not a finite real number in the requested range
+      def self.finite(value, context:, field:, positive: false, nonnegative: false)
+        invalid(context, field, value) unless real?(value)
+
+        number = Float(value)
+        invalid(context, field, value) unless valid?(number, positive:, nonnegative:)
+
+        number
+      rescue ::ArgumentError, ::RangeError, ::TypeError
+        invalid(context, field, value)
+      end
+
+      def self.real?(value) = value.is_a?(::Numeric) && !value.is_a?(::Complex)
+
+      def self.valid?(number, positive:, nonnegative:)
+        number.finite? && (!positive || number.positive?) && (!nonnegative || number >= 0)
+      end
+
+      def self.invalid(context, field, value) = ArgumentError.("Invalid #{context} #{field}: #{value.inspect}")
+
+      private_class_method :invalid, :real?, :valid?
+    end
+
+    private_constant :Scalar
+  end
+end

data/lib/sevgi/graphics/auxiliary/sizes.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    # Built-in paper dimensions and units.
+    # @api private
+    PAPER_SIZES = {
+      a0: [841, 1189, "mm"],
+      a1: [594, 841, "mm"],
+      a2: [420, 594, "mm"],
+      a3: [297, 420, "mm"],
+      a4: [210, 297, "mm"],
+      a5: [148, 210, "mm"],
+      a6: [105, 148, "mm"],
+      a7: [74, 105, "mm"],
+      a8: [52, 74, "mm"],
+      a9: [37, 52, "mm"],
+      a10: [26, 37, "mm"],
+
+      b0: [1000, 1414, "mm"],
+      b1: [707, 1000, "mm"],
+      b2: [500, 707, "mm"],
+      b3: [353, 500, "mm"],
+      b4: [250, 353, "mm"],
+      b5: [176, 250, "mm"],
+      b6: [125, 176, "mm"],
+      b7: [88, 125, "mm"],
+      b8: [62, 88, "mm"],
+      b9: [44, 62, "mm"],
+      b10: [31, 44, "mm"],
+
+      c0: [917, 1297, "mm"],
+      c1: [648, 917, "mm"],
+      c2: [458, 648, "mm"],
+      c3: [324, 458, "mm"],
+      c4: [229, 324, "mm"],
+      c5: [162, 229, "mm"],
+      c6: [114, 162, "mm"],
+      c7: [81, 114, "mm"],
+      c8: [57, 81, "mm"],
+      c9: [40, 57, "mm"],
+      c10: [28, 40, "mm"],
+
+      business: [85, 55, "mm"],
+      large: [130, 210, "mm"],
+      passport: [88, 125, "mm"],
+      pocket: [90, 140, "mm"],
+      travelers: [110, 210, "mm"],
+      us: [216, 279, "mm"],
+      xlarge: [190, 250, "mm"],
+
+      icon16: [16, 16, "px"],
+      icon32: [32, 32, "px"],
+      icon64: [64, 64, "px"],
+      icon128: [128, 128, "px"],
+      icon256: [256, 256, "px"],
+      icon512: [512, 512, "px"]
+    }.transform_values(&:freeze).freeze
+
+    private_constant :PAPER_SIZES
+  end
+end

data/lib/sevgi/graphics/auxiliary.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "auxiliary/scalar"
 require_relative "auxiliary/margin"
+require_relative "auxiliary/sizes"
 require_relative "auxiliary/paper"
 
 require_relative "auxiliary/canvas"