asciidoctor-pdf 1.5.0.alpha.16 → 1.5.0

data/lib/asciidoctor-pdf/prawn_ext/images.rb

@@ -1,40 +0,0 @@
-module Asciidoctor
-module Prawn
-module Images
-  class << self
-    def extended base
-      base.class.__send__ :alias_method, :_initial_image, :image
-    end
-  end
-
-  # Dispatch to suitable image method in Prawn based on file extension.
-  def image file, opts = {}
-    # FIXME handle case when SVG is a File or IO object
-    if ::String === file && (file.downcase.end_with? '.svg')
-      opts[:fallback_font_name] ||= default_svg_font if respond_to? :default_svg_font
-      svg((::IO.read file), opts)
-    else
-      _initial_image file, opts
-    end
-  end
-
-  # Retrieve the intrinsic image dimensions for the specified path.
-  #
-  # Returns a Hash containing :width and :height keys that map to the image's
-  # intrinsic width and height values (in pixels)
-  def intrinsic_image_dimensions path
-    if path.end_with? '.svg'
-      img_obj = ::Prawn::Svg::Interface.new ::IO.read(path), self, {}
-      img_size = img_obj.document.sizing
-      { width: img_size.output_width, height: img_size.output_height }
-    else
-      # NOTE build_image_object caches image data previously loaded
-      _, img_size = ::File.open(path, 'rb') {|fd| build_image_object fd }
-      { width: img_size.width, height: img_size.height }
-    end
-  end
-end
-
-::Prawn::Document.extensions << Images
-end
-end

data/lib/asciidoctor-pdf/prawn_ext.rb

@@ -1,5 +0,0 @@
-# the following are organized under the Asciidoctor::Prawn namespace
-require_relative 'prawn_ext/font/afm'
-require_relative 'prawn_ext/images'
-require_relative 'prawn_ext/formatted_text/fragment'
-require_relative 'prawn_ext/extensions'

data/lib/asciidoctor-pdf/roman_numeral.rb

@@ -1,114 +0,0 @@
-########################################################################
-#
-# This file was copied from roman-numerals and modified for use with
-# Asciidoctor PDF.
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Copyright (c) 2011 Andrew Vos
-# Copyright (c) 2014 OpenDevice, Inc.
-#
-########################################################################
-
-module Asciidoctor
-module Pdf
-class RomanNumeral
-  BaseDigits = {
-    1    => 'I',
-    4    => 'IV',
-    5    => 'V',
-    9    => 'IX',
-    10   => 'X',
-    40   => 'XL',
-    50   => 'L',
-    90   => 'XC',
-    100  => 'C',
-    400  => 'CD',
-    500  => 'D',
-    900  => 'CM',
-    1000 => 'M'
-  }
-
-  def initialize initial_value, letter_case = nil
-    initial_value ||= 1
-    if ::Integer === initial_value
-      @integer_value = initial_value
-    else
-      @integer_value = RomanNumeral.roman_to_int initial_value
-      letter_case = :lower if letter_case.nil? && initial_value.upcase != initial_value
-    end
-    @letter_case = letter_case.nil? ? :upper : letter_case
-  end
-
-  def to_s
-    to_r
-  end
-
-  def to_r
-    if (int = @integer_value) < 1
-      return int.to_s
-    end
-    roman = RomanNumeral.int_to_roman int
-    @letter_case == :lower ? roman.downcase : roman
-  end
-
-  def to_i
-    @integer_value
-  end
-
-  def next
-    RomanNumeral.new @integer_value + 1, @letter_case
-  end
-
-  def next!
-    @integer_value += 1
-    self
-  end
-
-  def pred
-    RomanNumeral.new @integer_value - 1, @letter_case
-  end
-
-  def self.int_to_roman value
-    result = []
-    BaseDigits.keys.reverse.each do |ival|
-      while value >= ival
-        value -= ival 
-        result << BaseDigits[ival]
-      end
-    end
-    result.join
-  end
-
-  def self.roman_to_int value
-    value = value.upcase
-    result = 0
-    BaseDigits.values.reverse.each do |rval|
-      while value.start_with? rval
-        offset = rval.length
-        value = value[offset..offset]
-        result += BaseDigits.key rval
-      end
-    end
-    result
-  end
-end
-end
-end

