sass-embedded 1.63.5 → 1.64.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c463495ed448856ecec61dd708f275713908553dfac183dbe5e006617701b501
-  data.tar.gz: dd1b24b9d4f5a68b666b18455bd8a67649be1d931dab12ea74fc9083de2c6fa1
+  metadata.gz: d6ab7f4ccdb57babfe8dc2af27348ef74956b60b6051389839211004aee50b4a
+  data.tar.gz: f423e6703e1beeaaf12d87c2085f2f918812ac6eed6639b939108128abf5b0b1
 SHA512:
-  metadata.gz: 24fb32bbe970020cad694e98b453266b442dfb8622e74b54cec053b5ecd1a26ed8696a95a4d1a1f9ec5497665a521722c9fd8a7d8d0ce1fc1007c7e4e3e9272a
-  data.tar.gz: ec326d600ded86c87acc834c59a584ae024c9496a169d943e807fd678790c64aca94a77d3bc5bba2c9a8dd9c6732c45b7f995e55927fe1ecefce5df58f41ec52
+  metadata.gz: df45e1d1804557bd66f0062f4c46f015f74f9ade4349bf0094c61557d32ae2f0b26aea707e449e722d629b41e866ffa0a67fba24d15a1ce5cfc5119ecd7f9261
+  data.tar.gz: 5eec5885c830ad9d5d2e68ce637c3754c22186da39aa8c12353e38d38ed80748cacbe4b6cf3f2a566950e65fbcff8f8c3852de41657c2a9c8b305c75ec2062ec

data/ext/sass/Rakefile

@@ -8,17 +8,23 @@ task install: %w[cli.rb] do
   Rake::Task['embedded_sass_pb.rb'].invoke unless File.exist?('embedded_sass_pb.rb')
 end
 
-CLEAN.include %w[protoc.exe *.proto *.tar.gz *.zip]
+CLEAN.include %w[protoc.exe ruby *.proto *.tar.gz *.zip]
 
 CLOBBER.include %w[dart-sass cli.rb embedded_sass_pb.rb]
 
 file 'protoc.exe' do |t|
-  fetch(ENV.fetch('PROTOC_BIN') { Configuration.default_protoc }, t.name)
+  fetch(ENV.fetch('PROTOC_BIN') { SassConfig.default_protoc }, t.name)
   chmod 'a+x', t.name
 end
 
 file 'dart-sass' do |t|
-  archive = fetch(ENV.fetch(t.name.tr('-', '_').upcase) { Configuration.default_dart_sass })
+  raise if ENV.key?('DART_SASS')
+
+  gem_install 'sass-embedded', SassConfig.gem_version, SassConfig.gem_platform do |dir|
+    cp_r File.absolute_path("ext/sass/#{t.name}", dir), t.name
+  end
+rescue StandardError
+  archive = fetch(ENV.fetch('DART_SASS') { SassConfig.default_dart_sass })
   unarchive archive
   rm archive
 end
@@ -58,7 +64,7 @@ file 'cli.rb' => %w[dart-sass] do |t|
 end
 
 file 'embedded_sass.proto' => %w[cli.rb] do |t|
-  fetch(ENV.fetch('EMBEDDED_SASS_PROTOCOL') { Configuration.default_embedded_sass_protocol }, t.name)
+  fetch(ENV.fetch('EMBEDDED_SASS_PROTOCOL') { SassConfig.default_embedded_sass_protocol }, t.name)
 end
 
 rule '_pb.rb' => %w[.proto protoc.exe] do |t|
@@ -174,10 +180,48 @@ module FileUtils
 
     dest_path
   end
+
+  def gem_install(name, version, platform)
+    install_dir = File.absolute_path('ruby', __dir__)
+
+    if Rake::FileUtilsExt.verbose_flag
+      Rake.rake_output_message [
+        'gem', 'install',
+        '--force',
+        '--install-dir', install_dir,
+        '--no-document', '--ignore-dependencies',
+        '--platform', platform,
+        '--version', version,
+        'sass-embedded'
+      ].join(' ')
+    end
+
+    dependency = Gem::Dependency.new(name, version)
+
+    specs_and_sources, _errors = Gem::SpecFetcher.fetcher.spec_for_dependency(dependency, false)
+
+    spec, source = specs_and_sources.find do |s, _|
+      s.platform == platform
+    end
+
+    raise if spec.nil? || source.nil?
+
+    if Rake::FileUtilsExt.nowrite_flag
+      installer = Gem::Installer.for_spec(spec, { force: true, install_dir: install_dir })
+    else
+      path = source.download(spec, install_dir)
+      installer = Gem::Installer.at(path, { force: true, install_dir: install_dir })
+      installer.install
+    end
+
+    yield installer.dir
+  ensure
+    rm_rf install_dir
+  end
 end
 
-# The {Configuration} module.
-module Configuration
+# The {SassConfig} module.
+module SassConfig
   module Platform
     OS = case RbConfig::CONFIG['host_os'].downcase
          when /darwin/
@@ -204,8 +248,7 @@ module Configuration
           when /arm64|aarch64/
             'aarch64'
           when /arm/
-            # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
-            OS == 'darwin' ? 'aarch64' : 'arm'
+            'arm'
           when /ppc64le|powerpc64le/
             'powerpc64le'
           when /s390x/
@@ -214,21 +257,39 @@ module Configuration
             RbConfig::CONFIG['host_cpu']
           end
 
