sass-embedded 1.74.1-x86_64-cygwin

data/lib/sass/elf.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {ELF} class.
+  #
+  # It parses ELF header to extract interpreter.
+  # @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
+    # rubocop:disable Naming/ConstantName
+
+    # 32-bit ELF base types.
+    Elf32_Addr  = :__u32
+    Elf32_Half  = :__u16
+    Elf32_Off   = :__u32
+    Elf32_Sword = :__s32
+    Elf32_Word  = :__u32
+
+    # 64-bit ELF base types.
+    Elf64_Addr   = :__u64
+    Elf64_Half   = :__u16
+    Elf64_SHalf  = :__s16
+    Elf64_Off    = :__u64
+    Elf64_Sword  = :__s32
+    Elf64_Word   = :__u32
+    Elf64_Xword  = :__u64
+    Elf64_Sxword = :__s64
+
+    # rubocop:enable Naming/ConstantName
+
+    # These constants are for the segment types stored in the image headers
+    PT_NULL         = 0
+    PT_LOAD         = 1
+    PT_DYNAMIC      = 2
+    PT_INTERP       = 3
+    PT_NOTE         = 4
+    PT_SHLIB        = 5
+    PT_PHDR         = 6
+    PT_TLS          = 7
+    PT_LOOS         = 0x60000000
+    PT_HIOS         = 0x6fffffff
+    PT_LOPROC       = 0x70000000
+    PT_HIPROC       = 0x7fffffff
+    PT_GNU_EH_FRAME = (PT_LOOS + 0x474e550)
+    PT_GNU_STACK    = (PT_LOOS + 0x474e551)
+    PT_GNU_RELRO    = (PT_LOOS + 0x474e552)
+    PT_GNU_PROPERTY = (PT_LOOS + 0x474e553)
+
+    # These constants define the different elf file types
+    ET_NONE   = 0
+    ET_REL    = 1
+    ET_EXEC   = 2
+    ET_DYN    = 3
+    ET_CORE   = 4
+    ET_LOPROC = 0xff00
+    ET_HIPROC = 0xffff
+
+    EI_NIDENT = 16
+
+    # rubocop:disable Naming/ConstantName
+
+    Elf32_Ehdr = [
+      [:unsigned_char, :e_ident, EI_NIDENT],
+      [Elf32_Half,     :e_type],
+      [Elf32_Half,     :e_machine],
+      [Elf32_Word,     :e_version],
+      [Elf32_Addr,     :e_entry],
+      [Elf32_Off,      :e_phoff],
+      [Elf32_Off,      :e_shoff],
+      [Elf32_Word,     :e_flags],
+      [Elf32_Half,     :e_ehsize],
+      [Elf32_Half,     :e_phentsize],
+      [Elf32_Half,     :e_phnum],
+      [Elf32_Half,     :e_shentsize],
+      [Elf32_Half,     :e_shnum],
+      [Elf32_Half,     :e_shstrndx]
+    ].freeze
+
+    Elf64_Ehdr = [
+      [:unsigned_char, :e_ident, EI_NIDENT],
+      [Elf64_Half,     :e_type],
+      [Elf64_Half,     :e_machine],
+      [Elf64_Word,     :e_version],
+      [Elf64_Addr,     :e_entry],
+      [Elf64_Off,      :e_phoff],
+      [Elf64_Off,      :e_shoff],
+      [Elf64_Word,     :e_flags],
+      [Elf64_Half,     :e_ehsize],
+      [Elf64_Half,     :e_phentsize],
+      [Elf64_Half,     :e_phnum],
+      [Elf64_Half,     :e_shentsize],
+      [Elf64_Half,     :e_shnum],
+      [Elf64_Half,     :e_shstrndx]
+    ].freeze
+
+    Elf32_Phdr = [
+      [Elf32_Word, :p_type],
+      [Elf32_Off,  :p_offset],
+      [Elf32_Addr, :p_vaddr],
+      [Elf32_Addr, :p_paddr],
+      [Elf32_Word, :p_filesz],
+      [Elf32_Word, :p_memsz],
+      [Elf32_Word, :p_flags],
+      [Elf32_Word, :p_align]
+    ].freeze
+
+    Elf64_Phdr = [
+      [Elf64_Word,  :p_type],
+      [Elf64_Word,  :p_flags],
+      [Elf64_Off,   :p_offset],
+      [Elf64_Addr,  :p_vaddr],
+      [Elf64_Addr,  :p_paddr],
+      [Elf64_Xword, :p_filesz],
+      [Elf64_Xword, :p_memsz],
+      [Elf64_Xword, :p_align]
+    ].freeze
+
+    # rubocop:enable Naming/ConstantName
+
+    # e_ident[] indexes
+    EI_MAG0    = 0
+    EI_MAG1    = 1
+    EI_MAG2    = 2
+    EI_MAG3    = 3
+    EI_CLASS   = 4
+    EI_DATA    = 5
+    EI_VERSION = 6
+    EI_OSABI   = 7
+    EI_PAD     = 8
+
+    # EI_MAG
+    ELFMAG0 = 0x7f
+    ELFMAG1 = 'E'.ord
+    ELFMAG2 = 'L'.ord
+    ELFMAG3 = 'F'.ord
+    ELFMAG  = [ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3].pack('C*')
+    SELFMAG = 4
+
+    # e_ident[EI_CLASS]
+    ELFCLASSNONE = 0
+    ELFCLASS32   = 1
+    ELFCLASS64   = 2
+    ELFCLASSNUM  = 3
+
+    # e_ident[EI_DATA]
+    ELFDATANONE = 0
+    ELFDATA2LSB = 1
+    ELFDATA2MSB = 2
+
+    def initialize(buffer)
+      @buffer = buffer
+      @ehdr = read_ehdr
+      @buffer.seek(@ehdr[:e_phoff], IO::SEEK_SET)
+      @proghdrs = Array.new(@ehdr[:e_phnum]) do
+        read_phdr
+      end
+    end
+
+    def relocatable?
+      @ehdr[:e_type] == ET_REL
+    end
+
+    def executable?
+      @ehdr[:e_type] == ET_EXEC
+    end
+
+    def shared_object?
+      @ehdr[:e_type] == ET_DYN
+    end
+
+    def core?
+      @ehdr[:e_type] == ET_CORE
+    end
+
+    def interpreter
+      phdr = @proghdrs.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])
+      raise ArgumentError unless interpreter.end_with?("\0")
+
+      interpreter.chomp!("\0")
+    end
+
+    private
+
+    def file_class
+      @ehdr[:e_ident][EI_CLASS]
+    end
+
+    def data_encoding
+      @ehdr[:e_ident][EI_DATA]
+    end
+
+    def read_ehdr
+      @ehdr = { e_ident: @buffer.read(EI_NIDENT).unpack('C*') }
+      raise ArgumentError unless @ehdr[:e_ident].slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+
+      case file_class
+      when ELFCLASS32
+        Elf32_Ehdr
+      when ELFCLASS64
+        Elf64_Ehdr
+      else
+        raise ArgumentError
+      end.drop(1).to_h do |field|
+        [field[1], read1(field[0])]
+      end.merge!(@ehdr)
+    end
+
+    def read_phdr
+      case file_class
+      when ELFCLASS32
+        Elf32_Phdr
+      when ELFCLASS64
+        Elf64_Phdr
+      else
+        raise ArgumentError
+      end.to_h do |field|
+        [field[1], read1(field[0])]
+      end
+    end
+
+    def explicit_endian
+      case data_encoding
+      when ELFDATA2LSB
+        '<'
+      when ELFDATA2MSB
+        '>'
+      else
+        raise ArgumentError
+      end
+    end
+
+    def read1(type)
+      case type
+      when :__u8
+        @buffer.read(1).unpack1('C')
+      when :__u16
+        @buffer.read(2).unpack1("S#{explicit_endian}")
+      when :__u32
+        @buffer.read(4).unpack1("L#{explicit_endian}")
+      when :__u64
+        @buffer.read(8).unpack1("Q#{explicit_endian}")
+      when :__s8
+        @buffer.read(1).unpack1('c')
+      when :__s16
+        @buffer.read(2).unpack1("s#{explicit_endian}")
+      when :__s32
+        @buffer.read(4).unpack1("l#{explicit_endian}")
+      when :__s64
+        @buffer.read(8).unpack1("q#{explicit_endian}")
+      else
+        raise ArgumentError
+      end
+    end
+
+    INTERPRETER = begin
+      proc_self_exe = '/proc/self/exe'
+      if File.exist?(proc_self_exe)
+        File.open(proc_self_exe, 'rb') do |file|
+          elf = ELF.new(file)
+          interpreter = elf.interpreter
+          if interpreter.nil? && elf.shared_object?
+            File.readlink(proc_self_exe)
+          else
+            interpreter
+          end
+        end
+      end
+    end
+  end
+
+  private_constant :ELF
+end

