CSS-Sass
view release on metacpan or search on metacpan
lib/CSS/ppport.h
t/00_sanity.t
t/01_xs.t
t/02_perl.t
t/03_xs_functions.t
t/04_xs_value_types.t
t/05_source_maps.t
t/06_sass_import.t
t/07_custom_importer.t
t/08_sass_to_scss.t
t/09_unicode.t
t/98_sass_srcmaps.t
t/99_sass_specs.t
t/inc/_colors.scss
t/inc/sass/comment.sass
t/inc/sass/pretty.sass
t/inc/sass/t-01.sass
t/inc/sass/t-02.sass
t/inc/sass/t-03.sass
t/inc/sass/t-04.sass
t/inc/sass/t-05.sass
t/sass-spec/spec/libsass/color-names/expected.compact.css
t/sass-spec/spec/libsass/color-names/expected.compressed.css
t/sass-spec/spec/libsass/color-names/expected.expanded.css
t/sass-spec/spec/libsass/color-names/expected_output.css
t/sass-spec/spec/libsass/color-names/input.scss
t/sass-spec/spec/libsass/css-import/expected.compact.css
t/sass-spec/spec/libsass/css-import/expected.compressed.css
t/sass-spec/spec/libsass/css-import/expected.expanded.css
t/sass-spec/spec/libsass/css-import/expected_output.css
t/sass-spec/spec/libsass/css-import/input.scss
t/sass-spec/spec/libsass/css_unicode/expected.compact.css
t/sass-spec/spec/libsass/css_unicode/expected.compressed.css
t/sass-spec/spec/libsass/css_unicode/expected.expanded.css
t/sass-spec/spec/libsass/css_unicode/expected_output.css
t/sass-spec/spec/libsass/css_unicode/input.scss
t/sass-spec/spec/libsass/div/expected.compact.css
t/sass-spec/spec/libsass/div/expected.compressed.css
t/sass-spec/spec/libsass/div/expected.expanded.css
t/sass-spec/spec/libsass/div/expected_output.css
t/sass-spec/spec/libsass/div/input.scss
t/sass-spec/spec/libsass/env/expected.compact.css
t/sass-spec/spec/libsass/env/expected.compressed.css
t/sass-spec/spec/libsass/env/expected.expanded.css
t/sass-spec/spec/libsass/env/expected_output.css
t/sass-spec/spec/libsass/env/input.scss
t/sass-spec/spec/misc/selector_only_interpolation/expected.compact.css
t/sass-spec/spec/misc/selector_only_interpolation/expected.compressed.css
t/sass-spec/spec/misc/selector_only_interpolation/expected.expanded.css
t/sass-spec/spec/misc/selector_only_interpolation/expected_output.css
t/sass-spec/spec/misc/selector_only_interpolation/input.scss
t/sass-spec/spec/misc/trailing_comma_in_selector/expected.compact.css
t/sass-spec/spec/misc/trailing_comma_in_selector/expected.compressed.css
t/sass-spec/spec/misc/trailing_comma_in_selector/expected.expanded.css
t/sass-spec/spec/misc/trailing_comma_in_selector/expected_output.css
t/sass-spec/spec/misc/trailing_comma_in_selector/input.scss
t/sass-spec/spec/misc/unicode_variables/expected.compact.css
t/sass-spec/spec/misc/unicode_variables/expected.compressed.css
t/sass-spec/spec/misc/unicode_variables/expected.expanded.css
t/sass-spec/spec/misc/unicode_variables/expected_output.css
t/sass-spec/spec/misc/unicode_variables/input.scss
t/sass-spec/spec/number-functions/abs/expected.compact.css
t/sass-spec/spec/number-functions/abs/expected.compressed.css
t/sass-spec/spec/number-functions/abs/expected.expanded.css
t/sass-spec/spec/number-functions/abs/expected_output.css
t/sass-spec/spec/number-functions/abs/input.scss
t/sass-spec/spec/number-functions/ceil/expected.compact.css
t/sass-spec/spec/number-functions/ceil/expected.compressed.css
t/sass-spec/spec/number-functions/ceil/expected.expanded.css
t/sass-spec/spec/number-functions/ceil/expected_output.css
t/sass-spec/spec/number-functions/ceil/input.scss
t/sass-spec/spec/scss-tests/003_test_variables/expected.compact.css
t/sass-spec/spec/scss-tests/003_test_variables/expected.compressed.css
t/sass-spec/spec/scss-tests/003_test_variables/expected.expanded.css
t/sass-spec/spec/scss-tests/003_test_variables/expected_output.css
t/sass-spec/spec/scss-tests/003_test_variables/input.scss
t/sass-spec/spec/scss-tests/004_test_variables/expected.compact.css
t/sass-spec/spec/scss-tests/004_test_variables/expected.compressed.css
t/sass-spec/spec/scss-tests/004_test_variables/expected.expanded.css
t/sass-spec/spec/scss-tests/004_test_variables/expected_output.css
t/sass-spec/spec/scss-tests/004_test_variables/input.scss
t/sass-spec/spec/scss-tests/005_test_unicode_variables/expected.compact.css
t/sass-spec/spec/scss-tests/005_test_unicode_variables/expected.compressed.css
t/sass-spec/spec/scss-tests/005_test_unicode_variables/expected.expanded.css
t/sass-spec/spec/scss-tests/005_test_unicode_variables/expected_output.css
t/sass-spec/spec/scss-tests/005_test_unicode_variables/input.scss
t/sass-spec/spec/scss-tests/006_test_guard_assign/expected.compact.css
t/sass-spec/spec/scss-tests/006_test_guard_assign/expected.compressed.css
t/sass-spec/spec/scss-tests/006_test_guard_assign/expected.expanded.css
t/sass-spec/spec/scss-tests/006_test_guard_assign/expected_output.css
t/sass-spec/spec/scss-tests/006_test_guard_assign/input.scss
t/sass-spec/spec/scss-tests/007_test_guard_assign/expected.compact.css
t/sass-spec/spec/scss-tests/007_test_guard_assign/expected.compressed.css
t/sass-spec/spec/scss-tests/007_test_guard_assign/expected.expanded.css
t/sass-spec/spec/scss-tests/007_test_guard_assign/expected_output.css
t/sass-spec/spec/scss-tests/007_test_guard_assign/input.scss
lib/CSS/ppport.h view on Meta::CPAN
pad_new|||
pad_peg|||n
pad_push|||
pad_reset|||
pad_setsv|||
pad_sv||5.011000|
pad_swipe|||
pad_tidy|||
pad_undef|||
parse_body|||
parse_unicode_opts|||
parser_dup|||
parser_free|||
path_is_absolute|||n
peep|||
pending_Slabs_to_ro|||
perl_alloc_using|||n
perl_alloc|||n
perl_clone_using|||n
perl_clone|||n
perl_construct|||n
lib/CSS/ppport.h view on Meta::CPAN
#endif
#ifndef PERL_PV_PRETTY_DUMP
# define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE
#endif
#ifndef PERL_PV_PRETTY_REGPROP
# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
#endif
/* Hint: pv_escape
* Note that unicode functionality is only backported to
* those perl versions that support it. For older perl
* versions, the implementation will fall back to bytes.
*/
#ifndef pv_escape
#if defined(NEED_pv_escape)
static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
static
#else
extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
libsass/constants.cpp view on Meta::CPAN
extern const char slash_slash[] = "//";
extern const char slash_star[] = "/*";
extern const char star_slash[] = "*/";
extern const char hash_lbrace[] = "#{";
extern const char rbrace[] = "}";
extern const char rparen[] = ")";
extern const char sign_chars[] = "-+";
extern const char hyphen[] = "-";
extern const char ellipsis[] = "...";
// extern const char url_space_chars[] = " \t\r\n\f";
extern const char escape_chars[] = " -~"; // need to include unicode spaces too
// type names
extern const char numeric_name[] = "numeric value";
extern const char number_name[] = "number";
extern const char percentage_name[] = "percentage";
extern const char dimension_name[] = "numeric dimension";
extern const char string_name[] = "string";
extern const char bool_name[] = "bool";
extern const char color_name[] = "color";
extern const char list_name[] = "list";
extern const char map_name[] = "map";
libsass/file.cpp view on Meta::CPAN
}
// try to load the given filename
// returned memory must be freed
// will auto convert .sass files
char* read_file(const string& path)
{
#ifdef _WIN32
BYTE* pBuffer;
DWORD dwBytes;
// windows unicode filepaths are encoded in utf16
wstring wpath = UTF_8::convert_to_utf16(path);
HANDLE hFile = CreateFileW(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE) return 0;
DWORD dwFileLength = GetFileSize(hFile, NULL);
if (dwFileLength == INVALID_FILE_SIZE) return 0;
// allocate an extra byte for the null char
pBuffer = (BYTE*)malloc((dwFileLength+1)*sizeof(BYTE));
ReadFile(hFile, pBuffer, dwFileLength, &dwBytes, NULL);
pBuffer[dwFileLength] = '\0';
CloseHandle(hFile);
libsass/json.cpp view on Meta::CPAN
((uint32_t)c[2] & 0x3F) << 6 |
((uint32_t)c[3] & 0x3F);
return 4;
}
}
/*
* Write a single UTF-8 character to @s,
* returning the length, in bytes, of the character written.
*
* @unicode must be U+0000..U+10FFFF, but not U+D800..U+DFFF.
*
* This function will write up to 4 bytes to @out.
*/
static int utf8_write_char(uint32_t unicode, char *out)
{
unsigned char *o = (unsigned char*) out;
assert(unicode <= 0x10FFFF && !(unicode >= 0xD800 && unicode <= 0xDFFF));
if (unicode <= 0x7F) {
/* U+0000..U+007F */
*o++ = unicode;
return 1;
} else if (unicode <= 0x7FF) {
/* U+0080..U+07FF */
*o++ = 0xC0 | unicode >> 6;
*o++ = 0x80 | (unicode & 0x3F);
return 2;
} else if (unicode <= 0xFFFF) {
/* U+0800..U+FFFF */
*o++ = 0xE0 | unicode >> 12;
*o++ = 0x80 | (unicode >> 6 & 0x3F);
*o++ = 0x80 | (unicode & 0x3F);
return 3;
} else {
/* U+10000..U+10FFFF */
*o++ = 0xF0 | unicode >> 18;
*o++ = 0x80 | (unicode >> 12 & 0x3F);
*o++ = 0x80 | (unicode >> 6 & 0x3F);
*o++ = 0x80 | (unicode & 0x3F);
return 4;
}
}
/*
* Compute the Unicode codepoint of a UTF-16 surrogate pair.
*
* @uc should be 0xD800..0xDBFF, and @lc should be 0xDC00..0xDFFF.
* If they aren't, this function returns false.
*/
static bool from_surrogate_pair(uint16_t uc, uint16_t lc, uint32_t *unicode)
{
if (uc >= 0xD800 && uc <= 0xDBFF && lc >= 0xDC00 && lc <= 0xDFFF) {
*unicode = 0x10000 + ((((uint32_t)uc & 0x3FF) << 10) | (lc & 0x3FF));
return true;
} else {
return false;
}
}
/*
* Construct a UTF-16 surrogate pair given a Unicode codepoint.
*
* @unicode must be U+10000..U+10FFFF.
*/
static void to_surrogate_pair(uint32_t unicode, uint16_t *uc, uint16_t *lc)
{
uint32_t n;
assert(unicode >= 0x10000 && unicode <= 0x10FFFF);
n = unicode - 0x10000;
*uc = ((n >> 10) & 0x3FF) | 0xD800;
*lc = (n & 0x3FF) | 0xDC00;
}
#define is_space(c) ((c) == '\t' || (c) == '\n' || (c) == '\r' || (c) == ' ')
#define is_digit(c) ((c) >= '0' && (c) <= '9')
static bool parse_value (const char **sp, JsonNode **out);
static bool parse_string (const char **sp, char **out);
static bool parse_number (const char **sp, double *out);
libsass/json.cpp view on Meta::CPAN
break;
case 'r':
*b++ = '\r';
break;
case 't':
*b++ = '\t';
break;
case 'u':
{
uint16_t uc, lc;
uint32_t unicode;
if (!parse_hex16(&s, &uc))
goto failed;
if (uc >= 0xD800 && uc <= 0xDFFF) {
/* Handle UTF-16 surrogate pair. */
if (*s++ != '\\' || *s++ != 'u' || !parse_hex16(&s, &lc))
goto failed; /* Incomplete surrogate pair. */
if (!from_surrogate_pair(uc, lc, &unicode))
goto failed; /* Invalid surrogate pair. */
} else if (uc == 0) {
/* Disallow "\u0000". */
goto failed;
} else {
unicode = uc;
}
b += utf8_write_char(unicode, b);
break;
}
default:
/* Invalid escape */
goto failed;
}
} else if (c <= 0x1F) {
/* Control characters are not allowed in string literals. */
goto failed;
} else {
libsass/json.cpp view on Meta::CPAN
member = member->next;
sb_puts(out, member != NULL ? ",\n" : "\n");
}
for (i = 0; i < indent_level; i++)
sb_puts(out, space);
sb_putc(out, '}');
}
void emit_string(SB *out, const char *str)
{
bool escape_unicode = false;
const char *s = str;
char *b;
assert(utf8_validate(str));
/*
* 14 bytes is enough space to write up to two
* \uXXXX escapes and two quotation marks.
*/
sb_need(out, 14);
libsass/json.cpp view on Meta::CPAN
if (len == 0) {
/*
* Handle invalid UTF-8 character gracefully in production
* by writing a replacement character (U+FFFD)
* and skipping a single byte.
*
* This should never happen when assertions are enabled
* due to the assertion at the beginning of this function.
*/
assert(false);
if (escape_unicode) {
strcpy(b, "\\uFFFD");
b += 6;
} else {
*b++ = 0xEFu;
*b++ = 0xBFu;
*b++ = 0xBDu;
}
s++;
} else if (c < 0x1F || (c >= 0x80 && escape_unicode)) {
/* Encode using \u.... */
uint32_t unicode;
s += utf8_read_char(s, &unicode);
if (unicode <= 0xFFFF) {
*b++ = '\\';
*b++ = 'u';
b += write_hex16(b, unicode);
} else {
/* Produce a surrogate pair. */
uint16_t uc, lc;
assert(unicode <= 0x10FFFF);
to_surrogate_pair(unicode, &uc, &lc);
*b++ = '\\';
*b++ = 'u';
b += write_hex16(b, uc);
*b++ = '\\';
*b++ = 'u';
b += write_hex16(b, lc);
}
} else {
/* Write the character directly. */
while (len--)
libsass/lexer.cpp view on Meta::CPAN
// locale independent
return chr == '.';
}
const bool is_alnum(const char& chr)
{
return is_alpha(chr) || is_digit(chr);
}
// check if char is outside ascii range
const bool is_unicode(const char& chr)
{
// check for unicode range
return unsigned(chr) > 127;
}
// Match word character (look ahead)
const bool is_character(const char& chr)
{
// valid alpha, numeric or unicode char (plus hyphen)
return is_alnum(chr) || is_unicode(chr) || chr == '-';
}
//####################################
// BASIC CLASS MATCHERS
//####################################
// create matchers that advance the position
const char* space(const char* src) { return is_space(*src) ? src + 1 : 0; }
const char* alpha(const char* src) { return is_alpha(*src) ? src + 1 : 0; }
const char* unicode(const char* src) { return is_unicode(*src) ? src + 1 : 0; }
const char* digit(const char* src) { return is_digit(*src) ? src + 1 : 0; }
const char* xdigit(const char* src) { return is_xdigit(*src) ? src + 1 : 0; }
const char* alnum(const char* src) { return is_alnum(*src) ? src + 1 : 0; }
const char* punct(const char* src) { return is_punct(*src) ? src + 1 : 0; }
const char* character(const char* src) { return is_character(*src) ? src + 1 : 0; }
// Match multiple ctype characters.
const char* spaces(const char* src) { return one_plus<space>(src); }
const char* digits(const char* src) { return one_plus<digit>(src); }
libsass/lexer.hpp view on Meta::CPAN
// BASIC CLASS MATCHERS
//####################################
// These are locale independant
const bool is_space(const char& src);
const bool is_alpha(const char& src);
const bool is_punct(const char& src);
const bool is_digit(const char& src);
const bool is_alnum(const char& src);
const bool is_xdigit(const char& src);
const bool is_unicode(const char& src);
const bool is_character(const char& src);
// Match a single ctype predicate.
const char* space(const char* src);
const char* alpha(const char* src);
const char* digit(const char* src);
const char* xdigit(const char* src);
const char* alnum(const char* src);
const char* punct(const char* src);
const char* unicode(const char* src);
const char* character(const char* src);
// Match multiple ctype characters.
const char* spaces(const char* src);
const char* digits(const char* src);
// Whitespace handling.
const char* no_spaces(const char* src);
const char* optional_spaces(const char* src);
libsass/output.cpp view on Meta::CPAN
// flush scheduled outputs
inspect.finalize();
// prepend buffer on top
prepend_output(inspect.output());
// make sure we end with a linefeed
if (!ends_with(wbuf.buffer, ctx->linefeed)) {
// if the output is not completely empty
if (!wbuf.buffer.empty()) append_string(ctx->linefeed);
}
// search for unicode char
for(const char& chr : wbuf.buffer) {
// skip all ascii chars
if (chr >= 0) continue;
// declare the charset
if (output_style() != COMPRESSED)
charset = "@charset \"UTF-8\";"
+ ctx->linefeed;
else charset = "\xEF\xBB\xBF";
// abort search
break;
libsass/prelexer.cpp view on Meta::CPAN
exactly<'\\'>,
any_char
>(src);
}
// Match identifier start
const char* identifier_alpha(const char* src)
{
return alternatives<
alpha,
unicode,
exactly<'-'>,
exactly<'_'>,
escape_seq
>(src);
}
// Match identifier after start
const char* identifier_alnum(const char* src)
{
return alternatives<
alnum,
unicode,
exactly<'-'>,
exactly<'_'>,
escape_seq
>(src);
}
// Match CSS identifiers.
const char* identifier(const char* src)
{
return sequence<
libsass/prelexer.cpp view on Meta::CPAN
exactly<'\r'>,
exactly<'\f'> >(src);
}*/
/* not used anymore - remove?
const char* H(const char* src) {
return std::isxdigit(*src) ? src+1 : 0;
}*/
/* not used anymore - remove?
const char* unicode(const char* src) {
return sequence< exactly<'\\'>,
between<H, 1, 6>,
optional< class_char<url_space_chars> > >(src);
}*/
/* not used anymore - remove?
const char* ESCAPE(const char* src) {
return alternatives< unicode, class_char<escape_chars> >(src);
}*/
const char* static_string(const char* src) {
const char* pos = src;
const char * s = quoted_string(pos);
Token t(pos, s);
const unsigned int p = count_interval< interpolant >(t.begin, t.end);
return (p == 0) ? t.end : 0;
}
libsass/utf8_string.hpp view on Meta::CPAN
// function that will return the byte offset of a code point in a
size_t offset_at_position(const string& str, size_t position);
// function that returns number of bytes in a character in a string
size_t code_point_size_at_offset(const string& str, size_t offset);
// function that will return a normalized index, given a crazy one
size_t normalize_index(int index, size_t len);
#ifdef _WIN32
// functions to handle unicode paths on windows
string convert_from_utf16(const wstring& wstr);
wstring convert_to_utf16(const string& str);
#endif
}
}
#endif
libsass/util.cpp view on Meta::CPAN
if (*s.begin() == '"' && *s.rbegin() == '"') q = '"';
else if (*s.begin() == '\'' && *s.rbegin() == '\'') q = '\'';
else return s;
string unq;
unq.reserve(s.length()-2);
for (size_t i = 1, L = s.length() - 1; i < L; ++i) {
// implement the same strange ruby sass behavior
// an escape sequence can also mean a unicode char
if (s[i] == '\\' && !skipped) {
// remember
skipped = true;
// skip it
// ++ i;
// if (i == L) break;
// escape length
t/09_unicode.t view on Meta::CPAN
use Test::More tests => 9;
BEGIN { use_ok('CSS::Sass') };
my %options = ( dont_die => 1 );
my ($fh, $sass, $r);
require Win32::Unicode::File if $^O eq "MSWin32";
unless ($^O eq "MSWin32") { open($fh, ">", 't/inc/unicode_äöü.scss'); }
else { $fh = Win32::Unicode::File->new(">", 't/inc/unicode_äöü.scss'); }
binmode($fh, ":utf8"); # allow utf8 output on handle
print $fh '.class { content: "[umlaut] äöü"; }'; close $fh;
unless ($^O eq "MSWin32") { open($fh, ">", 't/inc/unicode_тра.scss'); }
else { $fh = Win32::Unicode::File->new(">", 't/inc/unicode_тра.scss'); }
binmode($fh, ":utf8"); # allow utf8 output on handle
print $fh '.class { content: "тра"; }'; close $fh;
$sass = CSS::Sass->new(include_paths => ['t/inc'], %options);
unless ($^O eq "MSWin32") { ok(-e 't/inc/unicode_äöü.scss', "found unicode file [1]"); }
else { ok (Win32::Unicode::File::file_type('e', 't/inc/unicode_äöü.scss'), "found unicode file [1]"); }
unless ($^O eq "MSWin32") { ok(-e 't/inc/unicode_тра.scss', "found unicode file [2]"); }
else { ok (Win32::Unicode::File::file_type('e', 't/inc/unicode_тра.scss'), "found unicode file [2]"); }
# this should work on windows ansi api if chars are in ansi page
($r) = $sass->compile_file('t/inc/unicode_äöü.scss');
warn $sass->last_error if $sass->last_error;
ok ($r, "Passed unicode filename test 1a");
is ($sass->last_error, undef, "Passed unicode filename test 1b");
# this should fail on windows ansi api if chars are not in ansi page
$sass = CSS::Sass->new(include_paths => ['t/inc'], %options);
($r) = $sass->compile_file('t/inc/unicode_тра.scss');
warn $sass->last_error if $sass->last_error;
ok ($r, "Passed unicode filename test 2a");
is ($sass->last_error, undef, "Passed unicode filename test 2b");
unless ($^O eq "MSWin32") { unlink('t/inc/unicode_äöü.scss'); }
else { Win32::Unicode::File::unlinkW('t/inc/unicode_äöü.scss'); }
unless ($^O eq "MSWin32") { unlink('t/inc/unicode_тра.scss'); }
else { Win32::Unicode::File::unlinkW('t/inc/unicode_тра.scss'); }
unless ($^O eq "MSWin32") { ok(! -e 't/inc/unicode_äöü.scss', "found unicode file [1]"); }
else { ok (! Win32::Unicode::File::file_type('e', 't/inc/unicode_äöü.scss'), "found unicode file [1]"); }
unless ($^O eq "MSWin32") { ok(! -e 't/inc/unicode_тра.scss', "found unicode file [2]"); }
else { ok (! Win32::Unicode::File::file_type('e', 't/inc/unicode_тра.scss'), "found unicode file [2]"); }
t/sass-spec/spec/libsass-closed-issues/issue_820/expected.compact.css view on Meta::CPAN
@charset "UTF-8";
/*! Force output of above line by adding a unicode character. ♫ */
html, body { height: 100%; }
t/sass-spec/spec/libsass-closed-issues/issue_820/expected.compressed.css view on Meta::CPAN
/*! Force output of above line by adding a unicode character. ♫ */html,body{height:100%}
t/sass-spec/spec/libsass-closed-issues/issue_820/expected.expanded.css view on Meta::CPAN
@charset "UTF-8";
/*! Force output of above line by adding a unicode character. ♫ */
html, body {
height: 100%;
}
t/sass-spec/spec/libsass-closed-issues/issue_820/expected_output.css view on Meta::CPAN
@charset "UTF-8";
/*! Force output of above line by adding a unicode character. ♫ */
html, body {
height: 100%; }
t/sass-spec/spec/libsass-closed-issues/issue_820/input.scss view on Meta::CPAN
@charset "UTF-8";
/*! Force output of above line by adding a unicode character. ♫ */
html, body {
height: 100%; }
( run in 0.556 second using v1.01-cache-2.11-cpan-88abd93f124 )