sass-embedded 1.83.4 → 1.85.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2779af1e4b4b8994dc7cb041657aeb55af947f387fd30a6f9e41407c0166f8d0
-  data.tar.gz: fe9fa40596a2465ed7eabbe17e62bc42e882474fb34d37999214ca4606fb545a
+  metadata.gz: 53d0f1a6a02fe07581f2497fd69e21216a3a1e8bfd7d23643bd274595df73b41
+  data.tar.gz: 4b7687eb3bafd4cc21d5e473b3d6681c0f89b9aef84b457a09f6cafe6cfdd37c
 SHA512:
-  metadata.gz: dcc32242410a35d3ab99fde179f1cd0e2da3b37526dd1e038113bd675ce2bf16904e8e207719f0faef78b40de8592af9e34a1663a209828b3814629c3bf93420
-  data.tar.gz: 57d324ae11da9cb8a5057fbc7cccc1a75aabb85cd3c37ff4bf9ff6bc0e4c76aeef7ea882da92b79f625098024d41efe0168ef1549efb20b830aeb5f205226fe3
+  metadata.gz: 2e89874966d20a22859c41b946ea32d0591fa2f4d5292c393d0ad515eec1e8d29d9153c6bde2411db78ab939d1d27ed50c579aa325bf80ae5f10eed7ff8924b2
+  data.tar.gz: c7e8ba0b9346c455c659c64305677da630004ee6337e3ab69c07a2804c690422a0d943a63000875c42b4e0a3705963e64424bd50193ca29ff7e5305b85fc7b26

data/ext/sass/Rakefile

@@ -2,6 +2,10 @@
 
 require 'rake/clean'
 
+require_relative '../../lib/sass/elf'
+
+ELF = Sass.const_get(:ELF)
+
 task default: %i[install clean]
 
 task install: %w[cli.rb] do
