pd4ml 1.0.0

data/lib/pd4ml/installer.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'net/http'
+require 'time'
+
+module Pd4ml
+  # Downloads a PD4ML build from the PD4ML Maven repository and makes it the gem's default:
+  #
+  #   pd4ml install                    the most recent 4.* release
+  #   pd4ml install --snapshots        the most recent 4.* build, snapshots included
+  #   pd4ml install 4.0.23fx2          an exact version
+  #
+  # or Pd4ml.install from code. The jar is stored in the user's cache directory (PD4ML_HOME to
+  # choose another) with the Bouncy Castle jars PD4ML needs for encryption and signing, every
+  # file verified against its published SHA-1 checksum. With no build installed or configured,
+  # the first use of PD4ML downloads one (PD4ML_AUTO_INSTALL=0 turns that off).
+  module Installer
+    REPOSITORY = 'https://pd4ml.com/maven2'
+    CENTRAL = 'https://repo1.maven.org/maven2'
+    GROUP_PATH = 'com/pd4ml/pd4ml'
+    # The Bouncy Castle version PD4ML is built against (https://pd4ml.com/docs/#2.-obtaining-pd4ml).
+    BOUNCYCASTLE_VERSION = '1.84'
+    BOUNCYCASTLE = %w[bcprov-jdk18on bcpkix-jdk18on bcutil-jdk18on].freeze
+    MANIFEST = 'installed.json'
+    VERSION_PATTERN = /\A(\d+)\.(\d+)\.(\d+)(?:fx(\d+)(?:a(\d+))?)?(-jakarta)?(-SNAPSHOT)?\z/
+
+    module_function
+
+    # ----------------------------------------------------------------------------- versions
+
+    # An ordering key for a PD4ML version (4.1.1, 4.0.23fx2, 4.0.23fx1a1, 4.1.2-SNAPSHOT), or nil
+    # for an unknown form. A snapshot sorts below its release, an fxNaM pre-release below fxN.
+    def version_key(version)
+      m = VERSION_PATTERN.match(version)
+      return nil unless m
+
+      [m[1].to_i, m[2].to_i, m[3].to_i, m[4].to_i, m[5] ? 0 : 1, m[5].to_i, m[7] ? 0 : 1]
+    end
+
+    # Versions sorted oldest first (unknown forms dropped).
+    def sort_versions(versions) = versions.select { |v| version_key(v) }.sort_by { |v| version_key(v) }
+
+    # The most recent `major`.* version: releases only unless `snapshots`, -jakarta only with `jakarta`.
+    def select_version(versions, major: 4, snapshots: false, jakarta: false)
+      candidates = versions.select do |v|
+        k = version_key(v)
+        k && k[0] == major && (snapshots || !v.end_with?('-SNAPSHOT')) && v.include?('-jakarta') == jakarta
+      end
+      raise InstallError, "no #{major}.* version in the repository" if candidates.empty?
+
+      sort_versions(candidates).last
+    end
+
+    # The versions the repository lists.
+    def available_versions(repository = REPOSITORY)
+      fetch("#{repository}/#{GROUP_PATH}/maven-metadata.xml").scan(%r{<version>([^<]+)</version>}).flatten.map(&:strip)
+    end
+
+    # ------------------------------------------------------------------------------ install
+
+    # Downloads a PD4ML build (unless already there) and makes it the default one; returns the
+    # jar's path. version: 'latest' (the most recent 4.* release; with snapshots: true, the most
+    # recent 4.* build) or an exact one such as '4.0.23fx2'.
+    def install(version = 'latest', snapshots: false, jakarta: false, repository: REPOSITORY, home: nil,
+                force: false, quiet: false, bouncycastle: true)
+      home ||= default_home
+      version = select_version(available_versions(repository), snapshots: snapshots, jakarta: jakarta) if version == 'latest'
+      name = jar_name(version, repository)
+      jar = File.join(home, name)
+      download("#{repository}/#{GROUP_PATH}/#{version}/#{name}", jar, force, quiet)
+      libs = []
+      if bouncycastle
+        BOUNCYCASTLE.each do |artifact|
+          lib = "#{artifact}-#{BOUNCYCASTLE_VERSION}.jar"
+          download("#{CENTRAL}/org/bouncycastle/#{artifact}/#{BOUNCYCASTLE_VERSION}/#{lib}", File.join(home, 'lib', lib),
+                   force, quiet)
+          libs << "lib/#{lib}"
+        end
+      end
+      manifest = read_manifest(home).merge('version' => version, 'jar' => name, 'libs' => libs,
+                                           'repository' => repository, 'installed' => Time.now.utc.iso8601)
+      tmp = File.join(home, "#{MANIFEST}.#{Process.pid}.part") # several processes may install at once
+      File.write(tmp, JSON.pretty_generate(manifest))
+      File.rename(tmp, File.join(home, MANIFEST))
+      warn "PD4ML #{version}: #{jar}" unless quiet
+      jar
+    end
+
+    # Where downloaded builds go: PD4ML_HOME, else the user's cache directory.
+    def default_home
+      return ENV['PD4ML_HOME'] if ENV['PD4ML_HOME'].to_s != ''
+
+      if Gem.win_platform?
+        File.join(ENV['LOCALAPPDATA'] || File.join(Dir.home, 'AppData', 'Local'), 'pd4ml-ruby')
+      else
+        File.join(ENV['XDG_CACHE_HOME'].to_s.empty? ? File.join(Dir.home, '.cache') : ENV['XDG_CACHE_HOME'], 'pd4ml-ruby')
+      end
+    end
+
+    # The jar install made the default, or nil.
+    def installed_jar(home = default_home)
+      jar = read_manifest(home)['jar']
+      path = jar && File.join(home, jar)
+      path && File.exist?(path) ? path : nil
+    end
+
+    # The installed build's classpath: the PD4ML jar and its companion jars; empty if none.
+    def installed_classpath(home = default_home)
+      jar = installed_jar(home)
+      return [] unless jar
+
+      [jar, *Array(read_manifest(home)['libs']).map { |l| File.join(home, l) }.select { |p| File.exist?(p) }]
+    end
+
+    # The version install made the default, or nil.
+    def installed_version(home = default_home)
+      installed_jar(home) ? read_manifest(home)['version'] : nil
+    end
+
+    # Whether the first use of PD4ML may download a build (PD4ML_AUTO_INSTALL, default on).
+    def auto_install?
+      !%w[0 false no off].include?(ENV.fetch('PD4ML_AUTO_INSTALL', '1').strip.downcase)
+    end
+
+    # ---------------------------------------------------------------------------- internals
+
+    def jar_name(version, repository)
+      return "pd4ml-#{version}.jar" unless version.end_with?('-SNAPSHOT')
+
+      xml = fetch("#{repository}/#{GROUP_PATH}/#{version}/maven-metadata.xml")
+      xml.scan(%r{<snapshotVersion>(.*?)</snapshotVersion>}m).flatten.each do |sv|
+        tag = ->(t) { sv[%r{<#{t}>([^<]*)</#{t}>}, 1] }
+        return "pd4ml-#{tag.call('value')}.jar" if tag.call('extension') == 'jar' && tag.call('classifier').to_s.empty? && tag.call('value')
+      end
+      ts = xml[%r{<timestamp>([^<]+)</timestamp>}, 1]
+      build = xml[%r{<buildNumber>([^<]+)</buildNumber>}, 1]
+      return "pd4ml-#{version.delete_suffix('-SNAPSHOT')}-#{ts}-#{build}.jar" if ts && build
+
+      raise InstallError, "no jar listed for #{version}"
+    end
+
+    def download(url, path, force, quiet)
+      return if !force && File.exist?(path)
+
+      warn "downloading #{url}" unless quiet
+      data = fetch(url)
+      expected = fetch("#{url}.sha1").strip.split.first.to_s.downcase
+      actual = Digest::SHA1.hexdigest(data)
+      raise InstallError, "checksum mismatch for #{url}: #{actual} != #{expected}" if !expected.empty? && actual != expected
+
+      FileUtils.mkdir_p(File.dirname(path))
+      tmp = "#{path}.#{Process.pid}.part"
+      File.binwrite(tmp, data)
+      File.rename(tmp, path)
+    end
+
+    def fetch(url, redirects = 5)
+      uri = URI(url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', open_timeout: 30, read_timeout: 300) do |http|
+        http.get(uri.request_uri, 'User-Agent' => 'pd4ml-ruby')
+      end
+      case response
+      when Net::HTTPSuccess then response.body.b
+      when Net::HTTPRedirection
+        raise InstallError, "too many redirects: #{url}" if redirects.zero?
+
+        fetch(URI.join(url, response['location']).to_s, redirects - 1)
+      else raise InstallError, "cannot download #{url} (HTTP #{response.code})"
+      end
+    rescue SocketError, SystemCallError, Timeout::Error, OpenSSL::SSL::SSLError => e
+      raise InstallError, "cannot download #{url}: #{e.message}"
+    end
+
+    def read_manifest(home)
+      JSON.parse(File.read(File.join(home, MANIFEST)))
+    rescue Errno::ENOENT, JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/pd4ml/java.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Pd4ml
+  # Converts a Ruby-style method name to the Java one: set_page_size -> setPageSize,
+  # demo_mode? -> isDemoMode. Names without underscores (Java names) pass through.
+  module Naming
+    @methods = {}
+    @lock = Mutex.new
+
+    module_function
+
+    # The Java method `name` (Ruby-style or Java) means on the class: use_ttf -> useTTF,
+    # demo_mode? -> isDemoMode, read_html -> readHTML. Ruby-style names are matched against the
+    # class's real method names ignoring case and underscores, so acronyms resolve too.
+    def resolve(bridge, java_class, name, static)
+      n = name.to_s
+      return n unless n.include?('_') || n.end_with?('?')
+
+      key = (n.end_with?('?') ? "is#{n[0..-2]}" : n).delete('_').downcase
+      table = @lock.synchronize do
+        @methods[[bridge.object_id, java_class, static]] ||= begin
+          info = bridge.describe(java_class)
+          names = static ? info['methods'] : Array(info['instanceMethods']) + Array(info['methods'])
+          names.to_h { |m| [m.downcase, m] }
+        end
+      end
+      table[key] || java_name(n)
+    end
+
+    def java_name(name)
+      n = name.to_s
+      if n.end_with?('?')
+        base = java_name(n[0..-2])
+        return "is#{base[0].upcase}#{base[1..]}"
+      end
+      return n unless n.include?('_') && n == n.downcase
+
+      parts = n.split('_').reject(&:empty?)
+      parts.first + parts.drop(1).map(&:capitalize).join
+    end
+  end
+
+  # A Java object living in the bridge. Call its Java methods by their Java names or in Ruby
+  # style (`size.rotate`, `pd.set_page_size(...)`, `pd.demo_mode?`). Public fields: `obj[:width]`
+  # / `obj[:width] = v`. Released in Java when garbage collected.
+  class JavaObject < BasicObject
+    def initialize(bridge, handle, java_class, enum_name)
+      @bridge = bridge
+      @handle = handle
+      @java_class = java_class
+      @enum_name = enum_name
+      ::ObjectSpace.define_finalizer(self, JavaObject.releaser(bridge, handle))
+    end
+
+    def self.releaser(bridge, handle)
+      proc { bridge.release(handle) }
+    end
+
+    # internal: the bridge handle
+    def __handle = @handle
+
+    # The Java class name ('com.pd4ml.PageSize').
+    def java_class = @java_class
+
+    # For an enum constant, its name ('v42', 'MM'); else nil.
+    def enum_name = @enum_name
+
+    # Reads a public field.
+    def [](field) = @bridge.get_field(self, field.to_s)
+
+    # Writes a public field.
+    def []=(field, value)
+      @bridge.set_field(self, field.to_s, value)
+    end
+
+    # Calls a Java method by its exact Java name.
+    def call_java(method, *args) = @bridge.call(self, method.to_s, args)
+
+    # Whether the object is an instance of the Java class or interface.
+    def instance_of_java?(name) = @bridge.instance_of?(self, name)
+
+    # Java toString().
+    def to_s = @bridge.call(self, 'toString', []).to_s
+    alias to_str to_s
+
+    def inspect = "#<Java #{@java_class} #{@enum_name || to_s}>"
+
+    # Java equals() (and the same object).
+    def ==(other)
+      equal?(other) || (JavaObject === other && @bridge.call(self, 'equals', [other]) == true)
+    end
+
+    def hash = @bridge.call(self, 'hashCode', [])
+
+    def eql?(other) = equal?(other)
+
+    def is_a?(klass) = klass == JavaObject || klass == ::BasicObject
+    alias kind_of? is_a?
+
+    def class = JavaObject
+
+    def nil? = false
+
+    def respond_to?(name, _include_all = false)
+      %i[java_class enum_name to_s inspect [] []= call_java instance_of_java?].include?(name.to_sym) ||
+        !name.to_s.end_with?('=')
+    end
+
+    def method_missing(name, *args, &block)
+      ::Kernel.raise ::NoMethodError, "set Java fields with obj[:#{name.to_s.chomp('=')}] = value" if name.to_s.end_with?('=')
+      ::Kernel.raise ::ArgumentError, 'Java methods take no block' if block
+
+      @bridge.call(self, Naming.resolve(@bridge, @java_class, name, false), args)
+    end
+
+    def respond_to_missing?(_name, _include_private = false) = true
+  end
+
+  # A Java class as a Ruby class: constants and static fields (`PageSize::A4`, `PageSize.A4`,
+  # `LayoutEngine.v42`), static methods (`PdfSpec.get_instance('pdf/a-2b')`), constructors
+  # (`PageMargins.new(10, 10, 10, 10, Units::MM)`).
+  class JavaClass
+    class << self
+      attr_reader :java_name
+
+      def new(*args) = Bridge.get.new_object(@java_name, args)
+
+      def to_s = @java_name
+      alias inspect to_s
+
+      # Reads a static field.
+      def [](field) = Bridge.get.get_field(@java_name, field.to_s)
+
+      # Writes a static field.
+      def []=(field, value)
+        Bridge.get.set_field(@java_name, field.to_s, value)
+      end
+
+      # Calls a static method by its exact Java name.
+      def call_java(method, *args) = Bridge.get.call_static(@java_name, method.to_s, args)
+
+      def const_missing(name)
+        value_of(name.to_s) { super }
+      end
+
+      def method_missing(name, *args, &block)
+        n = name.to_s
+        return super if block || n.end_with?('=', '!')
+
+        d = description
+        if d[:fields].include?(n) && args.empty?
+          value_of(n)
+        else
+          java = Naming.resolve(Bridge.get, @java_name, n, true)
+          return super unless d[:methods].include?(java)
+
+          Bridge.get.call_static(@java_name, java, args)
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        d = description
+        d[:fields].include?(name.to_s) || d[:methods].include?(Naming.resolve(Bridge.get, @java_name, name, true)) || super
+      end
+
+      private
+
+      # A static field: constants are read once per bridge.
+      def value_of(field)
+        d = description
+        return yield unless d[:fields].include?(field)
+        return Bridge.get.get_field(@java_name, field) unless d[:constants].include?(field)
+
+        d[:values].fetch(field) { d[:values][field] = Bridge.get.get_field(@java_name, field) }
+      end
+
+      def description
+        bridge = Bridge.get
+        if @description.nil? || !@description[:bridge].equal?(bridge)
+          info = bridge.describe(@java_name)
+          @description = { bridge: bridge, fields: info['fields'], constants: info['constants'],
+                           methods: info['methods'], values: {} }
+        end
+        @description
+      end
+    end
+  end
+
+  # Java classes by name, Java interfaces implemented by Ruby blocks.
+  module Java
+    @classes = {}
+    @lock = Mutex.new
+
+    # A Java class (`Pd4ml::Java.type('java.util.Locale').get_default`); nested classes by '.' or '$'.
+    def self.type(name)
+      @lock.synchronize do
+        @classes[name] ||= Class.new(JavaClass) { @java_name = name }
+      end
+    end
+
+    # A Java object implementing the interface, its methods calling the block with
+    # (method, args) on this thread while PD4ML runs.
+    def self.proxy(iface, &block)
+      raise ArgumentError, 'a block is required' unless block
+
+      Bridge.get.proxy(iface, &block)
+    end
+  end
+end

data/lib/pd4ml/pd4ml.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Pd4ml
+  # An HTML to PDF/DOCX/RTF/image converter: com.pd4ml.PD4ML with Ruby I/O and the v42 layout
+  # engine by default. Every Java method is available by its Java name or in Ruby style
+  # (`set_page_size`, `add_style`, `use_ttf`); these take Ruby I/O: read_html (a path, URL or
+  # binary String/IO), read_html_string, write_pdf/write_docx/write_rtf (the document returned as
+  # a binary String, or written to a path or IO), render_as_images and monitor_progress_with (a block).
+  #
+  #   pd = Pd4ml::PD4ML.new
+  #   pd.set_page_size(Pd4ml::PageSize::A4)
+  #   pd.read_html_string('<h1>Hello</h1>')
+  #   pdf = pd.write_pdf
+  class PD4ML
+    DEFAULT_ENGINE = 'v42'
+
+    @warned_no_engines = false
+    class << self
+      attr_accessor :warned_no_engines
+
+      # Static Java members: PD4ML.get_version / PD4ML.getVersion.
+      def method_missing(name, *args, &block)
+        java_class.respond_to?(name) ? java_class.public_send(name, *args, &block) : super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        java_class.respond_to?(name) || super
+      end
+
+      def java_class = Java.type('com.pd4ml.PD4ML')
+    end
+
+    # The Java object (com.pd4ml.PD4ML).
+    attr_reader :java
+    # The layout engine chosen ('v42', 'v40'), or nil for the build's own.
+    attr_reader :engine
+
+    # license: a license serial number or license file URL (default: pd4ml.lic on the classpath
+    # or in the working directory, else evaluation mode); html_width: the width in pixels the
+    # HTML is laid out in; engine: 'v42', 'v40' (or :v42, a LayoutEngine), default v42 where the
+    # build has layout engines, else the build's own; false: the Java default.
+    def initialize(license: nil, html_width: nil, engine: nil)
+      args = [license, html_width].compact
+      @java = Bridge.get.new_object('com.pd4ml.PD4ML', args)
+      @engine = nil
+      if engine.nil?
+        if Pd4ml.layout_engines?
+          engine = DEFAULT_ENGINE
+        else
+          engine = false
+          unless self.class.warned_no_engines
+            self.class.warned_no_engines = true
+            warn "PD4ML #{Pd4ml.version} has no #{DEFAULT_ENGINE} layout engine (from 4.2): its own engine is used"
+          end
+        end
+      end
+      use_html_renderer(engine) unless engine == false
+    end
+
+    # Java methods not defined here.
+    def method_missing(name, *args, &block)
+      return super if block
+
+      @java.__send__(name, *args)
+    end
+
+    def respond_to_missing?(_name, _include_private = false) = true
+
+    # ------------------------------------------------------------------------- layout engine
+
+    # Chooses the layout engine ('v42', 'v40', a LayoutEngine), optionally with the HTML width
+    # and engine parameters (a Hash).
+    def use_html_renderer(engine = DEFAULT_ENGINE, html_width: nil, params: nil)
+      unless Pd4ml.layout_engines?
+        raise "PD4ML #{Pd4ml.version} has no layout engines to choose from (Constants.LayoutEngine is new in 4.2)"
+      end
+
+      e = engine.is_a?(JavaObject) ? engine : Java.type('com.pd4ml.Constants$LayoutEngine').value_of(engine.to_s)
+      if params
+        @java.useHtmlRenderer(e, html_width || -1, params.to_h { |k, v| [k.to_s, v.to_s] })
+      elsif html_width
+        @java.useHtmlRenderer(e, html_width)
+      else
+        @java.useHtmlRenderer(e)
+      end
+      @engine = e.enum_name
+    end
+    alias useHtmlRenderer use_html_renderer
+
+    # --------------------------------------------------------------------------------- input
+
+    # Reads the document to convert: a URL ('https://...', 'file:...') or a local path (a String,
+    # Pathname or URI), its content (a binary String - File.binread - or an IO), or a Java
+    # URL/InputStream. base_url: where relative links resolve, for content (a URL or a local
+    # directory/file); encoding: the document's encoding when it does not declare one.
+    def read_html(source, base_url = nil, encoding = nil)
+      if location?(source)
+        url = Pd4ml.to_url(source)
+        encoding ? @java.readHTML(url, encoding) : @java.readHTML(url)
+        return
+      end
+      content = source.is_a?(JavaObject) ? source : Pd4ml.binary(source)
+      base = base_url && Pd4ml.to_url(base_url)
+      if base_url.nil? && encoding.nil?
+        @java.readHTML(content)
+      elsif encoding.nil?
+        @java.readHTML(content, base)
+      else
+        @java.readHTML(content, base, encoding)
+      end
+    end
+    alias readHTML read_html
+
+    # Reads the document from a String of HTML.
+    def read_html_string(html, base_url = nil)
+      read_html(html.to_s.encode(Encoding::UTF_8).b, base_url, 'UTF-8')
+    end
+    alias readHtmlString read_html_string
+
+    # -------------------------------------------------------------------------------- output
+
+    # Writes the PDF: to `target` (a path or an IO), or returned as a binary String. spec: a
+    # PdfSpec (PdfSpec::PDFA_2B), one of its keywords ('pdf/a-2b', see PdfSpec.list_keywords),
+    # or 'PDF'/'PDFA'/'PDFUA'.
+    def write_pdf(target = nil, spec: nil)
+      s = Pd4ml.pdf_spec(spec)
+      outs = []
+      Bridge.get.call(@java, 'writePDF', s.nil? ? [Output.new(0)] : [Output.new(0), s], outs)
+      Pd4ml.deliver(outs[0] || ''.b, target)
+    end
+    alias writePDF write_pdf
+
+    # Writes a DOCX document (see write_pdf for `target`).
+    def write_docx(target = nil)
+      outs = []
+      Bridge.get.call(@java, 'writeDOCX', [Output.new(0)], outs)
+      Pd4ml.deliver(outs[0] || ''.b, target)
+    end
+    alias writeDOCX write_docx
+
+    # Writes an RTF document; rtf_wmf: images as WMF (see write_pdf for `target`).
+    def write_rtf(target = nil, rtf_wmf: false)
+      outs = []
+      Bridge.get.call(@java, 'writeRTF', [Output.new(0), rtf_wmf], outs)
+      Pd4ml.deliver(outs[0] || ''.b, target)
+    end
+    alias writeRTF write_rtf
+
+    # render_as_images(format): the pages as encoded images (Constants::PNG24...), binary Strings;
+    # render_as_images(dir, name, format): image files written to a directory;
+    # render_as_images: Java BufferedImage objects.
+    def render_as_images(*args)
+      if args.size == 3 && (args[0].is_a?(String) || args[0].is_a?(Pathname))
+        FileUtils.mkdir_p(args[0].to_s)
+        return @java.renderAsImages(Java.type('java.io.File').new(File.expand_path(args[0].to_s)), args[1], args[2])
+      end
+      @java.renderAsImages(*args)
+    end
+    alias renderAsImages render_as_images
+
+    # The pages as 24-bit PNG images (binary Strings).
+    def render_png = @java.renderAsImages(Java.type('com.pd4ml.Constants')::PNG24)
+
+    # ------------------------------------------------------------------------------ progress
+
+    # Reports conversion progress to a block |message_id, progress, note, msec| - it runs on this
+    # thread while PD4ML works - or to a Java ProgressListener.
+    def monitor_progress_with(listener = nil, &block)
+      listener ||= Java.proxy('com.pd4ml.ProgressListener') do |_method, a|
+        block.call(a[0].to_i, a[1].to_i, a[2], a[3].to_i)
+      end
+      @java.monitorProgressWith(listener)
+    end
+    alias monitorProgressWith monitor_progress_with
+
+    private
+
+    def location?(source)
+      source.is_a?(Pathname) || source.is_a?(URI::Generic) ||
+        (source.is_a?(String) && source.encoding != Encoding::BINARY && !source.lstrip.start_with?('<')) ||
+        (source.is_a?(JavaObject) && source.java_class == 'java.net.URL')
+    end
+  end
+end

data/lib/pd4ml/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pd4ml
+  VERSION = '1.0.0'
+end