Ubuntu Manpage: libsass - libsass Documentation

name
features
install
examples
user's guide
references
credit
open source
indices and tables
author
copyright

Provided by: python3-libsass_0.23.0-0.1_amd64

NAME

       libsass - libsass Documentation

       This package provides a simple Python extension module sass which is binding LibSass (written in C/C++ by
       Hampton Catlin and Aaron Leung).  It's very straightforward and  there  isn't  any  headache  related  to
       Python   distribution/deployment.    That   means   you   can  add  just  libsass  into  your  setup.py's
       install_requires list or requirements.txt file.

       It currently supports CPython 3.7+ and PyPy 3!

FEATURES

       • You don't need any Ruby/Node.js stack at all, for development or deployment either.

       • Fast. (LibSass is written in C++.)

       • Simple API.  See example code for details.

       • Custom functions.

       • @import callbacks.

       • Support both tabbed (Sass) and braces (SCSS) syntax.

       • WSGI middleware for ease of development.  It automatically compiles Sass/SCSS files for  each  request.
         See also sassutils.wsgi for details.

       • setuptools/distutils integration.  You can build all Sass/SCSS files using setup.py build_sass command.
         See also sassutils.distutils for details.

       • Works also on PyPy.

       • Provides prebuilt wheel (PEP 427) binaries for Windows and Mac.

INSTALL

       It's available on PyPI, so you can install it using pip:

          $ pip install libsass

       NOTE:
          libsass requires some features introduced by the recent C++ standard.  You need a  C++  compiler  that
          support those features.  See also libsass project's README file.