@@ -11,6 +15,7 @@ end
 CLEAN.include %w[
   protoc.exe
   ruby
+  true
   *.proto
   *.tar.gz
   *.zip
@@ -70,8 +75,6 @@ rescue NotImplementedError
 end
 
 file 'cli.rb' => %w[dart-sass] do |t|
-  require_relative '../../lib/sass/elf'
-
   begin
     exe = 'dart-sass/sass'
     exe = "#{exe}#{['', '.bat', '.exe'].find { |ext| File.exist?("#{exe}#{ext}") }}"
@@ -89,7 +92,7 @@ file 'cli.rb' => %w[dart-sass] do |t|
               end
 
     interpreter = File.open(command[0], 'rb') do |file|
-      Sass.const_get(:ELF).new(file).interpreter
+      ELF.new(file).interpreter
     rescue ArgumentError
       nil
     end
@@ -158,6 +161,128 @@ rule '_pb.rb' => %w[.proto protoc.exe] do |t|
   sh './protoc.exe', '--proto_path=.', '--ruby_out=.', t.source
 end
 
+file 'true' do |t|
+  case Platform::CPU
+  when 'aarch64'
+    ei_class  = ELF::ELFCLASS64
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0xb7
+    e_flags   = 0
+
+    # 0000000000400078 <PT_LOAD#0>:
+    #   400078: d2800ba8     	mov	x8, #0x5d               // =93
+    #   40007c: d2800000     	mov	x0, #0x0                // =0
+    #   400080: d4000001     	svc	#0
+    entry_point = [0xd2800ba8, 0xd2800000, 0xd4000001].pack('L<3')
+  when 'arm'
+    ei_class  = ELF::ELFCLASS32
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0x28
+    e_flags   = 0x5000400
+
+    # 00400054 <PT_LOAD#0>:
+    #   400054: 2701         	movs	r7, #0x1
+    #   400056: 2000         	movs	r0, #0x0
+    #   400058: df00         	svc	#0x0
+    entry_point = [0x2701, 0x2000, 0xdf00].pack('S<3')
+  when 'riscv64'
+    ei_class  = ELF::ELFCLASS64
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0xf3
+    e_flags   = 0x5
+
+    # 0000000000400078 <PT_LOAD#0>:
+    #   400078: 05d00893     	li	a7, 0x5d
+    #   40007c: 4501         	li	a0, 0x0
+    #   40007e: 00000073     	ecall
+    entry_point = [0x05d00893, 0x4501, 0x00000073].pack('L<S<L<')
+  when 'x86_64'
+    ei_class  = ELF::ELFCLASS64
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0x3e
+    e_flags   = 0
+
+    # 0000000000400078 <PT_LOAD#0>:
+    #   400078: 31 ff                        	xorl	%edi, %edi
+    #   40007a: b8 3c 00 00 00               	movl	$0x3c, %eax
+    #   40007f: 0f 05                        	syscall
+    entry_point = %w[31ffb83c0000000f05].pack('H*')
+  when 'i386'
+    ei_class  = ELF::ELFCLASS32
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0x03
+    e_flags   = 0
+
+    # 00400054 <PT_LOAD#0>:
+    #   400054: 31 db                        	xorl	%ebx, %ebx
+    #   400056: b8 01 00 00 00               	movl	$0x1, %eax
+    #   40005b: cd 80                        	int	$0x80
+    entry_point = %w[31dbb801000000cd80].pack('H*')
+  else
+    raise NotImplementedError
+  end
+
+  case ei_class
+  when ELF::ELFCLASS32
+    e_ehsize    = ELF::Elf32_Ehdr.sizeof
+    e_phentsize = ELF::Elf32_Phdr.sizeof
+    e_shentsize = ELF::Elf32_Shdr.sizeof
+  when ELF::ELFCLASS64
+    e_ehsize    = ELF::Elf64_Ehdr.sizeof
+    e_phentsize = ELF::Elf64_Phdr.sizeof
+    e_shentsize = ELF::Elf64_Shdr.sizeof
+  else
+    raise EncodingError
+  end
+
+  e_phoff  = e_ehsize
+
+  p_offset = e_phoff + e_phentsize
+  p_vaddr  = (2**22) + p_offset
+  p_filesz = entry_point.length
+  p_memsz  = p_filesz
+
+  e_entry  = p_vaddr
+  e_entry += 1 if Platform::CPU == 'arm'
+
+  ELF.allocate.instance_eval do
+    @ehdr = {
+      e_ident: [127, 69, 76, 70, ei_class, ei_data, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      e_type: ELF::ET_EXEC,
+      e_machine:,
+      e_version: 1,
+      e_entry:,
+      e_phoff:,
+      e_shoff: 0,
+      e_flags:,
+      e_ehsize:,
+      e_phentsize:,
+      e_phnum: 1,
+      e_shentsize:,
+      e_shnum: 0,
+      e_shstrndx: 0
+    }
+    @phdrs = [
+      {
+        p_type: ELF::PT_LOAD,
+        p_flags: ELF::PF_R | ELF::PF_X,
+        p_offset:,
+        p_vaddr:,
+        p_paddr: 0,
+        p_filesz:,
+        p_memsz:,
+        p_align: 4096
+      }
+    ]
+    @shdrs = []
+
+    File.open(t.name, 'wb', 0o755) do |file|
+      dump(file)
+      file.write(entry_point)
+    end
+  end
+end
+
 # This is a FileUtils extension that defines several additional commands to be
 # added to the FileUtils utility functions.
 module FileUtils
@@ -302,46 +427,140 @@ module FileUtils
   end
 end
 
-# The {SassConfig} module.
-module SassConfig
-  module Platform
-    OS = case RbConfig::CONFIG['host_os'].downcase
-         when /darwin/
-           'darwin'
-         when /linux-android/
-           'linux-android'
-         when /linux-musl/
-           'linux-musl'
-         when /linux-uclibc/
-           'linux-uclibc'
-         when /linux/
-           'linux'
-         when *Gem::WIN_PATTERNS
-           'windows'
-         else
-           RbConfig::CONFIG['host_os'].downcase
-         end
+# The {Platform} module.
+module Platform
+  # @see https://docs.freebsd.org/en/articles/linux-emulation/
+  # @see https://docs.freebsd.org/en/books/handbook/linuxemu/
+  module Linuxulator
+    module_function
 
-    CPU = case RbConfig::CONFIG['host_cpu'].downcase
-          when /amd64|x86_64|x64/
-            'x86_64'
-          when /i\d86|x86|i86pc/
-            'x86'
-          when /arm64|aarch64/
-            'aarch64'
-          when /arm/
-            'arm'
-          when /ppc64le|powerpc64le/
-            'powerpc64le'
-          else
-            RbConfig::CONFIG['host_cpu']
-          end
+    def enabled?
+      return false unless RbConfig::CONFIG['host_os'].include?('freebsd')
+
+      return true if defined?(Platform::OS) && Platform::OS.include?('linux')
+
+      begin
+        Rake::Task['true'].invoke unless File.exist?('true')
+      rescue NotImplementedError
+        # do nothing
+      end
 
-    ARCH = "#{CPU}-#{OS}".freeze
+      system('./true') == true
+    end
+
+    def host_os(root = compat_linux_emul_path)
+      return 'linux-none' unless File.symlink?(File.absolute_path('proc/self/exe', root))
+
+      if (Platform::CPU == 'aarch64' &&
+          File.exist?(File.absolute_path('lib/ld-linux-aarch64.so.1', root))) ||
+         (Platform::CPU == 'riscv64' &&
+          File.exist?(File.absolute_path('lib/ld-linux-riscv64-lp64d.so.1', root))) ||
+         (Platform::CPU == 'x86_64' &&
+          File.exist?(File.absolute_path('lib64/ld-linux-x86-64.so.2', root))) ||
+         (Platform::CPU == 'i386' &&
+          File.exist?(File.absolute_path('lib/ld-linux.so.2', root)))
+        return 'linux-gnu'
+      end
+
+      if Platform::CPU == 'arm' &&
+         File.exist?(File.absolute_path('lib/ld-linux-armhf.so.3', root))
+        return 'linux-gnueabihf'
+      end
+
+      if %w[aarch64 riscv64 x86_64 i386].include?(Platform::CPU) &&
+         File.exist?(File.absolute_path("lib/ld-musl-#{Platform::CPU}.so.1", root))
+        return 'linux-musl'
+      end
+
+      if Platform::CPU == 'arm' &&
+         File.exist?(File.absolute_path('lib/ld-musl-armhf.so.1', root))
+        return 'linux-musleabihf'
+      end
+
+      if (%w[aarch64 riscv64 x86_64].include?(Platform::CPU) &&
+          File.exist?(File.absolute_path('system/bin/linker64', root))) ||
+         (Platform::CPU == 'i386' &&
+          File.exist?(File.absolute_path('system/bin/linker', root)))
+        return 'linux-android'
+      end
+
+      if Platform::CPU == 'arm' &&
+         File.exist?(File.absolute_path('system/bin/linker', root))
+        return 'linux-androideabi'
+      end
+
+      'linux-none'
+    end
+
+    def compat_linux_emul_path
+      require 'fiddle'
+
+      lib = Fiddle.dlopen(nil)
+      sysctlbyname = Fiddle::Function.new(
+        lib['sysctlbyname'],
+        [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T],
+        Fiddle::TYPE_INT
+      )
+
+      name = Fiddle::Pointer.to_ptr('compat.linux.emul_path')
+      oldp = Fiddle::NULL
+      oldlenp = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T, Fiddle::RUBY_FREE)
+      newp = Fiddle::NULL
+      newlen = 0
+      raise SystemCallError.new(nil, Fiddle.last_error) if sysctlbyname.call(name, oldp, oldlenp, newp, newlen) == -1
+
+      oldp = Fiddle::Pointer.malloc(oldlenp.ptr.to_i, Fiddle::RUBY_FREE)
+      raise SystemCallError.new(nil, Fiddle.last_error) if sysctlbyname.call(name, oldp, oldlenp, newp, newlen) == -1
+
+      oldp.to_s
+    rescue SystemCallError
+      nil
+    end
   end
 
-  private_constant :Platform
+  HOST_CPU = RbConfig::CONFIG['host_cpu'].downcase
+
+  CPU = case HOST_CPU
+        when /amd64|x86_64|x64/
+          'x86_64'
+        when /i\d86|x86|i86pc/
+          'i386'
+        when /arm64|aarch64/
+          'aarch64'
+        when /arm/
+          'arm'
+        when /ppc64le|powerpc64le/
+          'ppc64le'
+        else
+          HOST_CPU
+        end
+
+  HOST_OS = (Linuxulator.enabled? ? Linuxulator.host_os : RbConfig::CONFIG['host_os']).downcase
+
+  OS = case HOST_OS
+       when /darwin/
+         'darwin'
+       when /linux-android/
+         'linux-android'
+       when /linux-musl/
+         'linux-musl'
+       when /linux-none/
+         'linux-none'
+       when /linux-uclibc/
+         'linux-uclibc'
+       when /linux/
+         'linux'
+       when *Gem::WIN_PATTERNS
+         'windows'
+       else
+         HOST_OS
+       end
+
+  ARCH = "#{CPU}-#{OS}".freeze
+end
 
+# The {SassConfig} module.
+module SassConfig
   module_function
 
   def package_json(path = '.')
@@ -380,7 +599,7 @@ module SassConfig
          end
 
     cpu = case Platform::CPU
-          when 'x86'
+          when 'i386'
             'ia32'
           when 'x86_64'
             'x64'
@@ -415,7 +634,7 @@ module SassConfig
     os = case Platform::OS
          when 'darwin'
            'osx'
-         when 'linux', 'linux-android', 'linux-musl', 'linux-uclibc'
+         when 'linux', 'linux-android', 'linux-musl', 'linux-none', 'linux-uclibc'
            'linux'
          when 'windows'
            'windows'
@@ -424,13 +643,13 @@ module SassConfig
          end
 
     cpu = case Platform::CPU
-          when 'x86'
+          when 'i386'
             'x86_32'
           when 'x86_64'
             'x86_64'
           when 'aarch64'
             'aarch_64'
-          when 'powerpc64le'
+          when 'ppc64le'
             'ppcle_64'
           when 's390x'
             's390_64'
@@ -492,7 +711,7 @@ module SassConfig
   end
 
   def gem_platform
-    platform = Gem::Platform.new("#{Platform::CPU}-#{RbConfig::CONFIG['host_os']}")
+    platform = Gem::Platform.new("#{Platform::CPU}-#{Platform::HOST_OS}")
     case Platform::OS
     when 'darwin'
       case platform.cpu

data/ext/sass/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "sass": "1.83.4"
+    "sass": "1.85.1"
   }
 }