-    ARCH = "#{CPU}-#{OS}"
+    ARCH = "#{CPU}-#{OS}".freeze
+
+    EMULATION = if ARCH == 'aarch64-windows'
+                  begin
+                    require_relative 'win32_api'
+
+                    if Win32API.x64?
+                      'x86_64'
+                    elsif Win32API.x86?
+                      'i386'
+                    end
+                  rescue LoadError
+                    'i386'
+                  end
+                end
   end
 
   private_constant :Platform
 
   module_function
 
-  def default_dart_sass
+  def dart_sass_version
     require 'json'
 
-    repo = 'https://github.com/sass/dart-sass'
-
     spec = JSON.parse(File.read(File.absolute_path('package.json', __dir__)))
 
-    tag_name = spec['dependencies']['sass']
+    spec['dependencies']['sass']
+  end
+
+  def default_dart_sass
+    repo = 'https://github.com/sass/dart-sass'
+
+    tag_name = dart_sass_version
 
     message = "dart-sass for #{Platform::ARCH} not available at #{repo}/releases/tag/#{tag_name}"
 
@@ -249,30 +310,13 @@ module Configuration
            raise NotImplementedError, message
          end
 
-    cpu = case Platform::CPU
+    cpu = case Platform::EMULATION || Platform::CPU
           when 'i386'
             'ia32'
           when 'x86_64'
             'x64'
           when 'aarch64'
-            if Platform::OS == 'windows'
-              begin
-                require_relative 'win32_api'
-
-                if Win32API.x64?
-                  'x64'
-                elsif Win32API.x86?
-                  'ia32'
-                else
-                  raise NotImplementedError, message
-                end
-              rescue LoadError
-                # TODO: remove begin/rescue once jruby/jffi support windows aarch64
-                'ia32'
-              end
-            else
-              'arm64'
-            end
+            'arm64'
           when 'arm'
             'arm'
           else
@@ -306,30 +350,13 @@ module Configuration
            raise NotImplementedError, message
          end
 
-    cpu = case Platform::CPU
+    cpu = case Platform::EMULATION || Platform::CPU
           when 'i386'
             'x86_32'
           when 'x86_64'
             'x86_64'
           when 'aarch64'
-            if Platform::OS == 'windows'
-              begin
-                require_relative 'win32_api'
-
-                if Win32API.x64?
-                  'x86_64'
-                elsif Win32API.x86?
-                  'x86_32'
-                else
-                  raise NotImplementedError, message
-                end
-              rescue LoadError
-                # TODO: remove begin/rescue once jruby/jffi support windows aarch64
-                'x86_32'
-              end
-            else
-              'aarch_64'
-            end
+            'aarch_64'
           when 'powerpc64le'
             'ppcle_64'
           when 's390x'
@@ -374,4 +401,39 @@ module Configuration
 
     "https://github.com/sass/sass/raw/embedded-protocol-#{tag_name}/spec/embedded_sass.proto"
   end
+
+  def development?
+    File.exist?('../../Gemfile')
+  end
+
+  def gem_version
+    require_relative '../../lib/sass/embedded/version'
+
+    development? ? dart_sass_version : Sass::Embedded::VERSION
+  end
+
+  def gem_platform
+    platform = Gem::Platform.new("#{RbConfig::CONFIG['host_cpu']}-#{RbConfig::CONFIG['host_os']}")
+    case Platform::OS
+    when 'darwin'
+      Gem::Platform.new([platform.cpu, platform.os])
+    when 'linux'
+      if platform.version&.start_with?('gnu')
+        platform
+      else
+        Gem::Platform.new([platform.cpu, platform.os, "gnu#{platform.version}"])
+      end
+    when 'windows'
+      case Platform::EMULATION || Platform::CPU
+      when 'x86_64'
+        Gem::Platform.new('x64-mingw32')
+      when 'i386'
+        Gem::Platform.new('x86-mingw32')
+      else
+        Gem::Platform.new([platform.cpu, 'mingw32'])
+      end
+    else
+      platform
+    end
+  end
 end

data/ext/sass/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "sass": "1.63.5"
+    "sass": "1.64.0"
   }
 }

data/ext/sass/win32_api.rb

@@ -3,127 +3,131 @@
 require 'fiddle'
 
 # @!visibility private
-# @see https://learn.microsoft.com/en-us/windows/win32/api/
-module Win32API
-  Kernel32 = Fiddle.dlopen('Kernel32.dll')
-
-  # @see https://learn.microsoft.com/en-us/windows/win32/sysinfo/image-file-machine-constants
-  module ImageFileMachineConstants
-    IMAGE_FILE_MACHINE_I386 = 0x014c
-    IMAGE_FILE_MACHINE_ARMNT = 0x01c4
-    IMAGE_FILE_MACHINE_AMD64 = 0x8664
-    IMAGE_FILE_MACHINE_ARM64 = 0xaa64
-  end
-
-  private_constant :ImageFileMachineConstants
-
-  # @see https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ne-processthreadsapi-machine_attributes
-  module MachineAttributes
-    USER_ENABLED = 0x00000001
-    KERNEL_ENABLED = 0x00000002
-    WOW64_CONTAINER = 0x00000004
-  end
-
-  private_constant :MachineAttributes
-
-  # Specifies the ways in which an architecture of code can run on a host operating system.
-  class MachineTypeAttributes
-    def initialize(machine_type_attributes)
-      @machine_type_attributes = machine_type_attributes
+module SassConfig
+  # @see https://learn.microsoft.com/en-us/windows/win32/api/
+  module Win32API
+    Kernel32 = Fiddle.dlopen('Kernel32.dll')
+
+    # @see https://learn.microsoft.com/en-us/windows/win32/sysinfo/image-file-machine-constants
+    module ImageFileMachineConstants
+      IMAGE_FILE_MACHINE_I386 = 0x014c
+      IMAGE_FILE_MACHINE_ARMNT = 0x01c4
+      IMAGE_FILE_MACHINE_AMD64 = 0x8664
+      IMAGE_FILE_MACHINE_ARM64 = 0xaa64
     end
 