EXAMPLES

   Compile a String of Sass to CSS
       >>> import sass
       >>> sass.compile(string='a { b { color: blue; } }')
       'a b {\n  color: blue; }\n'

   Compile a Directory of Sass Files to CSS
       >>> import sass
       >>> import os
       >>> os.mkdir('css')
       >>> os.mkdir('sass')
       >>> scss = """\
       ... $theme_color: #cc0000;
       ... body {
       ...     background-color: $theme_color;
       ... }
       ... """
       >>> with open('sass/example.scss', 'w') as example_scss:
       ...      example_scss.write(scss)
       ...
       >>> sass.compile(dirname=('sass', 'css'), output_style='compressed')
       >>> with open('css/example.css') as example_css:
       ...     print(example_css.read())
       ...
       body{background-color:#c00}

USER'S GUIDE

Using with Flask
This guide explains how to use libsass with the Flask web framework. sassutils package provides several
tools that can be integrated into web applications written in Flask.

Contents
• Using with Flask

• Directory layout

• Defining manifest

• Building Sass/SCSS for each request

• Building Sass/SCSS for each deployment

Directory layout
Imagine the project contained in such directory layout:

• setup.py

• myapp/

• __init__.py

• static/

• sass/

• css/

• templates/

Sass/SCSS files will go inside myapp/static/sass/ directory. Compiled CSS files will go inside
myapp/static/css/ directory. CSS files can be regenerated, so add myapp/static/css/ into your ignore
list like .gitignore or .hgignore.

Defining manifest
The sassutils defines a concept named manifest. Manifest is the build settings of Sass/SCSS. It
specifies some paths related to building Sass/SCSS:

• The path of the directory which contains Sass/SCSS source files.

• The path of the directory which the compiled CSS files will go.

• The path, exposed to HTTP (through WSGI), of the directory that will contain the compiled CSS files.

Every package may have its own manifest. Paths have to be relative to the path of the package.

For example, in the above project, the package name is myapp. The path of the package is myapp/. The
path of the Sass/SCSS directory is static/sass/ (relative to the package directory). The path of the CSS
directory is static/css/. The exposed path is /static/css.

These settings can be represented as the following manifests:

{
'myapp': ('static/sass', 'static/css', '/static/css')
}

As you can see the above, the set of manifests are represented in dictionary, in which the keys are
packages names and the values are tuples of paths.

Building Sass/SCSS for each request
SEE ALSO:

Flask --- Hooking in WSGI Middlewares
The section which explains how to integrate WSGI middlewares to Flask.

Flask --- flask:app-dispatch
The documentation which explains how Flask dispatches each request internally.

In development, manually building Sass/SCSS files for each change is a tedious task. SassMiddleware
makes the web application build Sass/SCSS files for each request automatically. It's a WSGI middleware,
so it can be plugged into the web app written in Flask.

SassMiddleware takes two required parameters:

• The WSGI-compliant callable object.

• The set of manifests represented as a dictionary.

So:

from flask import Flask
from sassutils.wsgi import SassMiddleware

app = Flask(__name__)

app.wsgi_app = SassMiddleware(app.wsgi_app, {
'myapp': ('static/sass', 'static/css', '/static/css')
})

And then, if you want to link a compiled CSS file, use the url_for() function:

NOTE:
The linked filename is style.scss.css, not just style.scss. All compiled filenames have trailing .css
suffix.

Building Sass/SCSS for each deployment
NOTE:
This section assumes that you use setuptools for deployment.

REFERENCES

   pysassc --- SassC compliant command line interface
       This provides SassC compliant CLI executable named pysassc:

          $ pysassc
          Usage: pysassc [options] SCSS_FILE [CSS_FILE]

       There are options as well:

       -t <style>, --style <style>
              Coding style of the compiled result.  The same as sass.compile() function's  output_style  keyword
              argument.  Default is nested.

       -s <style>, --output-style <style>
              Alias for -t / --style.

              Deprecated since version 0.11.0.

       -I <dir>, --include-path <dir>
              Optional directory path to find @imported (S)CSS files.  Can be multiply used.

       -m, -g, --sourcemap
              Emit  source map.  Requires the second argument (output CSS filename).  The filename of source map
              will be the output CSS filename followed by .map.

              Added in version 0.4.0.

       -p, --precision
              Set the precision for numbers. Default is 5.

              Added in version 0.7.0.

       --source-comments
              Include debug info in output.

              Added in version 0.11.0.

       --sourcemap-file
              Output file for source map

              Added in version 0.17.0.

       --sourcemap-contents
              Embed sourcesContent in source map.

              Added in version 0.17.0.

       --sourcemap-embed
              Embed sourceMappingUrl as data URI

              Added in version 0.17.0.

       --omit-sourcemap-url
              Omit source map URL comment from output

              Added in version 0.17.0.

       --sourcemap-root
              Base path, will be emitted to sourceRoot in source-map as is

              Added in version 0.17.0.

       -v, --version
              Prints the program version.

       -h, --help
              Prints the help message.

   sass --- Binding of libsass
       This simple C extension module provides a very simple binding of libsass, which is written in C/C++.   It
       contains only one function and one exception type.

       >>> import sass
       >>> sass.compile(string='a { b { color: blue; } }')
       'a b {
         color: blue; }
       '

       exception sass.CompileError(msg)
              The exception type that is raised by compile().  It is a subtype of exceptions.ValueError.

       sass.MODES = frozenset({'dirname', 'filename', 'string'})
              (frozenset) The set of keywords compile() can take.

       sass.OUTPUT_STYLES = {'compact': 2, 'compressed': 3, 'expanded': 1, 'nested': 0}
              (collections.abc.Mapping)  The  dictionary  of  output  styles.  Keys are output name strings, and
              values are flag integers.

       sass.SOURCE_COMMENTS = {'default': 1, 'line_numbers': 1, 'map': 2, 'none': 0}
              (collections.abc.Mapping) The dictionary of source comments styles.   Keys  are  mode  names,  and
              values are corresponding flag integers.

              Added in version 0.4.0.

              Deprecated since version 0.6.0.

       class sass.SassColor(r, g, b, a)

       class sass.SassError(msg)

       class sass.SassFunction(name, arguments, callable_)
              Custom function for Sass.  It can be instantiated using from_lambda() and from_named_function() as
              well.

              Parameters

                     • name (str) -- the function name

                     • arguments (collections.abc.Sequence) -- the argument names

                     • callable (collections.abc.Callable) -- the actual function to be called

              Added in version 0.7.0.

              classmethod from_lambda(name, lambda_)
                     Make a SassFunction object from the given lambda_ function.  Since lambda  functions  don't
                     have their name, it need its name as well.  Arguments are automatically inspected.

                     Parameters

                            • name (str) -- the function name

                            • lambda (types.LambdaType) -- the actual lambda function to be called

                     Returns
                            a custom function wrapper of the lambda_ function

                     Return type
                            SassFunction

              classmethod from_named_function(function)
                     Make  a  SassFunction  object  from  the  named  function.  Function name and arguments are
                     automatically inspected.

                     Parameters
                            function (types.FunctionType) -- the named function to be called

                     Returns
                            a custom function wrapper of the function

                     Return type
                            SassFunction

              property signature
                     Signature string of the function.

       class sass.SassList(items, separator, bracketed=False)

       class sass.SassMap(*args, **kwargs)
              Because sass maps can have mapping types as keys, we need an immutable hashable mapping type.

              Added in version 0.7.0.

       class sass.SassNumber(value, unit)

       class sass.SassWarning(msg)

       sass.and_join(strings)
              Join the given strings by commas with last ' and ' conjunction.

              >>> and_join(['Korea', 'Japan', 'China', 'Taiwan'])
              'Korea, Japan, China, and Taiwan'

              Parameters
                     strings -- a list of words to join

              Returns
                     a joined string

              Return type
                     str, basestring

       sass.compile(**kwargs)
              There are three modes of parameters compile() can take: string, filename, and dirname.

              The string parameter is the most basic way to compile Sass.  It simply  takes  a  string  of  Sass
              code, and then returns a compiled CSS string.

              Parameters

                     • string  (str)  --  Sass  source  code to compile.  it's exclusive to filename and dirname
                       parameters

                     • output_style (str) -- an optional coding style of the compiled result.   choose  one  of:
                       'nested' (default), 'expanded', 'compact', 'compressed'

                     • source_comments (bool) -- whether to add comments about source lines.  False by default

                     • source_map_contents (bool) -- embed include contents in map

                     • source_map_embed (bool) -- embed sourceMappingUrl as data URI

                     • omit_source_map_url (bool) -- omit source map URL comment from output

                     • source_map_root (str) -- base path, will be emitted in source map as is

                     • include_paths  (collections.abc.Sequence)  -- an optional list of paths to find @imported
                       Sass/CSS source files

                     • precision (int) -- optional precision for numbers. 5 by default.

                     • custom_functions (set,  collections.abc.Sequence,  collections.abc.Mapping)  --  optional
                       mapping of custom functions.  see also below custom functions description

                     • custom_import_extensions -- (ignored, for backward compatibility)

                     • indented  (bool)  --  optional  declaration  that the string is Sass, not SCSS formatted.
                       False by default

                     • importers (collections.abc.Callable) -- optional  callback  functions.   see  also  below
                       importer callbacks description

              Returns
                     the compiled CSS string

              Return type
                     str

              Raises sass.CompileError  --  when  it fails for any reason (for example the given Sass has broken
                     syntax)

              The filename is the most commonly used way.  It takes a string of Sass filename, and then  returns
              a compiled CSS string.

              Parameters

                     • filename  (str) -- the filename of Sass source code to compile.  it's exclusive to string
                       and dirname parameters

                     • output_style (str) -- an optional coding style of the compiled result.   choose  one  of:
                       'nested' (default), 'expanded', 'compact', 'compressed'

                     • source_comments (bool) -- whether to add comments about source lines.  False by default

                     • source_map_filename (str) -- use source maps and indicate the source map output filename.
                       None means not using source maps.  None by default.

                     • source_map_contents (bool) -- embed include contents in map

                     • source_map_embed (bool) -- embed sourceMappingUrl as data URI

                     • omit_source_map_url (bool) -- omit source map URL comment from output

                     • source_map_root (str) -- base path, will be emitted in source map as is

                     • include_paths (collections.abc.Sequence) -- an optional list of paths to  find  @imported
                       Sass/CSS source files

                     • precision (int) -- optional precision for numbers. 5 by default.

                     • custom_functions  (set,  collections.abc.Sequence,  collections.abc.Mapping)  -- optional
                       mapping of custom functions.  see also below custom functions description

                     • custom_import_extensions -- (ignored, for backward compatibility)

                     • importers (collections.abc.Callable) -- optional  callback  functions.   see  also  below
                       importer callbacks description

              Returns
                     the  compiled CSS string, or a pair of the compiled CSS string and the source map string if
                     source_map_filename is set

              Return type
                     str, tuple

              Raises

                     • sass.CompileError -- when it fails for any reason (for example the given Sass has  broken
                       syntax)

                     • exceptions.IOError -- when the filename doesn't exist or cannot be read

              The  dirname  is  useful for automation.  It takes a pair of paths.  The first of the dirname pair
              refers the source directory, contains several Sass source files to compiled.   Sass  source  files
              can  be  nested  in directories.  The second of the pair refers the output directory that compiled
              CSS files would be saved.  Directory tree structure of the source directory will be maintained  in
              the output directory as well.  If dirname parameter is used the function returns None.

              Parameters

                     • dirname  (tuple)  --  a  pair  of (source_dir, output_dir).  it's exclusive to string and
                       filename parameters

                     • output_style (str) -- an optional coding style of the compiled result.   choose  one  of:
                       'nested' (default), 'expanded', 'compact', 'compressed'

                     • source_comments (bool) -- whether to add comments about source lines.  False by default

                     • source_map_contents (bool) -- embed include contents in map

                     • source_map_embed (bool) -- embed sourceMappingUrl as data URI

                     • omit_source_map_url (bool) -- omit source map URL comment from output

                     • source_map_root (str) -- base path, will be emitted in source map as is

                     • include_paths  (collections.abc.Sequence)  -- an optional list of paths to find @imported
                       Sass/CSS source files

                     • precision (int) -- optional precision for numbers. 5 by default.

                     • custom_functions (set,  collections.abc.Sequence,  collections.abc.Mapping)  --  optional
                       mapping of custom functions.  see also below custom functions description

                     • custom_import_extensions -- (ignored, for backward compatibility)

              Raises sass.CompileError  --  when  it fails for any reason (for example the given Sass has broken
                     syntax)

              The custom_functions parameter can take three types of forms:

              set/Sequence of SassFunctions
                 It is the most general form.  Although pretty verbose, it can take any kind of  callables  like
                 type objects, unnamed functions, and user-defined callables.

                     sass.compile(
                         ...,
                         custom_functions={
                             sass.SassFunction('func-name', ('$a', '$b'), some_callable),
                             ...
                         }
                     )

              Mapping of names to functions
                     Less general, but easier-to-use form.  Although it's not it can take any kind of callables,
                     it can take any kind  of  functions  defined  using  def/lambda  syntax.   It  cannot  take
                     callables other than them since inspecting arguments is not always available for every kind
                     of callables.

                        sass.compile(
                            ...,
                            custom_functions={
                                'func-name': lambda a, b: ...,
                                ...
                            }
                        )

              set/Sequence of named functions
                 Not general, but the  easiest-to-use  form  for  named  functions.   It  can  take  only  named
                 functions, defined using def.  It cannot take lambdas sinc names are unavailable for them.

                     def func_name(a, b):
                         return ...

                     sass.compile(
                         ...,
                         custom_functions={func_name}
                     )

              Newer  versions of libsass allow developers to define callbacks to be called and given a chance to
              process @import directives. You can define yours by  passing  in  a  list  of  callables  via  the
              importers parameter. The callables must be passed as 2-tuples in the form:

                 (priority_int, callback_fn)

              A priority of zero is acceptable; priority determines the order callbacks are attempted.

              These  callbacks  can  accept one or two string arguments. The first argument is the path that was
              passed to the @import directive; the second (optional) argument is  the  previous  resolved  path,
              where  the @import directive was found. The callbacks must either return None to indicate the path
              wasn't handled by that callback (to  continue  with  others  or  fall  back  on  internal  libsass
              filesystem behaviour) or a list of one or more tuples, each in one of three forms:

              • A 1-tuple representing an alternate path to handle internally; or,

              • A 2-tuple representing an alternate path and the content that path represents; or,

              • A 3-tuple representing the same as the 2-tuple with the addition of a "sourcemap".

              All tuple return values must be strings. As a not overly realistic example:

                 def my_importer(path, prev):
                     return [(path, '#' + path + ' { color: red; }')]

                 sass.compile(
                         ...,
                         importers=[(0, my_importer)]
                     )

              Now,  within the style source, attempting to @import 'button'; will instead attach color: red as a
              property of an element with the imported name.

              Added in version 0.4.0: Added source_comments and source_map_filename parameters.

              Changed in version 0.6.0: The source_comments parameter becomes to take only bool instead of str.

              Deprecated  since  version  0.6.0:  Values  like  'none',  'line_numbers',  and  'map'   for   the
              source_comments parameter are deprecated.

              Added in version 0.7.0: Added precision parameter.

              Added in version 0.7.0: Added custom_functions parameter.

              Added in version 0.11.0: source_map_filename no longer implies source_comments.

              Added  in  version  0.17.0:  Added source_map_contents, source_map_embed, omit_source_map_url, and
              source_map_root parameters.

              Added in version 0.18.0: The importer callbacks can now take a second  argument,  the  previously-
              resolved path, so that importers can do relative path resolution.

   sassutils --- Additional utilities related to Sass
       This  package  provides  several additional utilities related to Sass which depends on libsass core (sass
       module).

   sassutils.builder --- Build the whole directory
       class sassutils.builder.Manifest(sass_path, css_path=None, wsgi_path=None, strip_extension=None)
              Building manifest of Sass/SCSS.

              Parameters

                     • sass_path (str, basestring) -- the path of the directory that contains  Sass/SCSS  source
                       files

                     • css_path (str, basestring) -- the path of the directory to store compiled CSS files

                     • strip_extension (bool) -- whether to remove the original file extension

              build(package_dir, output_style='nested')
                     Builds  the  Sass/SCSS  files  in  the specified sass_path.  It finds sass_path and locates
                     css_path as relative to the given package_dir.

                     Parameters

                            • package_dir (str, basestring) -- the path of package directory

                            • output_style (str) -- an optional coding style of the compiled result.  choose one
                              of: 'nested' (default), 'expanded', 'compact', 'compressed'

                     Returns
                            the set of compiled CSS filenames

                     Return type
                            frozenset

                     Added in version 0.6.0: The output_style parameter.

              build_one(package_dir, filename, source_map=False)
                     Builds one Sass/SCSS file.

                     Parameters

                            • package_dir (str, basestring) -- the path of package directory

                            • filename (str, basestring) -- the filename of Sass/SCSS source to compile

                            • source_map  (bool)  -- whether to use source maps.  if True it also write a source
                              map to a filename followed by .map suffix.  default is False

                     Returns
                            the filename of compiled CSS

                     Return type
                            str, basestring

                     Added in version 0.4.0: Added optional source_map parameter.

              resolve_filename(package_dir, filename)
                     Gets a proper full relative path of Sass source and CSS  source  that  will  be  generated,
                     according to package_dir and filename.

                     Parameters

                            • package_dir (str, basestring) -- the path of package directory

                            • filename (str, basestring) -- the filename of Sass/SCSS source to compile

                     Returns
                            a pair of (sass, css) path

                     Return type
                            tuple

              unresolve_filename(package_dir, filename)
                     Retrieves  the  probable  source path from the output filename.  Pass in a .css path to get
                     out a .scss path.

                     Parameters

                            • package_dir (str) -- the path of the package directory

                            • filename (str) -- the css filename

                     Returns
                            the scss filename

                     Return type
                            str

       sassutils.builder.SUFFIXES = frozenset({'sass', 'scss'})
              (frozenset) The set of supported filename suffixes.

       sassutils.builder.SUFFIX_PATTERN = re.compile('[.](sass|scss)$')
              (re.RegexObject) The regular expression pattern which matches to filenames of supported SUFFIXES.

       sassutils.builder.build_directory(sass_path,    css_path,     output_style='nested',     _root_sass=None,
       _root_css=None, strip_extension=False)
              Compiles all Sass/SCSS files in path to CSS.

              Parameters

                     • sass_path  (str,  basestring) -- the path of the directory which contains source files to
                       compile

                     • css_path (str, basestring) -- the path of the directory compiled CSS files will go

                     • output_style (str) -- an optional coding style of the compiled result.   choose  one  of:
                       'nested' (default), 'expanded', 'compact', 'compressed'

              Returns
                     a dictionary of source filenames to compiled CSS filenames

              Return type
                     collections.abc.Mapping

              Added in version 0.6.0: The output_style parameter.

   sassutils.distutils --- setuptools/distutils integration
       This  module  provides  extensions (and some magical monkey-patches, sorry) of the standard distutils and
       setuptools (now it's named Distribute) for libsass.

       To use this, add libsass into setup_requires (not install_requires) option of the setup.py script:

          from setuptools import setup

          setup(
              # ...,
              setup_requires=['libsass >= 0.6.0']
          )

       It will adds build_sass command to the setup.py script:

          $ python setup.py build_sass

       This commands builds Sass/SCSS files to compiled CSS files of the project and makes the  package  archive
       (made by sdist, bdist, and so on) to include these compiled CSS files.

       To  set  the  directory  of Sass/SCSS source files and the directory to store compiled CSS files, specify
       sass_manifests option:

          from setuptools import find_packages, setup

          setup(
              name='YourPackage',
              packages=find_packages(),
              sass_manifests={
                  'your.webapp': ('static/sass', 'static/css')
              },
              setup_requires=['libsass >= 0.6.0']
          )

       The option should be a mapping of package names to pairs of paths, e.g.:

          {
              'package': ('static/sass', 'static/css'),
              'package.name': ('static/scss', 'static')
          }

       The option can also be a mapping of package names to manifest dictionaries:

          {
              'package': {
                  'sass_path': 'static/sass',
                  'css_path': 'static/css',
                  'strip_extension': True,
              },
          }

       Added in version 0.15.0: Added strip_extension so a.scss is compiled  to  a.css  instead  of  a.scss.css.
       This option will default to True in the future.

       Added in version 0.6.0: Added --output-style/-s option to build_sass command.

       class sassutils.distutils.build_sass(dist: Distribution, **kw)
              Builds Sass/SCSS files to CSS files.

              finalize_options()
                     Set  final  values  for all options/attributes used by the command.  Most of the time, each
                     option/attribute/cache should only be set if it does  not  have  any  value  yet  (e.g.  if
                     self.attr is None: self.attr = val).

              get_package_dir(package)
                     Returns  the  directory,  relative  to  the  top  of the source distribution, where package
                     package should be found (at least according to the package_dir option, if any).

                     Copied from distutils.command.build_py.get_package_dir() method.

              initialize_options()
                     Set or (reset) all options/attributes/caches used by the command to their  default  values.
                     Note that these values may be overwritten during the build.

              run()  Execute  the  actions  intended  by the command.  (Side effects SHOULD only take place when
                     run() is executed, for example, creating new files or writing to the terminal output).

       sassutils.distutils.validate_manifests(dist, attr, value)
              Verifies that value is an expected mapping of package to sassutils.builder.Manifest.

   sassutils.wsgi --- WSGI middleware for development purpose
       class sassutils.wsgi.SassMiddleware(app, manifests, package_dir={}, error_status='200 OK')
              WSGI middleware for development purpose.  Every time a CSS file has requested it finds  a  matched
              Sass/SCSS source file and then compiled it into CSS.

              It shows syntax errors in three ways:

              Heading comment
                     The result CSS includes detailed error message in the heading CSS comment e.g.:

                        /*
                        Error: invalid property name
                        */

              Red text in body:before
                     The result CSS draws detailed error message in :before pseudo-class of body element e.g.:

                        body:before {
                            content: 'Error: invalid property name';
                            color: maroon;
                            background-color: white;
                        }

                     In  most  cases  you  could  be  aware  of syntax error by refreshing your working document
                     because it will removes all other styles and leaves only a red text.

              logging
                     It logs syntax errors if exist during compilation to  sassutils.wsgi.SassMiddleware  logger
                     with level ERROR.

                     To enable this:

                        from logging import Formatter, StreamHandler, getLogger
                        logger = getLogger('sassutils.wsgi.SassMiddleware')
                        handler = StreamHandler(level=logging.ERROR)
                        formatter = Formatter(fmt='*' * 80 + '\n%(message)s\n' + '*' * 80)
                        handler.setFormatter(formatter)
                        logger.addHandler(handler)

                     Or simply:

                        import logging
                        logging.basicConfig()

              Parameters

                     • app (collections.abc.Callable) -- the WSGI application to wrap

                     • manifests  (collections.abc.Mapping)  --  build  settings.   the  same format to setup.py
                       script's sass_manifests option

                     • package_dir  (collections.abc.Mapping)  --  optional  mapping   of   package   names   to
                       directories.  the same format to setup.py script's package_dir option

              Changed in version 0.4.0: It creates also source map files with filenames followed by .map suffix.

              Added   in   version   0.8.0:   It   logs   syntax   errors   if   exist   during  compilation  to
              sassutils.wsgi.SassMiddleware logger with level ERROR.

              static quote_css_string(s)
                     Quotes a string as CSS string literal.

CREDIT

       Hong Minhee wrote this Python binding of LibSass.

       Hampton Catlin and Aaron Leung wrote LibSass, which is portable C/C++ implementation of Sass.

       Hampton Catlin originally designed Sass language and wrote the first reference implementation  of  it  in
       Ruby.

       The above three  are all distributed under MIT license.

OPEN SOURCE

       GitHub (Git repository + issues)
              https://github.com/sass/libsass-python

       GitHub Actions (linux + macos + windows)
          Build Status.UNINDENT

       PyPI   https://pypi.org/pypi/libsass/ PyPI.TP Changelog Changelog

INDICES AND TABLES

       • Index

       • Module Index

       • Search Page

AUTHOR

       Hong Minhee

COPYRIGHT

       2024, Hong Minhee