data/lib/sass/elf.rb

@@ -7,73 +7,30 @@ module Sass
   # @see https://github.com/torvalds/linux/blob/HEAD/include/uapi/linux/elf.h
   # @see https://github.com/torvalds/linux/blob/HEAD/kernel/kexec_elf.c
   class ELF
-    module PackInfo
-      PACK_MAP = {
-        Elf32_Ehdr: 'S<2L<5S<6',
-        Elf64_Ehdr: 'S<2L<Q<3L<S<6',
-        Elf32_Phdr: 'L<8',
-        Elf64_Phdr: 'L<2Q<6'
-      }.freeze
-
-      SIZE_MAP = {
-        Elf32_Ehdr: 36,
-        Elf64_Ehdr: 48,
-        Elf32_Phdr: 32,
-        Elf64_Phdr: 56
-      }.freeze
-
-      STRUCT_MAP = {
-        Elf32_Ehdr: %i[
-          e_type
-          e_machine
-          e_version
-          e_entry
-          e_phoff
-          e_shoff
-          e_flags
-          e_ehsize
-          e_phentsize
-          e_phnum
-          e_shentsize
-          e_shnum
-          e_shstrndx
-        ].freeze,
-        Elf64_Ehdr: %i[
-          e_type
-          e_machine
-          e_version
-          e_entry
-          e_phoff
-          e_shoff
-          e_flags
-          e_ehsize
-          e_phentsize
-          e_phnum
-          e_shentsize
-          e_shnum
-          e_shstrndx
-        ].freeze,
-        Elf32_Phdr: %i[
-          p_type
-          p_offset
-          p_vaddr
-          p_paddr
-          p_filesz
-          p_memsz
-          p_flags
-          p_align
-        ].freeze,
-        Elf64_Phdr: %i[
-          p_type
-          p_flags
-          p_offset
-          p_vaddr
-          p_paddr
-          p_filesz
-          p_memsz
-          p_align
-        ].freeze
-      }.freeze
+    # The {PackInfo} class.
+    class PackInfo
+      def initialize(format:, sizeof:, struct:)
+        @format_le = format.freeze
+        @format_be = format.tr('<', '>').freeze
+        @sizeof = sizeof.freeze
+        @struct = struct.freeze
+      end
+
+      attr_reader :sizeof
+
+      def pack(io, data, little_endian)
+        raise ArgumentError if io.write(data.values_at(*@struct).pack(format(little_endian))) != @sizeof
+      end
+
+      def unpack(io, little_endian)
+        @struct.zip(io.read(@sizeof).unpack(format(little_endian))).to_h
+      end
+
+      private
+
+      def format(little_endian)
+        little_endian ? @format_le : @format_be
+      end
     end
 
     private_constant :PackInfo