-    # The specified architecture of code can run in user mode.
-    def user_enabled?
-      @machine_type_attributes & MachineAttributes::USER_ENABLED == MachineAttributes::USER_ENABLED
-    end
+    private_constant :ImageFileMachineConstants
 
-    # The specified architecture of code can run in kernel mode.
-    def kernel_enabled?
-      @machine_type_attributes & MachineAttributes::KERNEL_ENABLED == MachineAttributes::KERNEL_ENABLED
+    # @see https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ne-processthreadsapi-machine_attributes
+    module MachineAttributes
+      USER_ENABLED = 0x00000001
+      KERNEL_ENABLED = 0x00000002
+      WOW64_CONTAINER = 0x00000004
     end
 
-    # The specified architecture of code runs on WOW64.
-    def wow64_container?
-      @machine_type_attributes & MachineAttributes::WOW64_CONTAINER == MachineAttributes::WOW64_CONTAINER
-    end
-  end
+    private_constant :MachineAttributes
 
-  private_constant :MachineTypeAttributes
+    # Specifies the ways in which an architecture of code can run on a host operating system.
+    class MachineTypeAttributes
+      def initialize(machine_type_attributes)
+        @machine_type_attributes = machine_type_attributes
+      end
 
-  class << self
-    def x86?
-      get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_I386).user_enabled?
-    end
+      # The specified architecture of code can run in user mode.
+      def user_enabled?
+        @machine_type_attributes & MachineAttributes::USER_ENABLED == MachineAttributes::USER_ENABLED
+      end
 
-    def arm?
-      get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_ARMNT).user_enabled?
-    end
+      # The specified architecture of code can run in kernel mode.
+      def kernel_enabled?
+        @machine_type_attributes & MachineAttributes::KERNEL_ENABLED == MachineAttributes::KERNEL_ENABLED
+      end
 
-    def x64?
-      get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_AMD64).user_enabled?
+      # The specified architecture of code runs on WOW64.
+      def wow64_container?
+        @machine_type_attributes & MachineAttributes::WOW64_CONTAINER == MachineAttributes::WOW64_CONTAINER
+      end
     end
 
-    def arm64?
-      get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_ARM64).user_enabled?
-    end
+    private_constant :MachineTypeAttributes
 
-    private
+    class << self
+      def x86?
+        get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_I386).user_enabled?
+      end
 
-    begin
-      # @see https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getmachinetypeattributes
-      GetMachineTypeAttributes = Fiddle::Function.new(
-        Kernel32['GetMachineTypeAttributes'],
-        [-Fiddle::TYPE_SHORT, Fiddle::TYPE_VOIDP],
-        Fiddle::TYPE_LONG
-      )
+      def arm?
+        get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_ARMNT).user_enabled?
+      end
 
-      def get_machine_type_attributes(machine)
-        p_machine_type_attributes = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT, Fiddle::RUBY_FREE)
-        raise Fiddle.win32_last_error unless GetMachineTypeAttributes.call(machine, p_machine_type_attributes).zero?
+      def x64?
+        get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_AMD64).user_enabled?
+      end
 
-        MachineTypeAttributes.new(p_machine_type_attributes.to_str.unpack1('i'))
+      def arm64?
+        get_machine_type_attributes(ImageFileMachineConstants::IMAGE_FILE_MACHINE_ARM64).user_enabled?
       end
-    rescue Fiddle::DLError
-      # @see https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getcurrentprocess
-      GetCurrentProcess = Fiddle::Function.new(
-        Kernel32['GetCurrentProcess'],
-        [],
-        Fiddle::TYPE_VOIDP
-      )
-
-      # @see https://learn.microsoft.com/en-us/windows/win32/api/wow64apiset/nf-wow64apiset-iswow64process2
-      IsWow64Process2 = Fiddle::Function.new(
-        Kernel32['IsWow64Process2'],
-        [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP],
-        Fiddle::TYPE_CHAR
-      )
-
-      # @see https://learn.microsoft.com/en-us/windows/win32/api/wow64apiset/nf-wow64apiset-iswow64guestmachinesupported
-      IsWow64GuestMachineSupported = Fiddle::Function.new(
-        Kernel32['IsWow64GuestMachineSupported'],
-        [-Fiddle::TYPE_SHORT, Fiddle::TYPE_VOIDP],
-        Fiddle::TYPE_LONG
-      )
-
-      def get_machine_type_attributes(machine)
-        h_process = GetCurrentProcess.call
-        p_process_machine = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SHORT, Fiddle::RUBY_FREE)
-        p_native_machine = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SHORT, Fiddle::RUBY_FREE)
-        raise Fiddle.win32_last_error if IsWow64Process2.call(h_process, p_process_machine, p_native_machine).zero?
-
-        if p_native_machine.to_str.unpack1('S!') == machine
-          return MachineTypeAttributes.new(MachineAttributes::USER_ENABLED | MachineAttributes::KERNEL_ENABLED)
-        end
 