data/lib/sass/embedded/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sass
+  module Embedded
+    VERSION = '1.74.1'
+  end
+end

data/lib/sass/embedded.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative 'compiler'
+
+# The Sass module.
+#
+# This communicates with Embedded Dart Sass using the Embedded Sass protocol.
+#
+# @example
+#   Sass.compile('style.scss')
+#
+# @example
+#   Sass.compile_string('h1 { font-size: 40px; }')
+module Sass
+  @compiler = nil
+  @mutex = Mutex.new
+
+  # rubocop:disable Layout/LineLength
+  class << self
+    # Compiles the Sass file at +path+ to CSS.
+    # @overload compile(path, load_paths: [], charset: true, source_map: false, source_map_include_sources: false, style: :expanded, functions: {}, importers: [], alert_ascii: false, alert_color: nil, fatal_deprecations: [], future_deprecations: [], logger: nil, quiet_deps: false, silence_deprecations: [], verbose: false)
+    # @param (see Compiler#compile)
+    # @return (see Compiler#compile)
+    # @raise (see Compiler#compile)
+    # @see Compiler#compile
+    def compile(...)
+      compiler.compile(...)
+    end
+
+    # Compiles a stylesheet whose contents is +source+ to CSS.
+    # @overload compile_string(source, importer: nil, load_paths: [], syntax: :scss, url: nil, charset: true, source_map: false, source_map_include_sources: false, style: :expanded, functions: {}, importers: [], alert_ascii: false, alert_color: nil, fatal_deprecations: [], future_deprecations: [], logger: nil, quiet_deps: false, silence_deprecations: [], verbose: false)
+    # @param (see Compiler#compile_string)
+    # @return (see Compiler#compile_string)
+    # @raise (see Compiler#compile_string)
+    # @see Compiler#compile_string
+    def compile_string(...)
+      compiler.compile_string(...)
+    end
+
+    # @param (see Compiler#info)
+    # @return (see Compiler#info)
+    # @raise (see Compiler#info)
+    # @see Compiler#info
+    def info
+      compiler.info
+    end
+
+    private
+
+    def compiler
+      return @compiler if @compiler
+
+      @mutex.synchronize do
+        return @compiler if @compiler
+
+        compiler = Class.new(Compiler) do
+          def initialize
+            @channel = Compiler.const_get(:Channel).new(Class.new(Compiler.const_get(:Dispatcher)) do
+              def initialize
+                super
+
+                idle_timeout = 10
+                @last_accessed_time = current_time
+
+                Thread.new do
+                  Thread.current.name = 'sass-embedded-process-reaper'
+                  duration = idle_timeout
+                  loop do
+                    sleep(duration.negative? ? idle_timeout : duration)
+                    break if @mutex.synchronize do
+                      raise Errno::EBUSY if _closed?
+
+                      duration = idle_timeout - (current_time - @last_accessed_time)
+                      duration.negative? && _idle? && _close
+                    end
+                  end
+                  close
+                rescue Errno::EBUSY
+                  # do nothing
+                end
+              end
+
+              private
+
+              def _idle
+                super
+
+                @last_accessed_time = current_time
+              end
+
+              def current_time
+                Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              end
+            end)
+          end
+        end.new
+
+        at_exit do
+          compiler.close
+        end
+
+        @compiler = compiler
+      end
+    end
+  end
+  # rubocop:enable Layout/LineLength
+end