data/lib/asciidoctor-pdf/rouge_ext/css_theme.rb

@@ -1,15 +0,0 @@
-module Rouge
-class CSSTheme
-  # Patch style_for to return most specific style first
-  # See https://github.com/jneen/rouge/issues/280
-  # Fixed as of rouge v1.10.0
-  def style_for token
-    token.token_chain.reverse_each do |t|
-      if (s = styles[t])
-        return s
-      end
-    end
-    nil
-  end
-end
-end if (Gem::Version.new Rouge.version) < (Gem::Version.new '1.10.0')

data/lib/asciidoctor-pdf/rouge_ext/formatters/prawn.rb

@@ -1,164 +0,0 @@
-module Rouge
-module Formatters
-# Transforms a token stream into an array of 
-# formatted text fragments for use with Prawn.
-class Prawn < Formatter
-  tag 'prawn'
-
-  Tokens = ::Rouge::Token::Tokens
-
-  LF = %(\n)
-  NoBreakSpace = %(\u00a0)
-  InnerIndent = %(\n )
-  GuardedIndent = %(\u00a0)
-  GuardedInnerIndent = %(\n\u00a0)
-  BoldStyle = [:bold].to_set
-  ItalicStyle = [:italic].to_set
-  BoldItalicStyle = [:bold, :italic].to_set
-  UnderlineStyle = [:underline].to_set
-
-  def initialize opts = {}
-    unless ::Rouge::Theme === (theme = opts[:theme])
-      unless theme && (theme = ::Rouge::Theme.find theme)
-        theme = ::Rouge::Themes::Pastie
-      end
-      theme = theme.new
-    end
-    @theme = theme
-    @normalized_colors = {}
-    @background_colorizer = BackgroundColorizer.new line_gap: opts[:line_gap]
-    @linenum_fragment_base = (create_fragment Tokens::Generic::Lineno).merge linenum: true
-  end
-
-  def background_color
-    @background_color ||= normalize_color((@theme.style_for Tokens::Text).bg)
-  end
-
-  # Override format method so fragments don't get flatted to a string
-  # and to add an options Hash.
-  def format tokens, opts = {}
-    stream tokens, opts
-  end
-
-  def stream tokens, opts = {}
-    if opts[:line_numbers]
-      if (linenum = opts[:start_line]) > 0
-        linenum -= 1
-      else
-        linenum = 0
-      end
-      fragments = []
-      fragments << (create_linenum_fragment linenum += 1)
-      tokens.each do |tok, val|
-        if val == LF
-          fragments << { text: LF }
-          fragments << (create_linenum_fragment linenum += 1)
-        elsif val.include? LF
-          # NOTE we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
-          line_oriented = val.end_with? LF
-          base_fragment = create_fragment tok, val
-          val.each_line do |line|
-            fragments << (line_oriented ? (base_fragment.merge text: line, line_oriented: true) : (base_fragment.merge text: line))
-            # NOTE append linenum fragment if there's a next line; only works if source doesn't have trailing endline
-            fragments << (create_linenum_fragment linenum += 1) if line.end_with? LF
-          end
-        else
-          fragments << (create_fragment tok, val)
-        end
-      end
-      # NOTE drop orphaned linenum fragment (due to trailing endline in source)
-      fragments.pop if (last_fragment = fragments[-1]) && last_fragment[:linenum]
-      # NOTE pad numbers that have less digits than the largest line number
-      if (linenum_w = linenum.to_s.length) > 1
-        # NOTE extra column is the trailing space after the line number
-        linenum_w += 1
-        fragments.each do |fragment|
-          fragment[:text] = %(#{fragment[:text].rjust linenum_w, NoBreakSpace}) if fragment[:linenum]
-        end
-      end
-      fragments
-    else
-      start_of_line = true
-      tokens.map do |tok, val|
-        # match one or more consecutive endlines
-        if val == LF || (val == (LF * val.length))
-          start_of_line = true
-          { text: val }
-        else
-          val[0] = GuardedIndent if start_of_line && (val.start_with? ' ')
-          val.gsub! InnerIndent, GuardedInnerIndent if val.include? InnerIndent
-          # QUESTION do we need the call to create_fragment if val contains only spaces? consider bg
-          #fragment = create_fragment tok, val
-          fragment = val.rstrip.empty? ? { text: val } : (create_fragment tok, val)
-          # NOTE we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
-          fragment[:line_oriented] = true if (start_of_line = val.end_with? LF)
-          fragment
-        end
-      end
-      # QUESTION should we strip trailing newline?
-    end
-  end
-
-  # TODO method could still be optimized (for instance, check if val is LF or empty)
-  def create_fragment tok, val = nil
-    fragment = val ? { text: val } : {}
-    if (style_rules = @theme.style_for tok)
-      if (bg = normalize_color style_rules.bg) && bg != @background_color
-        fragment[:background_color] = bg
-        fragment[:callback] = @background_colorizer
-        fragment[:inline_block] = true if style_rules[:inline_block]
-        fragment[:extend] = true if style_rules[:extend]
-      end
-      if (fg = normalize_color style_rules.fg)
-        fragment[:color] = fg
-      end
-      if style_rules[:bold]
-        fragment[:styles] = style_rules[:italic] ? BoldItalicStyle.dup : BoldStyle.dup
-      elsif style_rules[:italic]
-        fragment[:styles] = ItalicStyle.dup
-      end
-      if style_rules[:underline]
-        if fragment.key? :styles
-          fragment[:styles] << UnderlineStyle[0]
-        else
-          fragment[:styles] = UnderlineStyle.dup
-        end
-      end
-    end
-    fragment
-  end
-
-  def create_linenum_fragment linenum
-    @linenum_fragment_base.merge text: %(#{linenum} )
-  end
-
-  def normalize_color raw
-    return unless raw
-    if (normalized = @normalized_colors[raw])
-      normalized
-    else
-      normalized = (raw.start_with? '#') ? raw[1..-1] : raw
-      normalized = normalized.each_char.map {|c| c * 2 }.join if normalized.length == 3
-      @normalized_colors[raw] = normalized
-    end
-  end
-end
-
-class BackgroundColorizer
-  def initialize opts = {}
-    @line_gap = opts[:line_gap] || 0
-  end
-
-  def render_behind fragment
-    pdf = fragment.document
-    data = fragment.format_state
-    prev_fill_color = pdf.fill_color
-    pdf.fill_color data[:background_color]
-    v_gap = data[:inline_block] ? @line_gap : 0
-    fragment_width = data[:line_oriented] && data[:extend] ? (pdf.bounds.width - fragment.left) : fragment.width
-    pdf.fill_rectangle [fragment.left, fragment.top + v_gap * 0.5], fragment_width, (fragment.height + v_gap)
-    pdf.fill_color prev_fill_color
-  end
-end
-end
-end

data/lib/asciidoctor-pdf/rouge_ext.rb

@@ -1,4 +0,0 @@
-require 'rouge'
-require_relative 'rouge_ext/formatters/prawn'
-require_relative 'rouge_ext/css_theme'
-require_relative 'rouge_ext/themes/pastie'

data/lib/asciidoctor-pdf/sanitizer.rb

@@ -1,88 +0,0 @@
-begin
-  require 'unicode' unless defined? Unicode::VERSION
-rescue LoadError
-  begin
-    require 'active_support/multibyte' unless defined? ActiveSupport::Multibyte
-  rescue LoadError; end
-end
-
-module Asciidoctor
-module Pdf
-module Sanitizer
-  BuiltInEntityChars = {
-    '&lt;' => '<',
-    '&gt;' => '>',
-    '&amp;' => '&'
-  }
-  BuiltInEntityCharRx = /(?:#{BuiltInEntityChars.keys * '|'})/
-  BuiltInEntityCharOrTagRx = /(?:#{BuiltInEntityChars.keys * '|'}|<)/
-  InverseBuiltInEntityChars = BuiltInEntityChars.invert
-  InverseBuiltInEntityCharRx = /[#{InverseBuiltInEntityChars.keys.join}]/
-  NumericCharRefRx = /&#(\d{2,6});/
-  XmlSanitizeRx = /<[^>]+>/
-  SegmentPcdataRx = /(?:(&[a-z]+;|<[^>]+>)|([^&<]+))/
-
-  # Strip leading, trailing and repeating whitespace, remove XML tags and
-  # resolve all entities in the specified string.
-  #
-  # FIXME move to a module so we can mix it in elsewhere
-  # FIXME add option to control escaping entities, or a filter mechanism in general
-  def sanitize string
-    string.strip
-        .gsub(XmlSanitizeRx, '')
-        .tr_s(' ', ' ')
-        .gsub(NumericCharRefRx) { [$1.to_i].pack('U*') }
-        .gsub(BuiltInEntityCharRx, BuiltInEntityChars)
-  end
-
-  def escape_xml string
-    string.gsub InverseBuiltInEntityCharRx, InverseBuiltInEntityChars
-  end
-
-  def uppercase_pcdata string
-    if BuiltInEntityCharOrTagRx =~ string
-      string.gsub(SegmentPcdataRx) { $2 ? (uppercase_mb $2) : $1 }
-    else
-      uppercase_mb string
-    end
-  end
-
-  if RUBY_VERSION >= '2.4'
-    def uppercase_mb string
-      string.upcase
-    end
-
-    def lowercase_mb string
-      string.downcase
-    end
-  # NOTE Unicode library is 4x as fast as ActiveSupport::MultiByte::Chars
-  elsif defined? ::Unicode
-    def uppercase_mb string
-      string.ascii_only? ? string.upcase : (::Unicode.upcase string)
-    end
-
-    def lowercase_mb string
-      string.ascii_only? ? string.downcase : (::Unicode.downcase string)
-    end
-  elsif defined? ::ActiveSupport::Multibyte
-    MultibyteChars = ::ActiveSupport::Multibyte::Chars
-
-    def uppercase_mb string
-      string.ascii_only? ? string.upcase : (MultibyteChars.new string).upcase.to_s
-    end
-
-    def lowercase_mb string
-      string.ascii_only? ? string.downcase : (MultibyteChars.new string).downcase.to_s
-    end
-  else
-    def uppercase_mb string
-      string.upcase
-    end
-
-    def lowercase_mb string
-      string.downcase
-    end
-  end
-end
-end
-end

data/lib/asciidoctor-pdf/temporary_path.rb

@@ -1,13 +0,0 @@
-module Asciidoctor
-module Pdf
-module TemporaryPath
-  def unlink
-    ::File.unlink self
-  end
-
-  def exist?
-    ::File.file? self
-  end
-end
-end
-end

data/lib/asciidoctor-pdf/theme_loader.rb

@@ -1,247 +0,0 @@
-require 'safe_yaml/load'
-require 'ostruct'
-require_relative 'core_ext/ostruct'
-require_relative 'measurements'
-
-module Asciidoctor
-module Pdf
-class ThemeLoader
-  include ::Asciidoctor::Pdf::Measurements
-
-  DataDir = ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', '..', 'data'))
-  ThemesDir = ::File.join DataDir, 'themes'
-  FontsDir = ::File.join DataDir, 'fonts'
-  DefaultThemePath = ::File.expand_path 'default-theme.yml', ThemesDir
-  BaseThemePath = ::File.expand_path 'base-theme.yml', ThemesDir
-
-  VariableRx = /\$([a-z0-9_]+)/
-  LoneVariableRx = /^\$([a-z0-9_]+)$/
-  HexColorEntryRx = /^(?<k>[[:blank:]]*[[:graph:]]+): +(?!null$)(?<q>["']?)#?(?<v>\w{3,6})\k<q> *(?:#.*)?$/
-  MultiplyDivideOpRx = /(-?\d+(?:\.\d+)?) +([*\/]) +(-?\d+(?:\.\d+)?)/
-  AddSubtractOpRx = /(-?\d+(?:\.\d+)?) +([+\-]) +(-?\d+(?:\.\d+)?)/
-  PrecisionFuncRx = /^(round|floor|ceil)\(/
-
-  # TODO implement white? & black? methods
-  module ColorValue; end
-
-  class HexColorValue < String
-    include ColorValue
-  end
-
-  # A marker module for a normalized CMYK array
-  # Prevents normalizing CMYK value more than once
-  module CmykColorValue
-    include ColorValue
-    def to_s
-      %([#{join ', '}])
-    end
-  end
-
-  def self.resolve_theme_file theme_name = nil, theme_path = nil
-    theme_name ||= 'default'
-    # if .yml extension is given, assume it's a full file name
-    if (theme_name.end_with? '.yml')
-      # FIXME restrict to jail!
-      # QUESTION why are we not using expand_path in this case?
-      theme_path ? (::File.join theme_path, theme_name) : theme_name
-    else
-      # QUESTION should we append '-theme.yml' or just '.yml'?
-      ::File.expand_path %(#{theme_name}-theme.yml), (theme_path || ThemesDir)
-    end
-  end
-
-  def self.resolve_theme_asset asset_path, theme_path = nil
-    ::File.expand_path asset_path, (theme_path || ThemesDir)
-  end
-
-  # NOTE base theme is loaded "as is" (no post-processing)
-  def self.load_base_theme
-    ::OpenStruct.new(::SafeYAML.load_file BaseThemePath)
-  end
-
-  def self.load_theme theme_name = nil, theme_path = nil, opts = {}
-    if (theme_file = resolve_theme_file theme_name, theme_path) == BaseThemePath ||
-        (theme_file != DefaultThemePath && (opts.fetch :apply_base_theme, true))
-      theme_data = load_base_theme
-    else
-      theme_data = nil
-    end
-
-    if theme_file == BaseThemePath
-      theme_data
-    else
-      load_file theme_file, theme_data
-    end
-  end
-
-  def self.load_file filename, theme_data = nil
-    raw_data = (::IO.read filename, encoding: ::Encoding::UTF_8).each_line.map {|l| l.sub HexColorEntryRx, '\k<k>: \'\k<v>\'' }.join
-    self.new.load((::SafeYAML.load raw_data), theme_data)
-  end
-
-  def load hash, theme_data = nil
-    theme_data ||= ::OpenStruct.new
-    return theme_data unless ::Hash === hash
-    hash.inject(theme_data) {|data, (key, val)| process_entry key, val, data }
-    # NOTE remap legacy running content keys (e.g., header_recto_content_left => header_recto_left_content)
-    %w(header_recto header_verso footer_recto footer_verso).each do |periphery_face|
-      %w(left center right).each do |align|
-        if (val = theme_data.delete %(#{periphery_face}_content_#{align}))
-          theme_data[%(#{periphery_face}_#{align}_content)] = val
-        end
-      end
-    end
-    theme_data.base_align ||= 'left'
-    # QUESTION should we do any other post-load calculations or defaults?
-    theme_data
-  end
-
-  private
-
-  def process_entry key, val, data
-    if key.start_with? 'font_'
-      data[key] = val
-    elsif key.start_with? 'admonition_icon_'
-      data[key] = (val || {}).map do |(key2, val2)|
-        [key2.to_sym, (key2.end_with? '_color') ? to_color(evaluate val2, data) : (evaluate val2, data)]
-      end.to_h
-    elsif ::Hash === val
-      val.each do |key2, val2|
-        process_entry %(#{key}_#{key2.tr '-', '_'}), val2, data
-      end
-    elsif key.end_with? '_color'
-      # QUESTION do we need to evaluate_math in this case?
-      data[key] = to_color(evaluate val, data)
-    elsif %(#{key.chomp '_'}_).include? '_content_'
-      data[key] = (expand_vars val.to_s, data).to_s
-    else
-      data[key] = evaluate val, data
-    end
-    data
-  end
-
-  def evaluate expr, vars
-    case expr
-    when ::String
-      evaluate_math(expand_vars expr, vars)
-    when ::Array
-      expr.map {|e| evaluate e, vars }
-    else
-      expr
-    end
-  end
-
-  # NOTE we assume expr is a String
-  def expand_vars expr, vars
-    if (idx = (expr.index '$'))
-      if idx == 0 && expr =~ LoneVariableRx
-        if vars.respond_to? $1
-          vars[$1]
-        else
-          warn %(asciidoctor: WARNING: unknown variable reference in PDF theme: $#{$1})
-          expr
-        end
-      else
-        expr.gsub(VariableRx) {
-          if vars.respond_to? $1
-            vars[$1]
-          else
-            warn %(asciidoctor: WARNING: unknown variable reference in PDF theme: $#{$1})
-            $&
-          end
-        }
-      end
-    else
-      expr
-    end
-  end
-
-  def evaluate_math expr
-    return expr if !(::String === expr) || ColorValue === expr
-    # resolve measurement values (e.g., 0.5in => 36)
-    # QUESTION should we round the value? perhaps leave that to the precision functions
-    # NOTE leave % as a string; handled by converter for now
-    expr = resolve_measurement_values(original = expr)
-    while true
-      result = expr.gsub(MultiplyDivideOpRx) { $1.to_f.send $2.to_sym, $3.to_f }
-      unchanged = (result == expr)
-      expr = result
-      break if unchanged
-    end
-    while true
-      result = expr.gsub(AddSubtractOpRx) { $1.to_f.send $2.to_sym, $3.to_f }
-      unchanged = (result == expr)
-      expr = result
-      break if unchanged
-    end
-    if (expr.end_with? ')') && expr =~ PrecisionFuncRx
-      op = $1
-      offset = op.length + 1
-      expr = expr[offset...-1].to_f.send op.to_sym
-    end
-    if expr == original
-      original
-    else
-      (int_val = expr.to_i) == (flt_val = expr.to_f) ? int_val : flt_val
-    end
-  end
-
-  def to_color value
-    case value
-    when ColorValue
-      # already converted
-      return value
-    when ::String
-      if value == 'transparent'
-        # FIXME should we have a TransparentColorValue class?
-        return HexColorValue.new value
-      elsif value.length == 6
-        return HexColorValue.new value.upcase
-      end
-    when ::Array
-      case value.length
-      # CMYK value
-      when 4
-        value = value.map do |e|
-          if ::Numeric === e
-            e = e * 100.0 unless e > 1
-          else
-            e = e.to_s.chomp('%').to_f
-          end
-          e == (int_e = e.to_i) ? int_e : e
-        end
-        case value
-        when [0, 0, 0, 0]
-          return HexColorValue.new 'FFFFFF'
-        when [100, 100, 100, 100]
-          return HexColorValue.new '000000'
-        else
-          value.extend CmykColorValue
-          return value
-        end
-      # RGB value
-      when 3
-        return HexColorValue.new value.map {|e| '%02X' % e}.join
-      # Nonsense array value; flatten to string
-      else
-        value = value.join
-      end
-    else
-      # Unknown type; coerce to a string
-      value = value.to_s
-    end
-    value = case value.length
-    when 6
-      value
-    when 3
-      # expand hex shorthand (e.g., f00 -> ff0000)
-      value.each_char.map {|c| c * 2 }.join
-    else
-      # truncate or pad with leading zeros (e.g., ff -> 0000ff)
-      value[0..5].rjust 6, '0'
-    end
-    HexColorValue.new value.upcase
-  end
-end
-end
-end

data/lib/asciidoctor-pdf/ttfunk_ext.rb

@@ -1,8 +0,0 @@
-# patch ttfunk 1.5.0; see https://github.com/prawnpdf/ttfunk/issues/39
-class TTFunk::Subset::Base
-  alias __checksum checksum
-  def checksum data
-    return 0 if data.length == 0
-    __checksum data
-  end
-end