@@ -92,6 +49,8 @@ module Sass
     PT_LOPROC       = 0x70000000
     PT_HIPROC       = 0x7fffffff
 
+    PN_XNUM         = 0xffff
+
     # These constants define the different elf file types
     ET_NONE   = 0
     ET_REL    = 1
@@ -103,6 +62,154 @@ module Sass
 
     EI_NIDENT = 16
 
+    Elf32_Ehdr = PackInfo.new(
+      format: "a#{EI_NIDENT}S<2L<5S<6",
+      sizeof: 52,
+      struct: %i[
+        e_ident
+        e_type
+        e_machine
+        e_version
+        e_entry
+        e_phoff
+        e_shoff
+        e_flags
+        e_ehsize
+        e_phentsize
+        e_phnum
+        e_shentsize
+        e_shnum
+        e_shstrndx
+      ]
+    ).freeze
+
+    Elf64_Ehdr = PackInfo.new(
+      format: "a#{EI_NIDENT}S<2L<Q<3L<S<6",
+      sizeof: 64,
+      struct: %i[
+        e_ident
+        e_type
+        e_machine
+        e_version
+        e_entry
+        e_phoff
+        e_shoff
+        e_flags
+        e_ehsize
+        e_phentsize
+        e_phnum
+        e_shentsize
+        e_shnum
+        e_shstrndx
+      ]
+    ).freeze
+
+    # These constants define the permissions on sections in the program header, p_flags.
+    PF_R = 0x4
+    PF_W = 0x2
+    PF_X = 0x1
+
+    Elf32_Phdr = PackInfo.new(
+      format: 'L<8',
+      sizeof: 32,
+      struct: %i[
+        p_type
+        p_offset
+        p_vaddr
+        p_paddr
+        p_filesz
+        p_memsz
+        p_flags
+        p_align
+      ]
+    ).freeze
+
+    Elf64_Phdr = PackInfo.new(
+      format: 'L<2Q<6',
+      sizeof: 56,
+      struct: %i[
+        p_type
+        p_flags
+        p_offset
+        p_vaddr
+        p_paddr
+        p_filesz
+        p_memsz
+        p_align
+      ]
+    ).freeze
+
+    # sh_type
+    SHT_NULL     = 0
+    SHT_PROGBITS = 1
+    SHT_SYMTAB   = 2
+    SHT_STRTAB   = 3
+    SHT_RELA     = 4
+    SHT_HASH     = 5
+    SHT_DYNAMIC  = 6
+    SHT_NOTE     = 7
+    SHT_NOBITS   = 8
+    SHT_REL      = 9
+    SHT_SHLIB    = 10
+    SHT_DYNSYM   = 11
+    SHT_NUM      = 12
+    SHT_LOPROC   = 0x70000000
+    SHT_HIPROC   = 0x7fffffff
+    SHT_LOUSER   = 0x80000000
+    SHT_HIUSER   = 0xffffffff
+
+    # sh_flags
+    SHF_WRITE          = 0x1
+    SHF_ALLOC          = 0x2
+    SHF_EXECINSTR      = 0x4
+    SHF_RELA_LIVEPATCH = 0x00100000
+    SHF_RO_AFTER_INIT  = 0x00200000
+    SHF_MASKPROC       = 0xf0000000
+
+    # special section indexes
+    SHN_UNDEF     = 0
+    SHN_LORESERVE = 0xff00
+    SHN_LOPROC    = 0xff00
+    SHN_HIPROC    = 0xff1f
+    SHN_LIVEPATCH = 0xff20
+    SHN_ABS       = 0xfff1
+    SHN_COMMON    = 0xfff2
+    SHN_HIRESERVE = 0xffff
+
+    Elf32_Shdr = PackInfo.new(
+      format: 'L<10',
+      sizeof: 40,
+      struct: %i[
+        sh_name
+        sh_type
+        sh_flags
+        sh_addr
+        sh_offset
+        sh_size
+        sh_link
+        sh_info
+        sh_addralign
+        sh_entsize
+      ]
+    ).freeze
+
+    Elf64_Shdr = PackInfo.new(
+      format: 'L<2Q<4L<2Q<2',
+      sizeof: 64,
+      struct: %i[
+        sh_name
+        sh_type
+        sh_flags
+        sh_addr
+        sh_offset
+        sh_size
+        sh_link
+        sh_info
+        sh_addralign
+        sh_entsize
+      ]
+    ).freeze
+
     # e_ident[] indexes
     EI_MAG0    = 0
     EI_MAG1    = 1