-        p_machine_is_supported = Fiddle::Pointer.malloc(Fiddle::SIZEOF_CHAR, Fiddle::RUBY_FREE)
-        raise Fiddle.win32_last_error unless IsWow64GuestMachineSupported.call(machine, p_machine_is_supported).zero?
+      private
+
+      begin
+        # @see https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getmachinetypeattributes
+        GetMachineTypeAttributes = Fiddle::Function.new(
+          Kernel32['GetMachineTypeAttributes'],
+          [-Fiddle::TYPE_SHORT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_LONG
+        )
 
-        if p_machine_is_supported.to_str.unpack1('c').zero?
-          MachineTypeAttributes.new(0)
-        else
-          MachineTypeAttributes.new(MachineAttributes::USER_ENABLED | MachineAttributes::WOW64_CONTAINER)
+        def get_machine_type_attributes(machine)
+          p_machine_type_attributes = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT, Fiddle::RUBY_FREE)
+          raise Fiddle.win32_last_error unless GetMachineTypeAttributes.call(machine, p_machine_type_attributes).zero?
+
+          MachineTypeAttributes.new(p_machine_type_attributes.to_str.unpack1('i'))
+        end
+      rescue Fiddle::DLError
+        # @see https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getcurrentprocess
+        GetCurrentProcess = Fiddle::Function.new(
+          Kernel32['GetCurrentProcess'],
+          [],
+          Fiddle::TYPE_VOIDP
+        )
+
+        # @see https://learn.microsoft.com/en-us/windows/win32/api/wow64apiset/nf-wow64apiset-iswow64process2
+        IsWow64Process2 = Fiddle::Function.new(
+          Kernel32['IsWow64Process2'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_CHAR
+        )
+
+        # @see https://learn.microsoft.com/en-us/windows/win32/api/wow64apiset/nf-wow64apiset-iswow64guestmachinesupported
+        IsWow64GuestMachineSupported = Fiddle::Function.new(
+          Kernel32['IsWow64GuestMachineSupported'],
+          [-Fiddle::TYPE_SHORT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_LONG
+        )
+
+        def get_machine_type_attributes(machine)
+          h_process = GetCurrentProcess.call
+          p_process_machine = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SHORT, Fiddle::RUBY_FREE)
+          p_native_machine = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SHORT, Fiddle::RUBY_FREE)
+          raise Fiddle.win32_last_error if IsWow64Process2.call(h_process, p_process_machine, p_native_machine).zero?
+
+          if p_native_machine.to_str.unpack1('S!') == machine
+            return MachineTypeAttributes.new(MachineAttributes::USER_ENABLED | MachineAttributes::KERNEL_ENABLED)
+          end
+
+          p_machine_is_supported = Fiddle::Pointer.malloc(Fiddle::SIZEOF_CHAR, Fiddle::RUBY_FREE)
+          raise Fiddle.win32_last_error unless IsWow64GuestMachineSupported.call(machine, p_machine_is_supported).zero?
+
+          if p_machine_is_supported.to_str.unpack1('c').zero?
+            MachineTypeAttributes.new(0)
+          else
+            MachineTypeAttributes.new(MachineAttributes::USER_ENABLED | MachineAttributes::WOW64_CONTAINER)
+          end
         end
       end
     end
   end
+
+  private_constant :Win32API
 end

data/lib/sass/calculation_value/calculation_interpolation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sass
+  module CalculationValue
+    # A string injected into a SassCalculation using interpolation.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/calculationinterpolation/
+    class CalculationInterpolation
+      include CalculationValue
+
+      # @param value [::String]
+      def initialize(value)
+        @value = value
+      end
+
+      # @return [::String]
+      attr_reader :value
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::CalculationValue::CalculationInterpolation) &&
+          other.value == value
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= value.hash
+      end
+    end
+  end
+end

data/lib/sass/calculation_value/calculation_operation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sass
+  module CalculationValue
+    # A binary operation that can appear in a SassCalculation.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/calculationoperation/
+    class CalculationOperation
+      include CalculationValue
+
+      OPERATORS = ['+', '-', '*', '/'].freeze
+
+      private_constant :OPERATORS
+
+      # @param operator [::String]
+      # @param left [CalculationValue]
+      # @param right [CalculationValue]
+      def initialize(operator, left, right)
+        raise Sass::ScriptError, "Invalid operator: #{operator}" unless OPERATORS.include?(operator)
+
+        left.assert_calculation_value
+        right.assert_calculation_value
+
+        @operator = operator.freeze
+        @left = left.freeze
+        @right = right.freeze
+      end
+
+      # @return [::String]
+      attr_reader :operator
+
+      # @return [CalculationValue]
+      attr_reader :left
+
+      # @return [CalculationValue]
+      attr_reader :right
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::CalculationValue::CalculationOperation) &&
+          other.operator == operator &&
+          other.left == left &&
+          other.right == right
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= [operator, left, right].hash
+      end
+    end
+  end
+end