data/lib/sass/embedded_protocol.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Sass
+  # @see https://github.com/sass/sass/blob/HEAD/spec/embedded-protocol.md
+  module EmbeddedProtocol
+    require_relative '../../ext/sass/embedded_sass_pb'
+  end
+
+  private_constant :EmbeddedProtocol
+end

data/lib/sass/exception.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sass
+  # An exception thrown because a Sass compilation failed.
+  class CompileError < StandardError
+    # @return [String, nil]
+    attr_reader :sass_stack
+
+    # @return [Logger::SourceSpan, nil]
+    attr_reader :span
+
+    # @return [Array<String>]
+    attr_reader :loaded_urls
+
+    # @!visibility private
+    def initialize(message, full_message, sass_stack, span, loaded_urls)
+      super(message)
+
+      @full_message = full_message
+      @sass_stack = sass_stack
+      @span = span
+      @loaded_urls = loaded_urls
+    end
+
+    # @return [String]
+    def full_message(highlight: nil, order: nil, **)
+      return super if @full_message.nil?
+
+      highlight = Exception.respond_to?(:to_tty?) && Exception.to_tty? if highlight.nil?
+      if highlight
+        @full_message.dup
+      else
+        @full_message.gsub(/\e\[[0-9;]*m/, '')
+      end
+    end
+
+    # @return [String]
+    def to_css
+      content = full_message(highlight: false, order: :top)
+
+      <<~CSS.freeze
+        /* #{content.gsub('*/', "*\u2060/").gsub("\r\n", "\n").split("\n").join("\n * ")} */
+
+        body::before {
+          position: static;
+          display: block;
+          padding: 1em;
+          margin: 0 0 1em;
+          border-width: 0 0 2px;
+          border-bottom-style: solid;
+          font-family: monospace, monospace;
+          white-space: pre;
+          content: #{Serializer.serialize_quoted_string(content).gsub(/[^[:ascii:]][\h\t ]?/) do |match|
+            replacement = "\\#{match.ord.to_s(16)}"
+            replacement << " #{match[1]}" if match.length > 1
+            replacement
+          end};
+        }
+      CSS
+    end
+  end
+
+  # An exception thrown by Sass Script.
+  class ScriptError < StandardError
+    def initialize(message, name = nil)
+      super(name.nil? ? message : "$#{name}: #{message}")
+    end
+  end
+end