@@ -133,24 +240,84 @@ module Sass
     ELFDATA2LSB = 1
     ELFDATA2MSB = 2
 
-    def initialize(buffer)
-      @buffer = buffer
+    def initialize(io, program_headers: true, section_headers: false)
+      io.rewind
+      e_ident = io.read(EI_NIDENT).unpack('C*')
+      raise ArgumentError unless e_ident.slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+
+      case e_ident[EI_CLASS]
+      when ELFCLASS32
+        elf_ehdr = Elf32_Ehdr
+        elf_phdr = Elf32_Phdr
+        elf_shdr = Elf32_Shdr
+      when ELFCLASS64
+        elf_ehdr = Elf64_Ehdr
+        elf_phdr = Elf64_Phdr
+        elf_shdr = Elf64_Shdr
+      else
+        raise EncodingError
+      end
+
+      case e_ident[EI_DATA]
+      when ELFDATA2LSB
+        little_endian = true
+      when ELFDATA2MSB
+        little_endian = false
+      else
+        raise EncodingError
+      end
+
+      io.rewind
+      ehdr = elf_ehdr.unpack(io, little_endian)
+      ehdr[:e_ident] = e_ident
 
-      @ehdr = { e_ident: @buffer.read(EI_NIDENT).unpack('C*') }
-      raise ArgumentError unless @ehdr[:e_ident].slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+      phdrs = if program_headers && ehdr[:e_phnum].positive?
+                io.seek(ehdr[:e_phoff], IO::SEEK_SET)
+                Array.new(ehdr[:e_phnum]) do
+                  elf_phdr.unpack(io, little_endian)
+                end
+              else
+                []
+              end
 