data/lib/sass/calculation_value.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sass
+  # The type of values that can be arguments to a SassCalculation.
+  #
+  # @see https://sass-lang.com/documentation/js-api/types/calculationvalue/
+  module CalculationValue
+    # @return [CalculationValue]
+    # @raise [ScriptError]
+    def assert_calculation_value(_name = nil)
+      self
+    end
+  end
+end
+
+require_relative 'calculation_value/calculation_interpolation'
+require_relative 'calculation_value/calculation_operation'

data/lib/sass/compile_result.rb

@@ -3,7 +3,7 @@
 module Sass
   # The result of compiling Sass to CSS. Returned by {Sass.compile} and {Sass.compile_string}.
   #
-  # @see https://sass-lang.com/documentation/js-api/interfaces/CompileResult
+  # @see https://sass-lang.com/documentation/js-api/interfaces/compileresult/
   class CompileResult
     # @return [String]
     attr_reader :css

data/lib/sass/embedded/host/function_registry.rb

@@ -47,13 +47,11 @@ module Sass
           end
 
           success = value_protofier.to_proto(get(function_call_request).call(arguments))
-          accessed_argument_lists = arguments
-                                    .select do |argument|
-                                      argument.is_a?(Sass::Value::ArgumentList) && argument.instance_eval do
-                                        @keywords_accessed
-                                      end
-                                    end
-                                    .map { |argument| argument.instance_eval { @id } }
+          accessed_argument_lists = arguments.filter_map do |argument|
+            if argument.is_a?(Sass::Value::ArgumentList) && argument.instance_eval { @keywords_accessed }
+              argument.instance_eval { @id }
+            end
+          end
 
           EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
             id: function_call_request.id,

data/lib/sass/embedded/host/value_protofier.rb

@@ -22,11 +22,7 @@ module Sass
             )
           when Sass::Value::Number
             EmbeddedProtocol::Value.new(
-              number: EmbeddedProtocol::Value::Number.new(
-                value: obj.value.to_f,
-                numerators: obj.numerator_units,
-                denominators: obj.denominator_units
-              )
+              number: Number.to_proto(obj)
             )
           when Sass::Value::Color
             if obj.instance_eval { !defined?(@hue) }
@@ -100,6 +96,10 @@ module Sass
                 )
               )
             end
+          when Sass::Value::Calculation
+            EmbeddedProtocol::Value.new(
+              calculation: Calculation.to_proto(obj)
+            )
           when Sass::Value::Boolean
             EmbeddedProtocol::Value.new(
               singleton: obj.value ? :TRUE : :FALSE
@@ -123,12 +123,7 @@ module Sass
               quoted: obj.quoted
             )
           when :number
-            Sass::Value::Number.new(
-              obj.value, {
-                numerator_units: obj.numerators.to_a,
-                denominator_units: obj.denominators.to_a
-              }
-            )
+            Number.from_proto(obj)
           when :rgb_color
             Sass::Value::Color.new(
               red: obj.red,
@@ -181,6 +176,8 @@ module Sass
             Sass::Value::Function.new(obj.id)
           when :host_function
             raise Sass::ScriptError, 'The compiler may not send Value.host_function to host'
+          when :calculation
+            Calculation.from_proto(obj)
           when :singleton
             case obj
             when :TRUE
@@ -197,6 +194,178 @@ module Sass
           end
         end
 
+        # The {Number} Protofier.
+        module Number
+          module_function
+
+          def to_proto(obj)
+            EmbeddedProtocol::Value::Number.new(
+              value: obj.value.to_f,
+              numerators: obj.numerator_units,
+              denominators: obj.denominator_units
+            )
+          end
+
+          def from_proto(obj)
+            Sass::Value::Number.new(
+              obj.value, {
+                numerator_units: obj.numerators.to_a,
+                denominator_units: obj.denominators.to_a
+              }
+            )
+          end
+        end
+
+        private_constant :Number
+
+        # The {Calculation} Protofier.
+        module Calculation
+          module_function
+
+          def to_proto(obj)
+            EmbeddedProtocol::Value::Calculation.new(
+              name: obj.name,
+              arguments: obj.arguments.map { |argument| CalculationValue.to_proto(argument) }
+            )
+          end
+
+          def from_proto(obj)
+            case obj.name
+            when 'calc'
+              if obj.arguments.length != 1
+                raise Sass::ScriptError,
+                      'Value.Calculation.arguments must have exactly one argument for calc().'
+              end
+
+              Sass::Value::Calculation.calc(*obj.arguments.map { |argument| CalculationValue.from_proto(argument) })
+            when 'clamp'
+              if obj.arguments.length != 3
+                raise Sass::ScriptError,
+                      'Value.Calculation.arguments must have exactly 3 arguments for clamp().'
+              end
+
+              Sass::Value::Calculation.clamp(*obj.arguments.map { |argument| CalculationValue.from_proto(argument) })
+            when 'min'
+              if obj.arguments.empty?
+                raise Sass::ScriptError,
+                      'Value.Calculation.arguments must have at least 1 argument for min().'
+              end
+
+              Sass::Value::Calculation.min(obj.arguments.map { |argument| CalculationValue.from_proto(argument) })
+            when 'max'
+              if obj.arguments.empty?
+                raise Sass::ScriptError,
+                      'Value.Calculation.arguments must have at least 1 argument for max().'
+              end
+
+              Sass::Value::Calculation.max(obj.arguments.map { |argument| CalculationValue.from_proto(argument) })
+            else
+              raise Sass::ScriptError,
+                    "Value.Calculation.name #{calculation.name.inspect} is not a recognized calculation type."
+            end
+          end
+        end
+
+        private_constant :Calculation
+
+        # The {CalculationValue} Protofier.
+        module CalculationValue
+          module_function
+
+          def to_proto(value)
+            case value
+            when Sass::Value::Number
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                number: Number.to_proto(value)
+              )
+            when Sass::Value::Calculation
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                calculation: Calculation.to_proto(value)
+              )
+            when Sass::Value::String
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                string: value.text
+              )
+            when Sass::CalculationValue::CalculationOperation
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                operation: EmbeddedProtocol::Value::Calculation::CalculationOperation.new(
+                  operator: CalculationOperator.to_proto(value.operator),
+                  left: to_proto(value.left),
+                  right: to_proto(value.right)
+                )
+              )
+            when Sass::CalculationValue::CalculationInterpolation
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                interpolation: value.value
+              )
+            else
+              raise Sass::ScriptError, "Unknown CalculationValue #{value}"
+            end
+          end
+
+          def from_proto(value)
+            oneof = value.value
+            obj = value.public_send(oneof)
+            case oneof
+            when :number
+              Number.from_proto(obj)
+            when :calculation
+              Calculation.from_proto(obj)
+            when :string
+              Sass::Value::String.new(obj, quoted: false)
+            when :operation
+              Sass::CalculationValue::CalculationOperation.new(
+                CalculationOperator.from_proto(obj.operator),
+                from_proto(obj.left),
+                from_proto(obj.right)
+              )
+            when :interpolation
+              Sass::CalculationValue::CalculationInterpolation.new(obj)
+            else
+              raise Sass::ScriptError, "Unknown CalculationValue #{value}"
+            end
+          end
+        end
+
+        private_constant :CalculationValue
+
+        # The {CalculationOperator} Protofier.
+        module CalculationOperator
+          module_function
+
+          def to_proto(operator)
+            case operator
+            when '+'
+              :PLUS
+            when '-'
+              :MINUS
+            when '*'
+              :TIMES
+            when '/'
+              :DIVIDE
+            else
+              raise Sass::ScriptError, "Unknown CalculationOperator #{separator}"
+            end
+          end
+
+          def from_proto(operator)
+            case operator
+            when :PLUS
+              '+'
+            when :MINUS
+              '-'
+            when :TIMES
+              '*'
+            when :DIVIDE
+              '/'
+            else
+              raise Sass::ScriptError, "Unknown CalculationOperator #{separator}"
+            end
+          end
+        end
+
+        private_constant :CalculationOperator
+
         # The {ListSeparator} Protofier.
         module ListSeparator
           module_function

