libpng 1.6.58.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 424bb2ec057dfcb24902b7d42a4ca73936d54cd30ca0cbdb81df8277a97d3ba1
+  data.tar.gz: f424a0836d9ce74aaccacd16ab7aa6cb60aee534576b25a72a4d22d9752b4adc
+SHA512:
+  metadata.gz: dd873ee26bb9b3a7e2c52cded5e501de1ed59bc1c1250132c60ef71ffdc99af9e5d6a09aa3399f5ddee3eff7a4ced98772fa3eb2f058076e7410e770bd0225ea
+  data.tar.gz: 40b078365a95aff0413904b94092eed3f76f6f0cc42dd637d5b16c1ee1d72fe2cb05c89ac9f0513f140591dc28ccbc84f997dc3f64ed0e03e53487dd04b9da70

data/.github/workflows/build.yml

@@ -0,0 +1,120 @@
+name: build
+
+on:
+  push:
+    branches: [ main ]
+    paths-ignore:
+      - '*.adoc'
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.job }}-${{ github.head_ref || github.ref_name }}'
+  cancel-in-progress: true
+
+jobs:
+  prepare:
+    uses: metanorma/ci/.github/workflows/prepare-rake.yml@main
+
+  test:
+    name: Test on Ruby ${{ matrix.ruby.version }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+
+    needs: prepare
+    if: needs.prepare.outputs.push-for-tag != 'true'
+
+    continue-on-error: ${{ matrix.ruby.experimental }}
+    strategy:
+      fail-fast: false
+      max-parallel: 5
+      matrix: ${{ fromJson(needs.prepare.outputs.matrix) }}
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - uses: ruby/setup-ruby@master
+      with:
+        bundler-cache: true
+        ruby-version: ${{ matrix.ruby.version }}
+        rubygems: ${{ matrix.ruby.rubygems }}
+
+    # libpng's CMake needs cmake >= 3.10 and a working zlib. Both are
+    # pre-installed on GitHub Actions runners; this is just a sanity check.
+    - name: Install build tools
+      if: startsWith(matrix.os, 'ubuntu')
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake ninja-build zlib1g-dev
+
+    - name: Install build tools (macOS)
+      if: startsWith(matrix.os, 'macos')
+      run: |
+        brew install cmake ninja
+
+    - name: Install build tools (Windows)
+      if: startsWith(matrix.os, 'windows')
+      uses: ilammy/msvc-dev-tools@v1
+
+    - run: bundle exec rake
+
+  build:
+    name: build ${{ matrix.os }}, ${{ matrix.ruby-version }}, ${{ matrix.platform }}
+    runs-on: ${{ matrix.os }}
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: any
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: ubuntu-latest
+            platform: x86_64-linux
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: windows-latest
+            platform: x64-mingw32
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: windows-latest
+            platform: x64-mingw-ucrt
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: macos-latest
+            platform: x86_64-darwin
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@master
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - name: Install build tools (Linux)
+      if: startsWith(matrix.os, 'ubuntu')
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake ninja-build zlib1g-dev
+
+    - name: Install build tools (macOS)
+      if: startsWith(matrix.os, 'macos')
+      run: |
+        brew install cmake ninja
+
+    - name: Install build tools (Windows)
+      if: startsWith(matrix.os, 'windows')
+      uses: ilammy/msvc-dev-tools@v1
+
+    - run: bundle exec rake gem:native:${{ matrix.platform }}
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: pkg-${{ matrix.platform }}
+        path: pkg/*.gem
+
+    - name: Install gem
+      run: gem install -b pkg/libpng-*.gem
+
+    - name: Test conversion
+      run: |
+        ruby -rlibpng -e "png = Libpng.encode(2, 2, \"\\xff\" * 16, pixel_format: 'RGBA'); File.binwrite('test.png', png); puts Libpng.decode(png, pixel_format: 'RGBA').inspect"

data/.github/workflows/release.yml

@@ -0,0 +1,249 @@
+name: release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      bump-type:
+        description: 'What to bump before tagging'
+        type: choice
+        options:
+          - current
+          - iteration
+          - libpng
+        default: iteration
+      libpng-version:
+        description: 'New libpng version (required when bump-type=libpng, e.g. 1.6.49)'
+        type: string
+        required: false
+
+# contents: write is needed for workflow_dispatch to push the bump commit + tag.
+# id-token: write is required for RubyGems.org Trusted Publishing (OIDC).
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  bump:
+    if: github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    outputs:
+      sha: ${{ steps.sha.outputs.sha }}
+      new-version: ${{ steps.bump.outputs.new-version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: '3.3'
+
+      - name: Bump version.rb
+        id: bump
+        shell: bash
+        env:
+          BUMP_TYPE: ${{ inputs.bump-type }}
+          LIBPNG_VERSION_INPUT: ${{ inputs.libpng-version }}
+        run: |
+          set -euo pipefail
+
+          if [[ "$BUMP_TYPE" == "current" ]]; then
+            NEW_VERSION=$(ruby -Ilib -rlibpng/version -e 'puts Libpng::VERSION')
+            echo "new-version=${NEW_VERSION}" >> "$GITHUB_OUTPUT"
+            echo "sha=${{ github.sha }}" >> "$GITHUB_OUTPUT"
+            echo "Releasing current VERSION (${NEW_VERSION}) -- no bump."
+            exit 0
+          fi
+
+          ruby <<'RUBY'
+            bump_type = ENV.fetch("BUMP_TYPE")
+            path = "lib/libpng/version.rb"
+            content = File.read(path)
+
+            case bump_type
+            when "iteration"
+              m = %r{LIBPNG_RUBY_ITERATION = (\d+)}.match(content) or
+                raise "Could not find LIBPNG_RUBY_ITERATION in #{path}"
+              content.sub!(%r{LIBPNG_RUBY_ITERATION = \d+},
+                           "LIBPNG_RUBY_ITERATION = #{m[1].to_i + 1}") or
+                raise "Failed to substitute iteration"
+            when "libpng"
+              new_v = ENV.fetch("LIBPNG_VERSION_INPUT", "")
+              raise "libpng-version input is required when bump-type=libpng" if new_v.empty?
+              raise "Invalid version format: #{new_v} (expected X.Y.Z)" unless new_v.match?(/\A\d+\.\d+\.\d+\z/)
+              content.sub!(%r{LIBPNG_VERSION = "[^"]+"},
+                           "LIBPNG_VERSION = \"#{new_v}\"") or
+                raise "Failed to substitute libpng version"
+              content.sub!(%r{LIBPNG_RUBY_ITERATION = \d+},
+                           "LIBPNG_RUBY_ITERATION = 0") or
+                raise "Failed to reset iteration"
+            else
+              raise "Unknown bump-type: #{bump_type}"
+            end
+
+            File.write(path, content)
+            load File.expand_path(path)
+            File.open(ENV.fetch("GITHUB_OUTPUT"), "a") do |f|
+              f.puts "new-version=#{Libpng::VERSION}"
+            end
+            warn "Bumped to #{Libpng::VERSION}"
+          RUBY
+
+          NEW_VERSION=$(ruby -Ilib -rlibpng/version -e 'puts Libpng::VERSION')
+          echo "new-version=${NEW_VERSION}" >> "$GITHUB_OUTPUT"
+
+          git config user.name  "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add lib/libpng/version.rb
+          git commit -m "Release v${NEW_VERSION}"
+          echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+
+      - name: Show what's being released
+        run: |
+          echo "Releasing version: ${{ steps.bump.outputs.new-version }}"
+          git --no-pager log --oneline -1 "${{ steps.bump.outputs.sha }}"
+
+      - name: Push bump commit + tag
+        env:
+          NEW_VERSION: ${{ steps.bump.outputs.new-version }}
+          SHA: ${{ steps.bump.outputs.sha }}
+        run: |
+          if [[ -n "${SHA}" && "${SHA}" != "${{ github.sha }}" ]]; then
+            git push origin "HEAD:${{ github.event.repository.default_branch }}"
+          fi
+          git tag "v${NEW_VERSION}" "${SHA}"
+          git push origin "v${NEW_VERSION}"
+
+  build:
+    needs: bump
+    if: always() && !cancelled() && !failure() && (needs.bump.result == 'success' || needs.bump.result == 'skipped')
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: any
+            ruby-version: '3.3'
+          - os: ubuntu-latest
+            platform: x86_64-linux
+            ruby-version: '3.3'
+          - os: windows-latest
+            platform: x64-mingw32
+            ruby-version: '3.3'
+          - os: windows-latest
+            platform: x64-mingw-ucrt
+            ruby-version: '3.3'
+          - os: macos-latest
+            platform: x86_64-darwin
+            ruby-version: '3.3'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.bump.outputs.sha || github.ref }}
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Install build tools (Linux)
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build zlib1g-dev
+
+      - name: Install build tools (macOS)
+        if: startsWith(matrix.os, 'macos')
+        run: |
+          brew install cmake ninja
+
+      - name: Install build tools (Windows)
+        if: startsWith(matrix.os, 'windows')
+        uses: ilammy/msvc-dev-tools@v1
+
+      - run: bundle exec rake gem:native:${{ matrix.platform }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pkg-${{ matrix.platform }}
+          path: pkg/*.gem
+
+      - name: Install gem
+        run: gem install -b pkg/libpng-*.gem
+
+      - name: Test conversion
+        run: |
+          ruby -rlibpng -e "png = Libpng.encode(2, 2, \"\\xff\" * 16, pixel_format: 'RGBA'); puts Libpng.decode(png, pixel_format: 'RGBA').inspect"
+
+  cross:
+    needs: bump
+    if: always() && !cancelled() && !failure() && (needs.bump.result == 'success' || needs.bump.result == 'skipped')
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: aarch64-linux
+            ruby-version: '3.3'
+          - os: macos-latest
+            platform: arm64-darwin
+            ruby-version: '3.3'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.bump.outputs.sha || github.ref }}
+
+      - name: Install Ubuntu cross-build packages
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu binutils-aarch64-linux-gnu cmake ninja-build zlib1g-dev:arm64
+
+      - name: Install macOS build packages
+        if: startsWith(matrix.os, 'macos')
+        run: brew install cmake ninja
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - run: bundle exec rake gem:native:${{ matrix.platform }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pkg-${{ matrix.platform }}
+          path: pkg/*.gem
+
+      - name: Install gem
+        run: gem install -b pkg/libpng-*.gem
+
+  publish:
+    needs: [ bump, build, cross ]
+    if: always() && !cancelled() && !failure()
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.bump.outputs.sha || github.ref }}
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: pkg-*
+          path: pkg
+          merge-multiple: true
+
+      - name: Configure RubyGems credentials (Trusted Publishing / OIDC)
+        uses: rubygems/configure-rubygems-credentials@main
+
+      - name: Publish to rubygems.org
+        run: |
+          for gem in pkg/*.gem; do gem push -V "$gem"; done

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/ports/
+/lib/libpng/*.so
+/lib/libpng/*.so.*
+/lib/libpng/*.dylib
+/lib/libpng/*.dll
+/.idea/
+/.vscode/
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+RSpec
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,39 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.7
+  SuggestExtensions: false
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+# The wrapper is by nature a single file with FFI declarations + several
+# methods that walk libpng's chunked API; splitting would obscure the
+# 1-to-1 mapping with the C API.
+Metrics/AbcSize:
+  Max: 60
+Metrics/ClassLength:
+  Max: 200
+Metrics/CyclomaticComplexity:
+  Max: 20
+Metrics/MethodLength:
+  Max: 50
+Metrics/ModuleLength:
+  Max: 250
+Metrics/PerceivedComplexity:
+  Max: 20
+Metrics/ParameterLists:
+  Max: 7
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+    - Rakefile
+    - libpng.gemspec
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - ext/extconf.rb
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - ext/extconf.rb
+    - lib/libpng/recipe.rb

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rake', '~> 13.0'
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.65', require: false
+  gem 'rubocop-performance', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2026 Ribose Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+This gem bundles pre-compiled binaries of libpng, which is itself
+distributed under the libpng license (see the upstream LICENSE file
+in https://github.com/pnggroup/libpng for details).

data/README.adoc

@@ -0,0 +1,108 @@
+= libpng: pre-compiled libpng for Ruby
+
+image:https://img.shields.io/badge/Ruby-%3E%3D%202.7.0-ruby.svg[Ruby]
+image:https://img.shields.io/badge/license-BSD--2--Clause-blue.svg[License]
+
+`libpng` is a Ruby binding for the official PNG reference library
+(https://github.com/pnggroup/libpng[libpng]). The native shared library
+is pre-compiled for each target platform and shipped inside the gem, so
+`gem install libpng` Just Works without a C compiler on the host.
+
+== Installation
+
+Add to your Gemfile:
+
+  gem "libpng"
+
+Then:
+
+  bundle install
+
+Or install manually:
+
+  gem install libpng
+
+The gem downloads a pre-compiled binary for your platform automatically.
+No C compiler, libpng development headers, or system packages are needed
+at install time.
+
+== Usage
+
+  require "libpng"
+
+  # Encode raw RGBA pixels (row-major, top-down) as a PNG.
+  png = Libpng.encode(width, height, rgba_bytes, pixel_format: "RGBA")
+  File.binwrite("out.png", png)
+
+  # Decode a PNG into raw pixels.
+  decoded = Libpng.decode(File.binread("out.png"), pixel_format: "RGBA")
+  decoded.width   # => Integer
+  decoded.height  # => Integer
+  decoded.format  # => "RGBA"
+  decoded.pixels  # => binary String of RGBA bytes
+
+=== Supported pixel formats
+
+- `"GRAY"` / `"GRAYSCALE"` -- 8-bit grayscale (1 byte/pixel)
+- `"GA"` / `"AG"` -- 8-bit grayscale + alpha (2 bytes/pixel)
+- `"RGB"`, `"BGR"` -- 8-bit truecolor (3 bytes/pixel)
+- `"RGBA"`, `"ARGB"`, `"BGRA"`, `"ABGR"` -- 8-bit truecolor + alpha (4 bytes/pixel)
+
+=== Encoding options
+
+  Libpng.encode(width, height, pixels,
+                pixel_format: "RGBA",
+                convert_to_8bit: false)
+
+`convert_to_8bit: true` causes libpng to convert 16-bit input to 8-bit
+on write (input is still passed as a packed byte buffer; use this if you
+have packed 16-bit-per-channel data).
+
+== Ractor safety
+
+`Libpng.encode` and `Libpng.decode` are Ractor-safe. Every call
+allocates and frees its own libpng `png_image`; no shared mutable state
+exists on the Ruby side. Calls from multiple Ractors run concurrently
+without locking.
+
+Example:
+
+  r = Ractor.new do
+    Libpng.encode(2, 2, "\xFF" * 16, pixel_format: "RGBA")
+  end
+  r.take  # => PNG binary
+
+== Versioning
+
+This gem follows a `{LIBPNG_VERSION}.{ITERATION}` scheme:
+
+- `LIBPNG_VERSION` is the upstream libpng release the gem is built
+  against (currently 1.6.48).
+- `ITERATION` is a counter that bumps on Ruby-side changes (recipe bug
+  fixes, CI tweaks, doc updates). It resets to 0 each time
+  `LIBPNG_VERSION` bumps.
+
+For example, `1.6.48.0` is the first release against libpng 1.6.48,
+`1.6.48.1` is a Ruby-side fix, and `1.6.49.0` would be a release against
+the next upstream libpng.
+
+== How it works
+
+The gem has three layers:
+
+1. `lib/libpng.rb` -- Ruby FFI wrapper. Loads `libpng16.{so,dylib,dll}`
+   from the gem's `lib/libpng/` directory at runtime.
+2. `lib/libpng/recipe.rb` -- a MiniPortileCMake recipe that downloads
+   the libpng source tarball and runs CMake to produce the shared
+   library. This is invoked by `ext/extconf.rb` when the gem is installed
+   from source.
+3. `Rakefile` defines `gem:native:<platform>` tasks that pre-compile
+   the gem for each target platform. The pre-compiled gems bundle the
+   `.so`/`.dylib`/`.dll` and disable `extconf.rb`, so installation
+   requires no C compiler.
+
+== License
+
+BSD-2-Clause; see link:LICENSE.txt[LICENSE.txt]. The gem bundles
+pre-compiled libpng binaries; libpng itself is distributed under the
+https://github.com/pnggroup/libpng/blob/main/LICENSE[libpng license].

data/Rakefile

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+task :compile do
+  require_relative 'ext/extconf'
+end
+
+task spec: :compile
+
+desc 'Build install-compilation gem'
+task 'gem:native:any' do
+  sh 'rake platform:any gem'
+end
+
+require 'rubygems/package_task'
+
+desc 'Define the gem task to build on any platform (compile on install)'
+task 'platform:any' do
+  spec = Gem::Specification.load('libpng.gemspec').dup
+  task = Gem::PackageTask.new(spec)
+  task.define
+end
+
+platforms = %w[
+  x64-mingw32
+  x64-mingw-ucrt
+  x86_64-linux
+  aarch64-linux
+  x86_64-darwin
+  arm64-darwin
+]
+
+platforms.each do |platform|
+  desc "Build pre-compiled gem for the #{platform} platform"
+  task "gem:native:#{platform}" do
+    sh "rake compile platform:#{platform} gem target_platform=#{platform}"
+  end
+
+  desc "Define the gem task to build on the #{platform} platform (binary gem)"
+  task "platform:#{platform}" do
+    spec = Gem::Specification.load('libpng.gemspec').dup
+    spec.platform = Gem::Platform.new(platform)
+    spec.files += Dir.glob('lib/libpng/*.{dll,so,dylib}')
+    spec.extensions = []
+    spec.dependencies.reject! { |d| d.name == 'mini_portile2' }
+
+    task = Gem::PackageTask.new(spec)
+    task.define
+  end
+end
+
+require 'rake/clean'
+
+CLOBBER.include('pkg')
+CLEAN.include('ports',
+              'tmp',
+              'lib/libpng/*.dll',
+              'lib/libpng/*.dylib',
+              'lib/libpng/*.so',
+              'lib/libpng/*.so.*')

data/bin/console

@@ -0,0 +1,5 @@
+#!/bin/sh
+# frozen_string_literal: true
+
+# Console entry point for the libpng gem.
+exec ruby -Ilib -rlibpng -e 'puts "Libpng #{Libpng::VERSION} loaded"; binding.irb' "$@"

data/bin/setup

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'libpng'

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
+
+require 'libpng/recipe'
+
+recipe = Libpng::Recipe.new
+recipe.cook_if_not

data/lib/libpng/recipe.rb

@@ -0,0 +1,182 @@
+require 'rbconfig'
+require 'mini_portile2'
+require 'pathname'
+require 'tmpdir'
+require 'open3'
+require_relative 'version'
+
+module Libpng
+  # MiniPortile-based recipe for building libpng from source. Mirrors the
+  # pattern used by emf2svg-ruby: during `gem install`, ext/extconf.rb
+  # invokes Recipe#cook, which downloads the libpng source tarball, runs
+  # configure + make, and installs the shared library into the gem's lib/
+  # directory. The pre-compiled gems (built via `rake gem:native:<plat>`)
+  # ship the .so/.dylib/.dll and disable extconf.rb entirely.
+  class Recipe < MiniPortileCMake
+    # Pinned libpng source URL + sha256. Bump deliberately to refresh
+    # the upstream — and remember to update both fields together.
+    LIBPNG_URL = "https://downloads.sourceforge.net/project/libpng/libpng16/#{Libpng::LIBPNG_VERSION}/libpng-#{Libpng::LIBPNG_VERSION}.tar.gz".freeze
+    # sha256 of the libpng-X.Y.Z.tar.gz tarball. Verify with:
+    #   curl -sL <URL> | shasum -a 256
+    LIBPNG_SHA256 = '8c9b05b675ca7301a458df2c2e46f26e1d41ff36b8863f8c33530bc58c2e6225'.freeze
+
+    ROOT = Pathname.new(File.expand_path('../..', __dir__))
+
+    def initialize
+      super('libpng', Libpng::LIBPNG_VERSION)
+
+      @files << {
+        url: LIBPNG_URL,
+        sha256: LIBPNG_SHA256
+      }
+
+      @target = ROOT.join(@target).to_s
+      @printed = {}
+    end
+
+    # libpng ships a CMake build alongside the autotools one. We use CMake
+    # for consistency with mini_portile2's defaults and to handle Windows
+    # cleanly (autotools on native Windows is fragile).
+    # No additional configuration is needed; defaults build PNG_SHARED=ON
+    # and PNG_STATIC=OFF, which is what we want.
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+      FileUtils.touch(checkpoint)
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{target_platform}.installed")
+    end
+
+    def configure_defaults
+      # Build a static+self-contained shared library: we only ship the .so
+      # to consumers, so libpng's transitive dep on zlib must be linked in.
+      opts = super
+      opts << '-DPNG_SHARED=ON'
+      opts << '-DPNG_STATIC=OFF'
+      opts << '-DPNG_TESTS=OFF'
+      opts << '-DPNG_FRAMEWORK=OFF'
+      # macOS: avoid the .framework build; we want a plain .dylib.
+      opts << '-DCMAKE_INSTALL_LIBDIR=lib'
+      opts << '-DCMAKE_BUILD_TYPE=Release'
+      opts
+    end
+
+    def install
+      super
+      # After `make install`, the .so/.dylib/.dll is under ports/<name>/<ver>/lib/.
+      # Copy it into the gem's lib/libpng/ so FFI can load it at runtime.
+      libs = Dir.glob(File.join(port_path, 'lib', shared_lib_glob))
+      raise "no libpng shared lib produced at #{port_path}/lib" if libs.empty?
+
+      target_dir = ROOT.join('lib', 'libpng')
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp_r(libs, target_dir, verbose: true)
+
+      verify_libs
+    end
+
+    def verify_libs
+      each_built_lib do |path|
+        out, st = Open3.capture2("file #{path}")
+        raise "Failed to query file #{path}: #{out}" unless st.exitstatus.zero?
+
+        next if target_format.eql?('skip')
+
+        raise "Invalid file format '#{out}', /#{target_format.source}/ expected" unless target_format.match?(out)
+
+        message("Verifying #{path} ... OK\n")
+      end
+    end
+
+    def execute(action, command, command_opts = {})
+      super(action, command, command_opts.merge(debug: false))
+    end
+
+    def message(text)
+      return super unless text.start_with?("\rDownloading")
+
+      match = text.match(/(\rDownloading .*)\(\s*\d+%\)/)
+      pattern = match ? match[1] : text
+      return if @printed[pattern]
+
+      @printed[pattern] = true
+      super
+    end
+
+    private
+
+    def port_path
+      File.join(@target, 'ports', "#{name}-#{version}") # MiniPortile default
+    end
+
+    def shared_lib_glob
+      if MiniPortile.windows?
+        'libpng16*.dll'
+      elsif MiniPortile.darwin?
+        'libpng16*.dylib'
+      else
+        'libpng16.so*'
+      end
+    end
+
+    def each_built_lib(&block)
+      Dir.glob(ROOT.join('lib', 'libpng', shared_lib_glob)).each(&block)
+    end
+
+    def host_platform
+      @host_platform ||=
+        case @host
+        when /\Ax86_64.*mingw32/
+          'x64-mingw32'
+        when /\Ax86_64.*linux/
+          'x86_64-linux'
+        when /\A(arm64|aarch64).*linux/
+          'arm64-linux'
+        when /\Ax86_64.*(darwin|macos|osx)/
+          'x86_64-darwin'
+        when /\A(arm64|aarch64).*(darwin|macos|osx)/
+          'arm64-darwin'
+        else
+          @host
+        end
+    end
+
+    def target_platform
+      @target_platform ||=
+        case ENV.fetch('target_platform', nil)
+        when /\A(arm64|aarch64).*(darwin|macos|osx)/
+          'arm64-darwin'
+        when /\Ax86_64.*(darwin|macos|osx)/
+          'x86_64-darwin'
+        when /\A(arm64|aarch64).*linux/
+          'aarch64-linux'
+        else
+          ENV.fetch('target_platform', host_platform)
+        end
+    end
+
+    def target_format
+      @target_format ||=
+        case target_platform
+        when 'arm64-darwin'
+          /Mach-O 64-bit dynamically linked shared library arm64/
+        when 'x86_64-darwin'
+          /Mach-O 64-bit dynamically linked shared library x86_64/
+        when 'aarch64-linux'
+          /ELF 64-bit LSB shared object, ARM aarch64/
+        when 'x86_64-linux'
+          /ELF 64-bit LSB shared object, x86-64/
+        when /\Ax64-mingw(32|-ucrt)/
+          /PE32\+ executable.*\(DLL\).*x86-64/
+        else
+          'skip'
+        end
+    end
+  end
+end

data/lib/libpng/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Libpng
+  # Gem version follows the pattern:
+  #
+  #   {LIBPNG_VERSION}.{LIBPNG_RUBY_ITERATION}
+  #
+  # where LIBPNG_VERSION is the upstream libpng release this gem is
+  # built against, and LIBPNG_RUBY_ITERATION is a counter for Ruby-side
+  # changes (recipe bug fixes, CI changes, docs) that bump without a
+  # new libpng release. The iteration resets to 0 each time
+  # LIBPNG_VERSION bumps.
+  LIBPNG_VERSION = '1.6.58'
+  LIBPNG_RUBY_ITERATION = 0
+  VERSION = "#{LIBPNG_VERSION}.#{LIBPNG_RUBY_ITERATION}"
+end

data/lib/libpng.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'zlib'
+require_relative 'libpng/version'
+
+# Libpng is a Ruby binding for libpng (the official PNG reference library)
+# via FFI. The native library is pre-compiled for each target platform and
+# shipped inside the gem, so no C compiler is required at install time.
+#
+# The API mirrors libpng's "simplified" high-level API:
+#
+#   Libpng.encode(width, height, rgba_bytes, pixel_format: "RGBA")
+#   Libpng.decode(png_bytes, pixel_format: "RGBA")
+#
+# All encode/decode state is per-call (libpng allocates and frees a
+# png_image internally), so calls from different Ractors do not share
+# state. The module's FFI function table is frozen at load time.
+module Libpng
+  class Error < StandardError; end
+
+  extend FFI::Library
+
+  ffi_lib_flags :now, :global
+
+  lib_filename = if FFI::Platform.windows?
+                   'libpng16.dll'
+                 elsif FFI::Platform.mac?
+                   'libpng16.dylib'
+                 else
+                   'libpng16.so'
+                 end
+
+  ffi_lib File.expand_path("libpng/#{lib_filename}", __dir__)
+              .gsub('/', File::ALT_SEPARATOR || File::SEPARATOR)
+
+  # libpng simplified API (png_image / png_image_*). All return int
+  # (1 on success, 0 on failure); the png_image's message buffer holds
+  # the error string on failure.
+  attach_function :png_image_begin_read_from_memory,
+                  %i[pointer pointer size_t], :int
+  attach_function :png_image_finish_read,
+                  %i[pointer pointer pointer int pointer], :int
+  attach_function :png_image_write_to_memory,
+                  %i[pointer pointer pointer int pointer int pointer], :int
+  attach_function :png_image_free, [:pointer], :void
+
+  # PNG_IMAGE_FORMAT_* bit flags and named formats from png.h.
+  FORMAT_FLAG_ALPHA = 0x01
+  FORMAT_FLAG_COLOR = 0x02
+  FORMAT_FLAG_LINEAR = 0x04
+  FORMAT_FLAG_COLORMAP = 0x08
+  FORMAT_FLAG_BGR = 0x10
+  FORMAT_FLAG_AFIRST = 0x20
+  FORMAT_FLAG_ASSOCIATED_ALPHA = 0x40
+
+  FORMAT_GRAY = 0
+  FORMAT_GA = FORMAT_FLAG_ALPHA
+  FORMAT_AG = FORMAT_FLAG_ALPHA | FORMAT_FLAG_AFIRST
+  FORMAT_RGB = FORMAT_FLAG_COLOR
+  FORMAT_BGR = FORMAT_FLAG_COLOR | FORMAT_FLAG_BGR
+  FORMAT_RGBA = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA
+  FORMAT_ARGB = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA | FORMAT_FLAG_AFIRST
+  FORMAT_BGRA = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA | FORMAT_FLAG_BGR
+  FORMAT_ABGR = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA | FORMAT_FLAG_AFIRST | FORMAT_FLAG_BGR
+
+  FORMAT_BY_NAME = {
+    'GRAY' => FORMAT_GRAY,
+    'GRAYSCALE' => FORMAT_GRAY,
+    'GA' => FORMAT_GA,
+    'AG' => FORMAT_AG,
+    'RGB' => FORMAT_RGB,
+    'BGR' => FORMAT_BGR,
+    'RGBA' => FORMAT_RGBA,
+    'ARGB' => FORMAT_ARGB,
+    'BGRA' => FORMAT_BGRA,
+    'ABGR' => FORMAT_ABGR
+  }.freeze
+
+  # png_image::version value libpng checks for. Defined in png.h as
+  # PNG_IMAGE_VERSION == 1.
+  PNG_IMAGE_VERSION = 1
+
+  # Buffer size for libpng's per-image error message (PNG_IMAGE_MESSAGE_BYTES).
+  # The png_image struct stores a fixed-size char buffer of this length.
+  PNG_IMAGE_MESSAGE_BYTES = 64
+
+  # png_image struct field offsets (bytes). png_image is laid out as:
+  #   void*       opaque             (pointer-width)
+  #   png_uint_32 version            (uint32)
+  #   png_uint_32 width              (uint32)
+  #   png_uint_32 height             (uint32)
+  #   png_uint_32 format             (uint32)
+  #   png_uint_32 flags              (uint32)
+  #   png_uint_32 colormap_entries   (uint32)
+  #   png_uint_32 warning_or_error   (uint32)
+  #   char[64]    message
+  # Total = pointer-size + 7*4 + 64. The fixed width makes it safe to
+  # allocate via FFI::MemoryPointer directly so the wrapper stays
+  # Ractor-safe (FFI::Struct has class-level state that isn't shareable
+  # across non-main Ractors).
+  PNG_IMAGE_SIZE = FFI.type_size(:pointer) + (7 * 4) + PNG_IMAGE_MESSAGE_BYTES
+  PNG_IMAGE_OFF_OPAQUE = 0
+  PNG_IMAGE_OFF_VERSION = FFI.type_size(:pointer)
+  PNG_IMAGE_OFF_WIDTH = PNG_IMAGE_OFF_VERSION + 4
+  PNG_IMAGE_OFF_HEIGHT = PNG_IMAGE_OFF_WIDTH + 4
+  PNG_IMAGE_OFF_FORMAT = PNG_IMAGE_OFF_HEIGHT + 4
+  PNG_IMAGE_OFF_FLAGS = PNG_IMAGE_OFF_FORMAT + 4
+  PNG_IMAGE_OFF_COLORMAP_ENTRIES = PNG_IMAGE_OFF_FLAGS + 4
+  PNG_IMAGE_OFF_WARNING_OR_ERROR = PNG_IMAGE_OFF_COLORMAP_ENTRIES + 4
+  PNG_IMAGE_OFF_MESSAGE = PNG_IMAGE_OFF_WARNING_OR_ERROR + 4
+
+  # Result struct for Libpng.decode (returned as a plain Hash for simplicity).
+  DecodedImage = Struct.new(:width, :height, :format, :pixels, keyword_init: true)
+
+  class << self
+    # Encode raw pixel data as a PNG.
+    #
+    # +width+, +height+    image dimensions in pixels
+    # +pixels+             String of raw pixel bytes (row-major, top-down)
+    # +pixel_format+       "RGB", "RGBA", "GRAY", "GA", "BGR", "BGRA"
+    #                      (default: "RGBA")
+    # +convert_to_8bit+    when true, libpng converts 16-bit input to 8-bit
+    #                      on write (default: false)
+    # +strip_colorspace+   when true, removes any sRGB/gAMA/cHRM/iCCP chunks
+    #                      libpng's simplified API emits by default, leaving
+    #                      only IHDR, IDAT, and IEND. This matches the
+    #                      "classic" libpng write path (e.g. libemf2svg) and
+    #                      produces byte-identical output. Default: true.
+    #
+    # Returns a String containing the PNG file bytes. Raises Libpng::Error
+    # on failure (bad dimensions, insufficient input bytes, invalid
+    # pixel_format, or libpng-internal error).
+    #
+    # Ractor-safe: every call allocates and frees its own png_image; no
+    # shared mutable state.
+    def encode(width, height, pixels, pixel_format: 'RGBA',
+               convert_to_8bit: false, strip_colorspace: true)
+      raw = encode_ancillary(width, height, pixels,
+                             pixel_format: pixel_format,
+                             convert_to_8bit: convert_to_8bit)
+      strip_colorspace ? strip_ancillary_chunks(raw) : raw
+    end
+
+    # Decode a PNG file into raw pixels.
+    #
+    # +png+           String containing PNG file bytes
+    # +pixel_format+  desired output format ("RGB", "RGBA", "GRAY", etc.)
+    #                 (default: "RGBA")
+    #
+    # Returns a DecodedImage Struct with #width, #height, #format (String),
+    # and #pixels (binary String).
+    #
+    # Ractor-safe: same reason as encode.
+    def decode(png, pixel_format: 'RGBA')
+      fmt = FORMAT_BY_NAME[pixel_format.to_s.upcase] ||
+            raise(Error, "unknown pixel_format #{pixel_format.inspect}")
+
+      img = FFI::MemoryPointer.new(:uint8, PNG_IMAGE_SIZE)
+      img.clear
+      img.put_uint32(PNG_IMAGE_OFF_VERSION, PNG_IMAGE_VERSION)
+
+      begin
+        FFI::MemoryPointer.new(:uint8, png.bytesize) do |in_buf|
+          in_buf.write_bytes(png)
+          ok = png_image_begin_read_from_memory(img, in_buf, png.bytesize)
+          if ok.zero?
+            msg = read_message(img)
+            raise Error, "png_image_begin_read_from_memory failed: #{msg}"
+          end
+
+          img.put_uint32(PNG_IMAGE_OFF_FORMAT, fmt)
+          width = img.get_uint32(PNG_IMAGE_OFF_WIDTH)
+          height = img.get_uint32(PNG_IMAGE_OFF_HEIGHT)
+          stride = width * bytes_per_pixel_for_format(fmt)
+          out_size = stride * height
+
+          FFI::MemoryPointer.new(:uint8, out_size) do |out_buf|
+            ok = png_image_finish_read(img, nil, out_buf, stride, nil)
+            if ok.zero?
+              msg = read_message(img)
+              raise Error, "png_image_finish_read failed: #{msg}"
+            end
+            return DecodedImage.new(width: width,
+                                    height: height,
+                                    format: pixel_format.to_s.upcase,
+                                    pixels: out_buf.read_bytes(out_size))
+          end
+        end
+      ensure
+        png_image_free(img)
+      end
+    end
+
+    private
+
+    # Lower-level encode that produces the raw libpng output (with sRGB
+    # or gAMA chunks depending on libpng's defaults). Public #encode strips
+    # these by default to match the classic libpng write path.
+    def encode_ancillary(width, height, pixels, pixel_format:, convert_to_8bit:)
+      raise Error, 'width must be positive' unless width.positive?
+      raise Error, 'height must be positive' unless height.positive?
+
+      fmt = FORMAT_BY_NAME[pixel_format.to_s.upcase] ||
+            raise(Error, "unknown pixel_format #{pixel_format.inspect}")
+
+      bytes_per_pixel = bytes_per_pixel_for_format(fmt)
+      stride = width * bytes_per_pixel
+      expected = stride * height
+      raise Error, "pixels too short: expected #{expected}, got #{pixels.bytesize}" if pixels.bytesize < expected
+
+      img = FFI::MemoryPointer.new(:uint8, PNG_IMAGE_SIZE)
+      img.clear
+      img.put_uint32(PNG_IMAGE_OFF_VERSION, PNG_IMAGE_VERSION)
+      img.put_uint32(PNG_IMAGE_OFF_WIDTH, width)
+      img.put_uint32(PNG_IMAGE_OFF_HEIGHT, height)
+      img.put_uint32(PNG_IMAGE_OFF_FORMAT, fmt)
+
+      out_len_ptr = FFI::MemoryPointer.new(:size_t, 1)
+      ok = png_image_write_to_memory(img, nil, out_len_ptr,
+                                     convert_to_8bit ? 1 : 0,
+                                     pixels, stride, nil)
+      if ok.zero?
+        msg = read_message(img)
+        png_image_free(img)
+        raise Error, "png_image_write_to_memory (size query) failed: #{msg}"
+      end
+
+      out_len = out_len_ptr.read_uint64
+      raise Error, 'libpng reported zero-length PNG output' if out_len.zero?
+
+      buffer = FFI::MemoryPointer.new(:uint8, out_len)
+      ok = png_image_write_to_memory(img, buffer, out_len_ptr,
+                                     convert_to_8bit ? 1 : 0,
+                                     pixels, stride, nil)
+      if ok.zero?
+        msg = read_message(img)
+        png_image_free(img)
+        raise Error, "png_image_write_to_memory (write) failed: #{msg}"
+      end
+
+      result = buffer.read_bytes(out_len)
+      png_image_free(img)
+      result
+    end
+
+    # Walk the PNG chunk list, keeping only IHDR, IDAT, and IEND. The PNG
+    # signature (8 bytes) is preserved. We do NOT need to recompute CRCs —
+    # the simplified API's emitted chunks (including the ones we drop) are
+    # all correctly CRCd; we only need to walk the chunk list and keep the
+    # ones we want, byte-for-byte.
+    def strip_ancillary_chunks(png_bytes)
+      sig = png_bytes.bytes[0, 8]
+      raise Error, 'not a PNG file (bad signature)' unless sig == [137, 80, 78, 71, 13, 10, 26, 10]
+
+      kept = sig.pack('C*')
+      offset = 8
+      while offset + 8 <= png_bytes.bytesize
+        len = png_bytes.bytes[offset, 4].pack('C*').unpack1('N')
+        type = png_bytes.bytes[offset + 4, 4].pack('C*')
+        chunk_total = 12 + len
+        raise Error, "PNG chunk at offset #{offset} runs past EOF" if offset + chunk_total > png_bytes.bytesize
+
+        crc_input = png_bytes.bytes[offset + 4, 4 + len].pack('C*')
+        crc_actual = png_bytes.bytes[offset + 8 + len, 4].pack('C*').unpack1('N')
+        crc_expected = Zlib.crc32(crc_input)
+        raise Error, "PNG chunk CRC mismatch at offset #{offset} (#{type})" unless crc_actual == crc_expected
+
+        kept << png_bytes.bytes[offset, chunk_total].pack('C*') if %w[IHDR IDAT IEND].include?(type)
+        offset += chunk_total
+        break if type == 'IEND'
+      end
+      kept.force_encoding('ASCII-8BIT')
+    end
+
+    def read_message(img)
+      # img[:message] is an Array field (char[64]); FFI returns a
+      # CharArray, which doesn't respond to .null? but does support to_ptr
+      # and to_s.
+
+      s = img[:message].to_s
+      s.empty? ? '(no message)' : s.force_encoding('UTF-8')
+    rescue StandardError
+      '(no message)'
+    end
+
+    def bytes_per_pixel_for_format(fmt)
+      case fmt
+      when FORMAT_GRAY then 1
+      when FORMAT_GA, FORMAT_AG then 2
+      when FORMAT_RGB, FORMAT_BGR then 3
+      when FORMAT_RGBA, FORMAT_ARGB, FORMAT_BGRA, FORMAT_ABGR then 4
+      else raise Error, "no bytes-per-pixel mapping for format 0x#{fmt.to_s(16)}"
+      end
+    end
+  end
+end

data/libpng.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'lib/libpng/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'libpng'
+  spec.version       = Libpng::VERSION
+  spec.authors       = ['Ribose Inc.']
+  spec.email         = ['open.source@ribose.com']
+
+  spec.summary       = 'libpng for Ruby (pre-compiled, FFI-based).'
+  spec.description   = 'Ruby binding for libpng via FFI. The native ' \
+                       'libpng16 shared library is pre-compiled for ' \
+                       'each target platform and shipped inside the ' \
+                       'gem, so no C compiler is required at install time.'
+  spec.homepage      = 'https://github.com/claricle/libpng-ruby'
+  spec.license       = 'BSD-2-Clause'
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/README.adoc#versioning"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features|tmp|ports)/})
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ffi', '~> 1.0'
+  spec.add_dependency 'mini_portile2', '~> 2.6'
+
+  spec.extensions = ['ext/extconf.rb']
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: libpng
+version: !ruby/object:Gem::Version
+  version: 1.6.58.0
+platform: ruby
+authors:
+- Ribose Inc.
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mini_portile2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Ruby binding for libpng via FFI. The native libpng16 shared library is
+  pre-compiled for each target platform and shipped inside the gem, so no C compiler
+  is required at install time.
+email:
+- open.source@ribose.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".github/workflows/build.yml"
+- ".github/workflows/release.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.adoc
+- Rakefile
+- bin/console
+- bin/setup
+- ext/extconf.rb
+- lib/libpng.rb
+- lib/libpng/recipe.rb
+- lib/libpng/version.rb
+- libpng.gemspec
+homepage: https://github.com/claricle/libpng-ruby
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/claricle/libpng-ruby
+  source_code_uri: https://github.com/claricle/libpng-ruby
+  changelog_uri: https://github.com/claricle/libpng-ruby/blob/main/README.adoc#versioning
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: libpng for Ruby (pre-compiled, FFI-based).
+test_files: []