-      case @ehdr[:e_ident][EI_CLASS]
+      shdrs = if section_headers && ehdr[:e_shnum].positive?
+                io.seek(ehdr[:e_shoff], IO::SEEK_SET)
+                Array.new(ehdr[:e_shnum]) do
+                  elf_shdr.unpack(io, little_endian)
+                end
+              else
+                []
+              end
+
+      @io = io
+      @ehdr = ehdr
+      @phdrs = phdrs
+      @shdrs = shdrs
+    end
+
+    def dump(io)
+      e_ident = @ehdr[:e_ident]
+      raise ArgumentError unless e_ident.slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+
+      ehdr = @ehdr.dup
+      ehdr[:e_ident] = e_ident.pack('C*')
+      phdrs = @phdrs
+      shdrs = @shdrs
+
+      case e_ident[EI_CLASS]
       when ELFCLASS32
-        elf_ehdr = :Elf32_Ehdr
-        elf_phdr = :Elf32_Phdr
+        elf_ehdr = Elf32_Ehdr
+        elf_phdr = Elf32_Phdr
+        elf_shdr = Elf32_Shdr
       when ELFCLASS64
-        elf_ehdr = :Elf64_Ehdr
-        elf_phdr = :Elf64_Phdr
+        elf_ehdr = Elf64_Ehdr
+        elf_phdr = Elf64_Phdr
+        elf_shdr = Elf64_Shdr
       else
         raise EncodingError
       end
 