data/lib/sass/embedded/host.rb

@@ -86,7 +86,13 @@ module Sass
       end
 
       def error(message)
-        @error = message
+        if message.is_a?(EmbeddedProtocol::ProtocolError)
+          return if message.id != id
+
+          @error = Errno::EPROTO.new(message.message)
+        else
+          @error = message
+        end
         @queue.close
       end
 

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   class Embedded
-    VERSION = '1.63.5'
+    VERSION = '1.64.0'
   end
 end

data/lib/sass/embedded.rb

@@ -95,7 +95,7 @@ module Sass
     # Compiles the Sass file at +path+ to CSS.
     # @param path [String]
     # @param load_paths [Array<String>] Paths in which to look for stylesheets loaded by rules like
-    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
     # @param charset [Boolean] By default, if the CSS document contains non-ASCII characters, Sass adds a +@charset+
     #   declaration (in expanded output mode) or a byte-order mark (in compressed mode) to indicate its encoding to
     #   browsers or other consumers. If +charset+ is +false+, these annotations are omitted.
@@ -104,7 +104,7 @@ module Sass
     # @param style [String, Symbol] The OutputStyle of the compiled CSS.
     # @param functions [Hash<String, Proc>] Additional built-in Sass functions that are available in all stylesheets.
     # @param importers [Array<Object>] Custom importers that control how Sass resolves loads from rules like
-    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
     # @param alert_ascii [Boolean] If this is +true+, the compiler will exclusively use ASCII characters in its error
     #   and warning messages. Otherwise, it may use non-ASCII Unicode characters as well.
     # @param alert_color [Boolean] If this is +true+, the compiler will use ANSI color escape codes in its error and
@@ -119,7 +119,7 @@ module Sass
     #   deprecation warning it encounters.
     # @return [CompileResult]
     # @raise [CompileError]