data/lib/sass/fork_tracker.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {ForkTracker} module.
+  #
+  # It tracks objects that need to be closed after `Process.fork`.
+  module ForkTracker
+    HASH = {}.compare_by_identity
+
+    MUTEX = Mutex.new
+
+    private_constant :HASH, :MUTEX
+
+    module_function
+
+    def add(obj)
+      MUTEX.synchronize do
+        HASH[obj] = true
+      end
+    end
+
+    def delete(obj)
+      MUTEX.synchronize do
+        HASH.delete(obj)
+      end
+    end
+
+    def each(...)
+      MUTEX.synchronize do
+        HASH.keys
+      end.each(...)
+    end
+
+    # The {CoreExt} module.
+    #
+    # It closes objects after `Process.fork`.
+    module CoreExt
+      def _fork
+        pid = super
+        ForkTracker.each(&:close) if pid.zero?
+        pid
+      end
+    end
+
+    private_constant :CoreExt
+
+    Process.singleton_class.prepend(CoreExt) if Process.respond_to?(:_fork)
+  end
+
+  private_constant :ForkTracker
+end

data/lib/sass/logger/silent.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sass
+  # A namespace for built-in Loggers.
+  #
+  # @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
+
+    # A Logger that silently ignores all warnings and debug messages.
+    module Silent
+      module_function
+
+      def warn(message, deprecation: false, span: nil, stack: nil); end
+
+      def debug(message, span: nil); end
+    end
+
+    private_constant :Silent
+  end
+end