-      case @ehdr[:e_ident][EI_DATA]
+      case e_ident[EI_DATA]
       when ELFDATA2LSB
         little_endian = true
       when ELFDATA2MSB
@@ -159,12 +326,20 @@ module Sass
         raise EncodingError
       end
 
-      @ehdr.merge!(read(elf_ehdr, little_endian))
+      io.rewind
+      elf_ehdr.pack(io, ehdr, little_endian)
 
-      @buffer.seek(@ehdr[:e_phoff], IO::SEEK_SET)
-      @proghdrs = Array.new(@ehdr[:e_phnum]) do
-        read(elf_phdr, little_endian)
+      io.seek(ehdr[:e_phoff], IO::SEEK_SET) if ehdr[:e_phnum].positive?
+      phdrs.each do |phdr|
+        elf_phdr.pack(io, phdr, little_endian)
       end
+
+      io.seek(ehdr[:e_shoff], IO::SEEK_SET) if ehdr[:e_shnum].positive?
+      shdrs.each do |shdr|
+        elf_shdr.pack(io, shdr, little_endian)
+      end
+
+      io.flush
     end
 
     def relocatable?
@@ -184,24 +359,16 @@ module Sass
     end
 
     def interpreter
-      phdr = @proghdrs.find { |p| p[:p_type] == PT_INTERP }
+      phdr = @phdrs.find { |p| p[:p_type] == PT_INTERP }
       return if phdr.nil?
 
-      @buffer.seek(phdr[:p_offset], IO::SEEK_SET)
-      interpreter = @buffer.read(phdr[:p_filesz])
+      @io.seek(phdr[:p_offset], IO::SEEK_SET)
+      interpreter = @io.read(phdr[:p_filesz])
       raise EncodingError unless interpreter.end_with?("\0")
 
       interpreter.chomp!("\0")
     end
 
-    private
-
-    def read(type, little_endian)
-      size = PackInfo::SIZE_MAP[type]
-      format = little_endian ? PackInfo::PACK_MAP[type] : PackInfo::PACK_MAP[type].tr('<', '>')
-      [PackInfo::STRUCT_MAP[type], @buffer.read(size).unpack(format)].transpose.to_h
-    end
-
     INTERPRETER = begin
       proc_self_exe = '/proc/self/exe'
       if File.exist?(proc_self_exe)

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   module Embedded
-    VERSION = '1.83.4'
+    VERSION = '1.85.1'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 1.83.4
+  version: 1.85.1
 platform: ruby
 authors:
 - なつき
 bindir: exe
 cert_chain: []
-date: 2025-01-14 00:00:00.000000000 Z
+date: 2025-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -124,8 +124,8 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/sass-contrib/sass-embedded-host-ruby/issues
-  documentation_uri: https://rubydoc.info/gems/sass-embedded/1.83.4
-  source_code_uri: https://github.com/sass-contrib/sass-embedded-host-ruby/tree/v1.83.4
+  documentation_uri: https://rubydoc.info/gems/sass-embedded/1.85.1
+  source_code_uri: https://github.com/sass-contrib/sass-embedded-host-ruby/tree/v1.85.1
   funding_uri: https://github.com/sponsors/ntkme
   rubygems_mfa_required: 'true'
 rdoc_options: []
@@ -142,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.5
 specification_version: 4
 summary: Use dart-sass with Ruby!
 test_files: []