-    # @see https://sass-lang.com/documentation/js-api/modules#compile
+    # @see https://sass-lang.com/documentation/js-api/functions/compile/
     def compile(path,
                 load_paths: [],
 
@@ -163,7 +163,7 @@ module Sass
     # @param source [String]
     # @param importer [Object] The importer to use to handle loads that are relative to the entrypoint stylesheet.
     # @param load_paths [Array<String>] Paths in which to look for stylesheets loaded by rules like
-    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
     # @param syntax [String, Symbol] The Syntax to use to parse the entrypoint stylesheet.
     # @param url [String] The canonical URL of the entrypoint stylesheet. If this is passed along with +importer+, it's
     #   used to resolve relative loads in the entrypoint stylesheet.
@@ -175,7 +175,7 @@ module Sass
     # @param style [String, Symbol] The OutputStyle of the compiled CSS.
     # @param functions [Hash<String, Proc>] Additional built-in Sass functions that are available in all stylesheets.
     # @param importers [Array<Object>] Custom importers that control how Sass resolves loads from rules like
-    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
     # @param alert_ascii [Boolean] If this is +true+, the compiler will exclusively use ASCII characters in its error
     #   and warning messages. Otherwise, it may use non-ASCII Unicode characters as well.
     # @param alert_color [Boolean] If this is +true+, the compiler will use ANSI color escape codes in its error and
@@ -190,7 +190,7 @@ module Sass
     #   deprecation warning it encounters.
     # @return [CompileResult]
     # @raise [CompileError]
-    # @see https://sass-lang.com/documentation/js-api/modules#compileString
+    # @see https://sass-lang.com/documentation/js-api/functions/compilestring/
     def compile_string(source,
                        importer: nil,
                        load_paths: [],
@@ -234,7 +234,7 @@ module Sass
     end
 
     # @return [String] Information about the Sass implementation.
-    # @see https://sass-lang.com/documentation/js-api/modules#info
+    # @see https://sass-lang.com/documentation/js-api/variables/info/
     def info
       @info ||= Host.new(@dispatcher).version_request
     end

data/lib/sass/logger/silent.rb

@@ -3,11 +3,13 @@
 module Sass
   # A namespace for built-in Loggers.
   #
-  # @see https://sass-lang.com/documentation/js-api/modules/Logger
+  # @see https://sass-lang.com/documentation/js-api/modules/logger/
   module Logger
     module_function
 
     # A Logger that silently ignores all warnings and debug messages.
+    #
+    # @see https://sass-lang.com/documentation/js-api/variables/logger.silent/
     def silent
       Silent
     end

data/lib/sass/logger/source_location.rb

@@ -6,7 +6,7 @@ module Sass
     #
     # This is always associated with a {SourceSpan} which indicates which file it refers to.
     #
-    # @see https://sass-lang.com/documentation/js-api/interfaces/SourceLocation
+    # @see https://sass-lang.com/documentation/js-api/interfaces/sourcelocation/
     class SourceLocation
       # @return [Integer]
       attr_reader :offset, :line, :column

data/lib/sass/logger/source_span.rb

@@ -4,7 +4,7 @@ module Sass
   module Logger
     # A span of text within a source file.
     #
-    # @see https://sass-lang.com/documentation/js-api/interfaces/SourceSpan
+    # @see https://sass-lang.com/documentation/js-api/interfaces/sourcespan/
     class SourceSpan
       # @return [SourceLocation]
       attr_reader :start, :end

data/lib/sass/value/argument_list.rb

@@ -7,7 +7,7 @@ module Sass
     # An argument list comes from a rest argument. It's distinct from a normal {List} in that it may contain a keyword
     # map as well as the positional arguments.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassArgumentList
+    # @see https://sass-lang.com/documentation/js-api/classes/sassargumentlist/
     class ArgumentList < Value::List
       # @param contents [Array<Value>]
       # @param keywords [Hash<::String, Value>]

data/lib/sass/value/boolean.rb

@@ -4,7 +4,7 @@ module Sass
   module Value
     # Sass's boolean type.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassBoolean
+    # @see https://sass-lang.com/documentation/js-api/classes/sassboolean/
     class Boolean
       include Value
 

data/lib/sass/value/calculation.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's calculation type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/sasscalculation/
+    class Calculation
+      include Value
+      include CalculationValue
+
+      def initialize(name, arguments)
+        @name = name.freeze
+        @arguments = arguments.freeze
+      end
+
+      # @return [::String]
+      attr_reader :name
+
+      # @return [Array<CalculationValue>]
+      attr_reader :arguments
+
+      private_class_method :new
+
+      class << self
+        # @param argument [CalculationValue]
+        # @return [Calculation]
+        def calc(argument)
+          argument.assert_calculation_value
+          new('calc', [argument])
+        end
+
+        # @param arguments [Array<CalculationValue>]
+        # @return [Calculation]
+        def min(arguments)
+          arguments.each(&:assert_calculation_value)
+          new('min', arguments)
+        end
+
+        # @param arguments [Array<CalculationValue>]
+        # @return [Calculation]
+        def max(arguments)
+          arguments.each(&:assert_calculation_value)
+          new('max', arguments)
+        end
+
+        # @param min [CalculationValue]
+        # @param value [CalculationValue]
+        # @param max [CalculationValue]
+        # @return [Calculation]
+        def clamp(min, value = nil, max = nil)
+          if (value.nil? && !valid_clamp_arg?(min)) ||
+             (max.nil? && [min, value].none? { |x| x && valid_clamp_arg?(x) })
+            raise Sass::ScriptError, 'Argument must be an unquoted SassString or CalculationInterpolation.'
+          end
+
+          arguments = [min]
+          arguments.push(value) unless value.nil?
+          arguments.push(max) unless max.nil?
+          arguments.each(&:assert_calculation_value)
+          new('clamp', arguments)
+        end
+
+        private
+
+        def valid_clamp_arg?(value)
+          value.is_a?(Sass::CalculationValue::CalculationInterpolation) ||
+            (value.is_a?(Sass::Value::String) && !value.quoted?)
+        end
+      end
+
+      # @return [Calculation]
+      def assert_calculation(_name = nil)
+        self
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Calculation) &&
+          other.name == name &&
+          other.arguments == arguments
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= [name, *arguments].hash
+      end
+    end
+  end
+end

data/lib/sass/value/color.rb

@@ -6,7 +6,7 @@ module Sass
     #
     # No matter what representation was originally used to create this color, all of its channels are accessible.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassColor
+    # @see https://sass-lang.com/documentation/js-api/classes/sasscolor/
     class Color
       include Value
 

data/lib/sass/value/function.rb

@@ -4,7 +4,7 @@ module Sass
   module Value
     # Sass's function type.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassFunction
+    # @see https://sass-lang.com/documentation/js-api/classes/sassfunction/
     class Function
       include Value
 

data/lib/sass/value/list.rb

@@ -4,7 +4,7 @@ module Sass
   module Value
     # Sass's list type.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassList
+    # @see https://sass-lang.com/documentation/js-api/classes/sasslist/
     class List
       include Value
 

data/lib/sass/value/map.rb

@@ -4,7 +4,7 @@ module Sass
   module Value
     # Sass's map type.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassMap
+    # @see https://sass-lang.com/documentation/js-api/classes/sassmap/
     class Map
       include Value
 

data/lib/sass/value/null.rb

@@ -4,7 +4,7 @@ module Sass
   module Value
     # Sass's null type.
     #
-    # @see https://sass-lang.com/documentation/js-api/modules#sassNull
+    # @see https://sass-lang.com/documentation/js-api/variables/sassnull/
     class Null
       include Value
 

data/lib/sass/value/number.rb

@@ -6,9 +6,10 @@ module Sass
   module Value
     # Sass's number type.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassNumber
+    # @see https://sass-lang.com/documentation/js-api/classes/sassnumber/
     class Number
       include Value
+      include CalculationValue
 
       # @param value [Numeric]
       # @param unit [::String, Hash]

data/lib/sass/value/string.rb

@@ -4,9 +4,10 @@ module Sass
   module Value
     # Sass's string type.
     #
-    # @see https://sass-lang.com/documentation/js-api/classes/SassString
+    # @see https://sass-lang.com/documentation/js-api/classes/sassstring/
     class String
       include Value
+      include CalculationValue
 
       # @param text [::String]
       # @param quoted [::Boolean]
@@ -38,6 +39,14 @@ module Sass
         self
       end
 
+      # @return [CalculationValue]
+      # @raise [ScriptError]
+      def assert_calculation_value(_name = nil)
+        raise Sass::ScriptError, "Expected #{self} to be an unquoted string." if quoted?
+
+        self
+      end
+
       # @param sass_index [Number]
       # @return [Integer]
       def sass_index_to_string_index(sass_index, name = nil)

data/lib/sass/value.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'calculation_value'
 require_relative 'script_error'
 
 module Sass
   # The abstract base class of Sass's value types.
   #
-  # @see https://sass-lang.com/documentation/js-api/classes/Value
+  # @see https://sass-lang.com/documentation/js-api/classes/value/
   module Value
     # @return [::String, nil]
     def separator
@@ -60,11 +61,18 @@ module Sass
       raise Sass::ScriptError.new("#{self} is not a boolean", name)
     end
 
+    # @return [Calculation]
     # @raise [ScriptError]
     def assert_calculation(name = nil)
       raise Sass::ScriptError.new("#{self} is not a calculation", name)
     end
 
+    # @return [CalculationValue]
+    # @raise [ScriptError]
+    def assert_calculation_value(name = nil)
+      raise Sass::ScriptError.new("#{self} is not a calculation value", name)
+    end
+
     # @return [Color]
     # @raise [ScriptError]
     def assert_color(name = nil)
@@ -119,6 +127,7 @@ end
 require_relative 'value/list'
 require_relative 'value/argument_list'
 require_relative 'value/boolean'
+require_relative 'value/calculation'
 require_relative 'value/color'
 require_relative 'value/function'
 require_relative 'value/fuzzy_math'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 1.63.5
+  version: 1.64.0
 platform: ruby
 authors:
 - なつき
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-21 00:00:00.000000000 Z
+date: 2023-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -57,6 +57,9 @@ files:
 - ext/sass/package.json
 - ext/sass/win32_api.rb
 - lib/sass-embedded.rb
+- lib/sass/calculation_value.rb
+- lib/sass/calculation_value/calculation_interpolation.rb
+- lib/sass/calculation_value/calculation_operation.rb
 - lib/sass/compile_error.rb
 - lib/sass/compile_result.rb
 - lib/sass/elf.rb
@@ -81,6 +84,7 @@ files:
 - lib/sass/value.rb
 - lib/sass/value/argument_list.rb
 - lib/sass/value/boolean.rb
+- lib/sass/value/calculation.rb
 - lib/sass/value/color.rb
 - lib/sass/value/function.rb
 - lib/sass/value/fuzzy_math.rb
@@ -94,8 +98,8 @@ homepage: https://github.com/ntkme/sass-embedded-host-ruby
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://rubydoc.info/gems/sass-embedded/1.63.5
-  source_code_uri: https://github.com/ntkme/sass-embedded-host-ruby/tree/v1.63.5
+  documentation_uri: https://rubydoc.info/gems/sass-embedded/1.64.0
+  source_code_uri: https://github.com/ntkme/sass-embedded-host-ruby/tree/v1.64.0
   funding_uri: https://github.com/sponsors/ntkme
 post_install_message: 
 rdoc_options: []
@@ -105,14 +109,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: Use dart-sass with Ruby!