data/lib/sass/logger/source_location.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sass
+  module Logger
+    # A specific location within a source file.
+    #
+    # This is always associated with a {SourceSpan} which indicates which file it refers to.
+    #
+    # @see https://sass-lang.com/documentation/js-api/interfaces/sourcelocation/
+    class SourceLocation
+      # @return [Integer]
+      attr_reader :offset, :line, :column
+
+      # @!visibility private
+      def initialize(source_location)
+        @offset = source_location.offset
+        @line = source_location.line
+        @column = source_location.column
+      end
+    end
+  end
+end

data/lib/sass/logger/source_span.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sass
+  module Logger
+    # A span of text within a source file.
+    #
+    # @see https://sass-lang.com/documentation/js-api/interfaces/sourcespan/
+    class SourceSpan
+      # @return [SourceLocation]
+      attr_reader :start, :end
+
+      # @return [String]
+      attr_reader :text
+
+      # @return [String, nil]
+      attr_reader :url, :context
+
+      # @!visibility private
+      def initialize(source_span)
+        @start = source_span.start.nil? ? nil : Logger::SourceLocation.new(source_span.start)
+        @end = source_span.end.nil? ? nil : Logger::SourceLocation.new(source_span.end)
+        @text = source_span.text
+        @url = source_span.url == '' ? nil : source_span.url
+        @context = source_span.context == '' ? nil : source_span.context
+      end
+    end
+  end
+end

data/lib/sass/node_package_importer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sass
+  # The built-in Node.js package importer. This loads pkg: URLs from node_modules
+  # according to the standard Node.js resolution algorithm.
+  #
+  # @see https://sass-lang.com/documentation/js-api/classes/nodepackageimporter/
+  class NodePackageImporter
+    # @param entry_point_directory [String] The directory where the {NodePackageImporter} should start when resolving
+    #   `pkg:` URLs in sources other than files on disk.
+    def initialize(entry_point_directory)
+      raise ArgumentError, 'entry_point_directory must be set' if entry_point_directory.nil?
+
+      @entry_point_directory = File.absolute_path(entry_point_directory)
+    end
+  end
+end

data/lib/sass/serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Serializer} module.
+  module Serializer
+    module_function
+
+    CSS_ESCAPE = {
+      "\0" => "\uFFFD",
+      '\\' => '\\\\',
+      '"' => '\\"',
+      "'" => "\\'",
+      **[*"\x01".."\x08", *"\x0A".."\x1F", "\x7F"].product(
+        [*'0'..'9', *'a'..'f', *'A'..'F', "\t", ' ', nil]
+      ).to_h do |c, x|
+        ["#{c}#{x}".freeze, "\\#{c.ord.to_s(16)}#{" #{x}" if x}".freeze]
+      end
+    }.freeze
+
+    private_constant :CSS_ESCAPE
+
+    def serialize_quoted_string(string)
+      if !string.include?('"') || string.include?("'")
+        %("#{string.gsub(/[\0\\"]|[\x01-\x08\x0A-\x1F\x7F][\h\t ]?/, CSS_ESCAPE)}")
+      else
+        %('#{string.gsub(/[\0\\']|[\x01-\x08\x0A-\x1F\x7F][\h\t ]?/, CSS_ESCAPE)}')
+      end
+    end
+
+    def serialize_unquoted_string(string)
+      string.tr("\0", "\uFFFD").gsub(/\n */, ' ')
+    end
+  end
+
+  private_constant :Serializer
+end

data/lib/sass/value/argument_list.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's argument list type.
+    #
+    # 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/
+    class ArgumentList < List
+      # @param contents [Array<Value>]
+      # @param keywords [Hash<Symbol, Value>]
+      # @param separator [::String]
+      def initialize(contents = [], keywords = {}, separator = ',')
+        super(contents, separator:)
+
+        @id = 0
+        @keywords_accessed = false
+        @keywords = keywords.freeze
+      end
+
+      # @return [Hash<Symbol, Value>]
+      def keywords
+        @keywords_accessed = true
+        @keywords
+      end
+
+      private
+
+      def initialize_dup(orig)
+        @id = 0
+        super
+      end
+    end
+  end
+end