You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
11659 lines
411 KiB
JavaScript
11659 lines
411 KiB
JavaScript
/** * @license Apache-2.0
|
|
*/
|
|
|
|
!(function (a) {
|
|
if ('object' == typeof exports && 'undefined' != typeof module)
|
|
module.exports = a();
|
|
else if ('function' == typeof define && define.amd) define([], a);
|
|
else {
|
|
var b;
|
|
(b =
|
|
'undefined' != typeof window
|
|
? window
|
|
: 'undefined' != typeof global
|
|
? global
|
|
: 'undefined' != typeof self
|
|
? self
|
|
: this),
|
|
(b.less = a());
|
|
}
|
|
})(function () {
|
|
return (function a(b, c, d) {
|
|
function e(g, h) {
|
|
if (!c[g]) {
|
|
if (!b[g]) {
|
|
var i = 'function' == typeof require && require;
|
|
if (!h && i) return i(g, !0);
|
|
if (f) return f(g, !0);
|
|
var j = new Error("Cannot find module '" + g + "'");
|
|
throw ((j.code = 'MODULE_NOT_FOUND'), j);
|
|
}
|
|
var k = (c[g] = { exports: {} });
|
|
b[g][0].call(
|
|
k.exports,
|
|
function (a) {
|
|
var c = b[g][1][a];
|
|
return e(c ? c : a);
|
|
},
|
|
k,
|
|
k.exports,
|
|
a,
|
|
b,
|
|
c,
|
|
d,
|
|
);
|
|
}
|
|
return c[g].exports;
|
|
}
|
|
for (
|
|
var f = 'function' == typeof require && require, g = 0;
|
|
g < d.length;
|
|
g++
|
|
)
|
|
e(d[g]);
|
|
return e;
|
|
})(
|
|
{
|
|
1: [
|
|
function (a, b, c) {
|
|
var d = a('./utils').addDataAttr,
|
|
e = a('./browser');
|
|
b.exports = function (a, b) {
|
|
d(b, e.currentScript(a)),
|
|
void 0 === b.isFileProtocol &&
|
|
(b.isFileProtocol =
|
|
/^(file|(chrome|safari)(-extension)?|resource|qrc|app):/.test(
|
|
a.location.protocol,
|
|
)),
|
|
(b.async = b.async || !1),
|
|
(b.fileAsync = b.fileAsync || !1),
|
|
(b.poll = b.poll || (b.isFileProtocol ? 1e3 : 1500)),
|
|
(b.env =
|
|
b.env ||
|
|
('127.0.0.1' == a.location.hostname ||
|
|
'0.0.0.0' == a.location.hostname ||
|
|
'localhost' == a.location.hostname ||
|
|
(a.location.port && a.location.port.length > 0) ||
|
|
b.isFileProtocol
|
|
? 'development'
|
|
: 'production'));
|
|
var c = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(
|
|
a.location.hash,
|
|
);
|
|
c && (b.dumpLineNumbers = c[1]),
|
|
void 0 === b.useFileCache && (b.useFileCache = !0),
|
|
void 0 === b.onReady && (b.onReady = !0),
|
|
b.relativeUrls && (b.rewriteUrls = 'all');
|
|
};
|
|
},
|
|
{ './browser': 3, './utils': 11 },
|
|
],
|
|
2: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
a.filename && console.warn(a), e.async || h.removeChild(i);
|
|
}
|
|
a('promise/polyfill');
|
|
var e = a('../less/default-options')();
|
|
if (window.less)
|
|
for (key in window.less)
|
|
window.less.hasOwnProperty(key) && (e[key] = window.less[key]);
|
|
a('./add-default-options')(window, e),
|
|
(e.plugins = e.plugins || []),
|
|
window.LESS_PLUGINS &&
|
|
(e.plugins = e.plugins.concat(window.LESS_PLUGINS));
|
|
var f = (b.exports = a('./index')(window, e));
|
|
window.less = f;
|
|
var g, h, i;
|
|
e.onReady &&
|
|
(/!watch/.test(window.location.hash) && f.watch(),
|
|
e.async ||
|
|
((g = 'body { display: none !important }'),
|
|
(h = document.head || document.getElementsByTagName('head')[0]),
|
|
(i = document.createElement('style')),
|
|
(i.type = 'text/css'),
|
|
i.styleSheet
|
|
? (i.styleSheet.cssText = g)
|
|
: i.appendChild(document.createTextNode(g)),
|
|
h.appendChild(i)),
|
|
f.registerStylesheetsImmediately(),
|
|
(f.pageLoadFinished = f
|
|
.refresh('development' === f.env)
|
|
.then(d, d)));
|
|
},
|
|
{
|
|
'../less/default-options': 17,
|
|
'./add-default-options': 1,
|
|
'./index': 8,
|
|
'promise/polyfill': 107,
|
|
},
|
|
],
|
|
3: [
|
|
function (a, b, c) {
|
|
var d = a('./utils');
|
|
b.exports = {
|
|
createCSS: function (a, b, c) {
|
|
var e = c.href || '',
|
|
f = 'less:' + (c.title || d.extractId(e)),
|
|
g = a.getElementById(f),
|
|
h = !1,
|
|
i = a.createElement('style');
|
|
i.setAttribute('type', 'text/css'),
|
|
c.media && i.setAttribute('media', c.media),
|
|
(i.id = f),
|
|
i.styleSheet ||
|
|
(i.appendChild(a.createTextNode(b)),
|
|
(h =
|
|
null !== g &&
|
|
g.childNodes.length > 0 &&
|
|
i.childNodes.length > 0 &&
|
|
g.firstChild.nodeValue === i.firstChild.nodeValue));
|
|
var j = a.getElementsByTagName('head')[0];
|
|
if (null === g || h === !1) {
|
|
var k = (c && c.nextSibling) || null;
|
|
k ? k.parentNode.insertBefore(i, k) : j.appendChild(i);
|
|
}
|
|
if ((g && h === !1 && g.parentNode.removeChild(g), i.styleSheet))
|
|
try {
|
|
i.styleSheet.cssText = b;
|
|
} catch (l) {
|
|
throw new Error("Couldn't reassign styleSheet.cssText.");
|
|
}
|
|
},
|
|
currentScript: function (a) {
|
|
var b = a.document;
|
|
return (
|
|
b.currentScript ||
|
|
(function () {
|
|
var a = b.getElementsByTagName('script');
|
|
return a[a.length - 1];
|
|
})()
|
|
);
|
|
},
|
|
};
|
|
},
|
|
{ './utils': 11 },
|
|
],
|
|
4: [
|
|
function (a, b, c) {
|
|
b.exports = function (a, b, c) {
|
|
var d = null;
|
|
if ('development' !== b.env)
|
|
try {
|
|
d =
|
|
'undefined' == typeof a.localStorage ? null : a.localStorage;
|
|
} catch (e) {}
|
|
return {
|
|
setCSS: function (a, b, e, f) {
|
|
if (d) {
|
|
c.info('saving ' + a + ' to cache.');
|
|
try {
|
|
d.setItem(a, f),
|
|
d.setItem(a + ':timestamp', b),
|
|
e && d.setItem(a + ':vars', JSON.stringify(e));
|
|
} catch (g) {
|
|
c.error(
|
|
'failed to save "' +
|
|
a +
|
|
'" to local storage for caching.',
|
|
);
|
|
}
|
|
}
|
|
},
|
|
getCSS: function (a, b, c) {
|
|
var e = d && d.getItem(a),
|
|
f = d && d.getItem(a + ':timestamp'),
|
|
g = d && d.getItem(a + ':vars');
|
|
if (
|
|
((c = c || {}),
|
|
(g = g || '{}'),
|
|
f &&
|
|
b.lastModified &&
|
|
new Date(b.lastModified).valueOf() ===
|
|
new Date(f).valueOf() &&
|
|
JSON.stringify(c) === g)
|
|
)
|
|
return e;
|
|
},
|
|
};
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
5: [
|
|
function (a, b, c) {
|
|
var d = a('./utils'),
|
|
e = a('./browser');
|
|
b.exports = function (a, b, c) {
|
|
function f(b, f) {
|
|
var g,
|
|
h,
|
|
i = 'less-error-message:' + d.extractId(f || ''),
|
|
j =
|
|
'<li><label>{line}</label><pre class="{class}">{content}</pre></li>',
|
|
k = a.document.createElement('div'),
|
|
l = [],
|
|
m = b.filename || f,
|
|
n = m.match(/([^\/]+(\?.*)?)$/)[1];
|
|
(k.id = i),
|
|
(k.className = 'less-error-message'),
|
|
(h =
|
|
'<h3>' +
|
|
(b.type || 'Syntax') +
|
|
'Error: ' +
|
|
(b.message || 'There is an error in your .less file') +
|
|
'</h3><p>in <a href="' +
|
|
m +
|
|
'">' +
|
|
n +
|
|
'</a> ');
|
|
var o = function (a, b, c) {
|
|
void 0 !== a.extract[b] &&
|
|
l.push(
|
|
j
|
|
.replace(
|
|
/\{line\}/,
|
|
(parseInt(a.line, 10) || 0) + (b - 1),
|
|
)
|
|
.replace(/\{class\}/, c)
|
|
.replace(/\{content\}/, a.extract[b]),
|
|
);
|
|
};
|
|
b.line &&
|
|
(o(b, 0, ''),
|
|
o(b, 1, 'line'),
|
|
o(b, 2, ''),
|
|
(h +=
|
|
'on line ' +
|
|
b.line +
|
|
', column ' +
|
|
(b.column + 1) +
|
|
':</p><ul>' +
|
|
l.join('') +
|
|
'</ul>')),
|
|
b.stack &&
|
|
(b.extract || c.logLevel >= 4) &&
|
|
(h +=
|
|
'<br/>Stack Trace</br />' +
|
|
b.stack.split('\n').slice(1).join('<br/>')),
|
|
(k.innerHTML = h),
|
|
e.createCSS(
|
|
a.document,
|
|
[
|
|
'.less-error-message ul, .less-error-message li {',
|
|
'list-style-type: none;',
|
|
'margin-right: 15px;',
|
|
'padding: 4px 0;',
|
|
'margin: 0;',
|
|
'}',
|
|
'.less-error-message label {',
|
|
'font-size: 12px;',
|
|
'margin-right: 15px;',
|
|
'padding: 4px 0;',
|
|
'color: #cc7777;',
|
|
'}',
|
|
'.less-error-message pre {',
|
|
'color: #dd6666;',
|
|
'padding: 4px 0;',
|
|
'margin: 0;',
|
|
'display: inline-block;',
|
|
'}',
|
|
'.less-error-message pre.line {',
|
|
'color: #ff0000;',
|
|
'}',
|
|
'.less-error-message h3 {',
|
|
'font-size: 20px;',
|
|
'font-weight: bold;',
|
|
'padding: 15px 0 5px 0;',
|
|
'margin: 0;',
|
|
'}',
|
|
'.less-error-message a {',
|
|
'color: #10a',
|
|
'}',
|
|
'.less-error-message .error {',
|
|
'color: red;',
|
|
'font-weight: bold;',
|
|
'padding-bottom: 2px;',
|
|
'border-bottom: 1px dashed red;',
|
|
'}',
|
|
].join('\n'),
|
|
{ title: 'error-message' },
|
|
),
|
|
(k.style.cssText = [
|
|
'font-family: Arial, sans-serif',
|
|
'border: 1px solid #e00',
|
|
'background-color: #eee',
|
|
'border-radius: 5px',
|
|
'-webkit-border-radius: 5px',
|
|
'-moz-border-radius: 5px',
|
|
'color: #e00',
|
|
'padding: 15px',
|
|
'margin-bottom: 15px',
|
|
].join(';')),
|
|
'development' === c.env &&
|
|
(g = setInterval(function () {
|
|
var b = a.document,
|
|
c = b.body;
|
|
c &&
|
|
(b.getElementById(i)
|
|
? c.replaceChild(k, b.getElementById(i))
|
|
: c.insertBefore(k, c.firstChild),
|
|
clearInterval(g));
|
|
}, 10));
|
|
}
|
|
function g(b) {
|
|
var c = a.document.getElementById(
|
|
'less-error-message:' + d.extractId(b),
|
|
);
|
|
c && c.parentNode.removeChild(c);
|
|
}
|
|
function h(a) {}
|
|
function i(a) {
|
|
c.errorReporting && 'html' !== c.errorReporting
|
|
? 'console' === c.errorReporting
|
|
? h(a)
|
|
: 'function' == typeof c.errorReporting &&
|
|
c.errorReporting('remove', a)
|
|
: g(a);
|
|
}
|
|
function j(a, d) {
|
|
var e = '{line} {content}',
|
|
f = a.filename || d,
|
|
g = [],
|
|
h =
|
|
(a.type || 'Syntax') +
|
|
'Error: ' +
|
|
(a.message || 'There is an error in your .less file') +
|
|
' in ' +
|
|
f,
|
|
i = function (a, b, c) {
|
|
void 0 !== a.extract[b] &&
|
|
g.push(
|
|
e
|
|
.replace(
|
|
/\{line\}/,
|
|
(parseInt(a.line, 10) || 0) + (b - 1),
|
|
)
|
|
.replace(/\{class\}/, c)
|
|
.replace(/\{content\}/, a.extract[b]),
|
|
);
|
|
};
|
|
a.line &&
|
|
(i(a, 0, ''),
|
|
i(a, 1, 'line'),
|
|
i(a, 2, ''),
|
|
(h +=
|
|
' on line ' +
|
|
a.line +
|
|
', column ' +
|
|
(a.column + 1) +
|
|
':\n' +
|
|
g.join('\n'))),
|
|
a.stack &&
|
|
(a.extract || c.logLevel >= 4) &&
|
|
(h += '\nStack Trace\n' + a.stack),
|
|
b.logger.error(h);
|
|
}
|
|
function k(a, b) {
|
|
c.errorReporting && 'html' !== c.errorReporting
|
|
? 'console' === c.errorReporting
|
|
? j(a, b)
|
|
: 'function' == typeof c.errorReporting &&
|
|
c.errorReporting('add', a, b)
|
|
: f(a, b);
|
|
}
|
|
return { add: k, remove: i };
|
|
};
|
|
},
|
|
{ './browser': 3, './utils': 11 },
|
|
],
|
|
6: [
|
|
function (a, b, c) {
|
|
b.exports = function (b, c) {
|
|
var d = a('../less/environment/abstract-file-manager.js'),
|
|
e = {},
|
|
f = function () {};
|
|
return (
|
|
(f.prototype = new d()),
|
|
(f.prototype.alwaysMakePathsAbsolute = function () {
|
|
return !0;
|
|
}),
|
|
(f.prototype.join = function (a, b) {
|
|
return a ? this.extractUrlParts(b, a).path : b;
|
|
}),
|
|
(f.prototype.doXHR = function (a, d, e, f) {
|
|
function g(b, c, d) {
|
|
b.status >= 200 && b.status < 300
|
|
? c(b.responseText, b.getResponseHeader('Last-Modified'))
|
|
: 'function' == typeof d && d(b.status, a);
|
|
}
|
|
var h = new XMLHttpRequest(),
|
|
i = !b.isFileProtocol || b.fileAsync;
|
|
'function' == typeof h.overrideMimeType &&
|
|
h.overrideMimeType('text/css'),
|
|
c.debug("XHR: Getting '" + a + "'"),
|
|
h.open('GET', a, i),
|
|
h.setRequestHeader(
|
|
'Accept',
|
|
d || 'text/x-less, text/css; q=0.9, */*; q=0.5',
|
|
),
|
|
h.send(null),
|
|
b.isFileProtocol && !b.fileAsync
|
|
? 0 === h.status || (h.status >= 200 && h.status < 300)
|
|
? e(h.responseText)
|
|
: f(h.status, a)
|
|
: i
|
|
? (h.onreadystatechange = function () {
|
|
4 == h.readyState && g(h, e, f);
|
|
})
|
|
: g(h, e, f);
|
|
}),
|
|
(f.prototype.supports = function (a, b, c, d) {
|
|
return !0;
|
|
}),
|
|
(f.prototype.clearFileCache = function () {
|
|
e = {};
|
|
}),
|
|
(f.prototype.loadFile = function (a, b, c, d) {
|
|
b && !this.isPathAbsolute(a) && (a = b + a),
|
|
(a = c.ext ? this.tryAppendExtension(a, c.ext) : a),
|
|
(c = c || {});
|
|
var f = this.extractUrlParts(a, window.location.href),
|
|
g = f.url,
|
|
h = this;
|
|
return new Promise(function (a, b) {
|
|
if (c.useFileCache && e[g])
|
|
try {
|
|
var d = e[g];
|
|
return a({
|
|
contents: d,
|
|
filename: g,
|
|
webInfo: { lastModified: new Date() },
|
|
});
|
|
} catch (f) {
|
|
return b({
|
|
filename: g,
|
|
message:
|
|
'Error loading file ' + g + ' error was ' + f.message,
|
|
});
|
|
}
|
|
h.doXHR(
|
|
g,
|
|
c.mime,
|
|
function (b, c) {
|
|
(e[g] = b),
|
|
a({
|
|
contents: b,
|
|
filename: g,
|
|
webInfo: { lastModified: c },
|
|
});
|
|
},
|
|
function (a, c) {
|
|
b({
|
|
type: 'File',
|
|
message: "'" + c + "' wasn't found (" + a + ')',
|
|
href: g,
|
|
});
|
|
},
|
|
);
|
|
});
|
|
}),
|
|
f
|
|
);
|
|
};
|
|
},
|
|
{ '../less/environment/abstract-file-manager.js': 18 },
|
|
],
|
|
7: [
|
|
function (a, b, c) {
|
|
b.exports = function () {
|
|
function b() {
|
|
throw {
|
|
type: 'Runtime',
|
|
message:
|
|
'Image size functions are not supported in browser version of less',
|
|
};
|
|
}
|
|
var c = a('./../less/functions/function-registry'),
|
|
d = {
|
|
'image-size': function (a) {
|
|
return b(this, a), -1;
|
|
},
|
|
'image-width': function (a) {
|
|
return b(this, a), -1;
|
|
},
|
|
'image-height': function (a) {
|
|
return b(this, a), -1;
|
|
},
|
|
};
|
|
c.addMultiple(d);
|
|
};
|
|
},
|
|
{ './../less/functions/function-registry': 27 },
|
|
],
|
|
8: [
|
|
function (a, b, c) {
|
|
var d = a('./utils').addDataAttr,
|
|
e = a('./browser');
|
|
b.exports = function (b, c) {
|
|
function f(a) {
|
|
var b = {};
|
|
for (var c in a) a.hasOwnProperty(c) && (b[c] = a[c]);
|
|
return b;
|
|
}
|
|
function g(a, b) {
|
|
var c = Array.prototype.slice.call(arguments, 2);
|
|
return function () {
|
|
var d = c.concat(Array.prototype.slice.call(arguments, 0));
|
|
return a.apply(b, d);
|
|
};
|
|
}
|
|
function h(a) {
|
|
for (
|
|
var b, d = l.getElementsByTagName('style'), e = 0;
|
|
e < d.length;
|
|
e++
|
|
)
|
|
if (((b = d[e]), b.type.match(s))) {
|
|
var h = f(c);
|
|
h.modifyVars = a;
|
|
var i = b.innerHTML || '';
|
|
(h.filename = l.location.href.replace(/#.*$/, '')),
|
|
m.render(
|
|
i,
|
|
h,
|
|
g(
|
|
function (a, b, c) {
|
|
b
|
|
? q.add(b, 'inline')
|
|
: ((a.type = 'text/css'),
|
|
a.styleSheet
|
|
? (a.styleSheet.cssText = c.css)
|
|
: (a.innerHTML = c.css));
|
|
},
|
|
null,
|
|
b,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
function i(a, b, e, g, h) {
|
|
function i(c) {
|
|
var d = c.contents,
|
|
f = c.filename,
|
|
h = c.webInfo,
|
|
i = {
|
|
currentDirectory: p.getPath(f),
|
|
filename: f,
|
|
rootFilename: f,
|
|
rewriteUrls: j.rewriteUrls,
|
|
};
|
|
if (
|
|
((i.entryPath = i.currentDirectory),
|
|
(i.rootpath = j.rootpath || i.currentDirectory),
|
|
h)
|
|
) {
|
|
h.remaining = g;
|
|
var k = r.getCSS(f, h, j.modifyVars);
|
|
if (!e && k)
|
|
return (h.local = !0), void b(null, k, d, a, h, f);
|
|
}
|
|
q.remove(f),
|
|
(j.rootFileInfo = i),
|
|
m.render(d, j, function (c, e) {
|
|
c
|
|
? ((c.href = f), b(c))
|
|
: (r.setCSS(a.href, h.lastModified, j.modifyVars, e.css),
|
|
b(null, e.css, d, a, h, f));
|
|
});
|
|
}
|
|
var j = f(c);
|
|
d(j, a),
|
|
(j.mime = a.type),
|
|
h && (j.modifyVars = h),
|
|
p
|
|
.loadFile(a.href, null, j, n)
|
|
.then(function (a) {
|
|
i(a);
|
|
})
|
|
['catch'](function (a) {
|
|
console.log(a), b(a);
|
|
});
|
|
}
|
|
function j(a, b, c) {
|
|
for (var d = 0; d < m.sheets.length; d++)
|
|
i(m.sheets[d], a, b, m.sheets.length - (d + 1), c);
|
|
}
|
|
function k() {
|
|
'development' === m.env &&
|
|
(m.watchTimer = setInterval(function () {
|
|
m.watchMode &&
|
|
(p.clearFileCache(),
|
|
j(function (a, c, d, f, g) {
|
|
a
|
|
? q.add(a, a.href || f.href)
|
|
: c && e.createCSS(b.document, c, f);
|
|
}));
|
|
}, c.poll));
|
|
}
|
|
var l = b.document,
|
|
m = a('../less')();
|
|
m.options = c;
|
|
var n = m.environment,
|
|
o = a('./file-manager')(c, m.logger),
|
|
p = new o();
|
|
n.addFileManager(p),
|
|
(m.FileManager = o),
|
|
(m.PluginLoader = a('./plugin-loader')),
|
|
a('./log-listener')(m, c);
|
|
var q = a('./error-reporting')(b, m, c),
|
|
r = (m.cache = c.cache || a('./cache')(b, c, m.logger));
|
|
a('./image-size')(m.environment),
|
|
c.functions &&
|
|
m.functions.functionRegistry.addMultiple(c.functions);
|
|
var s = /^text\/(x-)?less$/;
|
|
return (
|
|
(m.watch = function () {
|
|
return (
|
|
m.watchMode || ((m.env = 'development'), k()),
|
|
(this.watchMode = !0),
|
|
!0
|
|
);
|
|
}),
|
|
(m.unwatch = function () {
|
|
return clearInterval(m.watchTimer), (this.watchMode = !1), !1;
|
|
}),
|
|
(m.registerStylesheetsImmediately = function () {
|
|
var a = l.getElementsByTagName('link');
|
|
m.sheets = [];
|
|
for (var b = 0; b < a.length; b++)
|
|
('stylesheet/less' === a[b].rel ||
|
|
(a[b].rel.match(/stylesheet/) && a[b].type.match(s))) &&
|
|
m.sheets.push(a[b]);
|
|
}),
|
|
(m.registerStylesheets = function () {
|
|
return new Promise(function (a, b) {
|
|
m.registerStylesheetsImmediately(), a();
|
|
});
|
|
}),
|
|
(m.modifyVars = function (a) {
|
|
return m.refresh(!0, a, !1);
|
|
}),
|
|
(m.refresh = function (a, c, d) {
|
|
return (
|
|
(a || d) && d !== !1 && p.clearFileCache(),
|
|
new Promise(function (d, f) {
|
|
var g, i, k, l;
|
|
(g = i = new Date()),
|
|
(l = m.sheets.length),
|
|
0 === l
|
|
? ((i = new Date()),
|
|
(k = i - g),
|
|
m.logger.info(
|
|
'Less has finished and no sheets were loaded.',
|
|
),
|
|
d({
|
|
startTime: g,
|
|
endTime: i,
|
|
totalMilliseconds: k,
|
|
sheets: m.sheets.length,
|
|
}))
|
|
: j(
|
|
function (a, c, h, j, n) {
|
|
return a
|
|
? (q.add(a, a.href || j.href), void f(a))
|
|
: (m.logger.info(
|
|
n.local
|
|
? 'Loading ' + j.href + ' from cache.'
|
|
: 'Rendered ' + j.href + ' successfully.',
|
|
),
|
|
e.createCSS(b.document, c, j),
|
|
m.logger.info(
|
|
'CSS for ' +
|
|
j.href +
|
|
' generated in ' +
|
|
(new Date() - i) +
|
|
'ms',
|
|
),
|
|
l--,
|
|
0 === l &&
|
|
((k = new Date() - g),
|
|
m.logger.info(
|
|
'Less has finished. CSS generated in ' +
|
|
k +
|
|
'ms',
|
|
),
|
|
d({
|
|
startTime: g,
|
|
endTime: i,
|
|
totalMilliseconds: k,
|
|
sheets: m.sheets.length,
|
|
})),
|
|
void (i = new Date()));
|
|
},
|
|
a,
|
|
c,
|
|
),
|
|
h(c);
|
|
})
|
|
);
|
|
}),
|
|
(m.refreshStyles = h),
|
|
m
|
|
);
|
|
};
|
|
},
|
|
{
|
|
'../less': 37,
|
|
'./browser': 3,
|
|
'./cache': 4,
|
|
'./error-reporting': 5,
|
|
'./file-manager': 6,
|
|
'./image-size': 7,
|
|
'./log-listener': 9,
|
|
'./plugin-loader': 10,
|
|
'./utils': 11,
|
|
},
|
|
],
|
|
9: [
|
|
function (a, b, c) {
|
|
b.exports = function (a, b) {
|
|
var c = 4,
|
|
d = 3,
|
|
e = 2,
|
|
f = 1;
|
|
(b.logLevel =
|
|
'undefined' != typeof b.logLevel
|
|
? b.logLevel
|
|
: 'development' === b.env
|
|
? d
|
|
: f),
|
|
b.loggers ||
|
|
(b.loggers = [
|
|
{
|
|
debug: function (a) {
|
|
b.logLevel >= c && console.log(a);
|
|
},
|
|
info: function (a) {
|
|
b.logLevel >= d && console.log(a);
|
|
},
|
|
warn: function (a) {
|
|
b.logLevel >= e && console.warn(a);
|
|
},
|
|
error: function (a) {
|
|
b.logLevel >= f && console.error(a);
|
|
},
|
|
},
|
|
]);
|
|
for (var g = 0; g < b.loggers.length; g++)
|
|
a.logger.addListener(b.loggers[g]);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
10: [
|
|
function (a, b, c) {
|
|
var d = a('../less/environment/abstract-plugin-loader.js'),
|
|
e = function (a) {
|
|
this.less = a;
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.loadPlugin = function (a, b, c, d, e) {
|
|
return new Promise(function (f, g) {
|
|
e.loadFile(a, b, c, d).then(f)['catch'](g);
|
|
});
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ '../less/environment/abstract-plugin-loader.js': 19 },
|
|
],
|
|
11: [
|
|
function (a, b, c) {
|
|
b.exports = {
|
|
extractId: function (a) {
|
|
return a
|
|
.replace(/^[a-z-]+:\/+?[^\/]+/, '')
|
|
.replace(/[\?\&]livereload=\w+/, '')
|
|
.replace(/^\//, '')
|
|
.replace(/\.[a-zA-Z]+$/, '')
|
|
.replace(/[^\.\w-]+/g, '-')
|
|
.replace(/\./g, ':');
|
|
},
|
|
addDataAttr: function (a, b) {
|
|
for (var c in b.dataset)
|
|
if (b.dataset.hasOwnProperty(c))
|
|
if (
|
|
'env' === c ||
|
|
'dumpLineNumbers' === c ||
|
|
'rootpath' === c ||
|
|
'errorReporting' === c
|
|
)
|
|
a[c] = b.dataset[c];
|
|
else
|
|
try {
|
|
a[c] = JSON.parse(b.dataset[c]);
|
|
} catch (d) {}
|
|
},
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
12: [
|
|
function (a, b, c) {
|
|
b.exports = {
|
|
Math: {
|
|
ALWAYS: 0,
|
|
PARENS_DIVISION: 1,
|
|
PARENS: 2,
|
|
STRICT_LEGACY: 3,
|
|
},
|
|
RewriteUrls: { OFF: 0, LOCAL: 1, ALL: 2 },
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
13: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
return !/^(?:[a-z-]+:|\/|#)/i.test(a);
|
|
}
|
|
function e(a) {
|
|
return '.' === a.charAt(0);
|
|
}
|
|
var f = {};
|
|
b.exports = f;
|
|
var g = a('./constants'),
|
|
h = function (a, b, c) {
|
|
if (a)
|
|
for (var d = 0; d < c.length; d++)
|
|
a.hasOwnProperty(c[d]) && (b[c[d]] = a[c[d]]);
|
|
},
|
|
i = [
|
|
'paths',
|
|
'rewriteUrls',
|
|
'rootpath',
|
|
'strictImports',
|
|
'insecure',
|
|
'dumpLineNumbers',
|
|
'compress',
|
|
'syncImport',
|
|
'chunkInput',
|
|
'mime',
|
|
'useFileCache',
|
|
'processImports',
|
|
'pluginManager',
|
|
];
|
|
f.Parse = function (a) {
|
|
h(a, this, i),
|
|
'string' == typeof this.paths && (this.paths = [this.paths]);
|
|
};
|
|
var j = [
|
|
'paths',
|
|
'compress',
|
|
'ieCompat',
|
|
'math',
|
|
'strictUnits',
|
|
'sourceMap',
|
|
'importMultiple',
|
|
'urlArgs',
|
|
'javascriptEnabled',
|
|
'pluginManager',
|
|
'importantScope',
|
|
'rewriteUrls',
|
|
];
|
|
(f.Eval = function (a, b) {
|
|
h(a, this, j),
|
|
'string' == typeof this.paths && (this.paths = [this.paths]),
|
|
(this.frames = b || []),
|
|
(this.importantScope = this.importantScope || []);
|
|
}),
|
|
(f.Eval.prototype.enterCalc = function () {
|
|
this.calcStack || (this.calcStack = []),
|
|
this.calcStack.push(!0),
|
|
(this.inCalc = !0);
|
|
}),
|
|
(f.Eval.prototype.exitCalc = function () {
|
|
this.calcStack.pop(), this.calcStack || (this.inCalc = !1);
|
|
}),
|
|
(f.Eval.prototype.inParenthesis = function () {
|
|
this.parensStack || (this.parensStack = []),
|
|
this.parensStack.push(!0);
|
|
}),
|
|
(f.Eval.prototype.outOfParenthesis = function () {
|
|
this.parensStack.pop();
|
|
}),
|
|
(f.Eval.prototype.inCalc = !1),
|
|
(f.Eval.prototype.mathOn = !0),
|
|
(f.Eval.prototype.isMathOn = function (a) {
|
|
return (
|
|
!!this.mathOn &&
|
|
!!(
|
|
'/' !== a ||
|
|
this.math === g.Math.ALWAYS ||
|
|
(this.parensStack && this.parensStack.length)
|
|
) &&
|
|
(!(this.math > g.Math.PARENS_DIVISION) ||
|
|
(this.parensStack && this.parensStack.length))
|
|
);
|
|
}),
|
|
(f.Eval.prototype.pathRequiresRewrite = function (a) {
|
|
var b = this.rewriteUrls === g.RewriteUrls.LOCAL ? e : d;
|
|
return b(a);
|
|
}),
|
|
(f.Eval.prototype.rewritePath = function (a, b) {
|
|
var c;
|
|
return (
|
|
(b = b || ''),
|
|
(c = this.normalizePath(b + a)),
|
|
e(a) && d(b) && e(c) === !1 && (c = './' + c),
|
|
c
|
|
);
|
|
}),
|
|
(f.Eval.prototype.normalizePath = function (a) {
|
|
var b,
|
|
c = a.split('/').reverse();
|
|
for (a = []; 0 !== c.length; )
|
|
switch ((b = c.pop())) {
|
|
case '.':
|
|
break;
|
|
case '..':
|
|
0 === a.length || '..' === a[a.length - 1]
|
|
? a.push(b)
|
|
: a.pop();
|
|
break;
|
|
default:
|
|
a.push(b);
|
|
}
|
|
return a.join('/');
|
|
});
|
|
},
|
|
{ './constants': 12 },
|
|
],
|
|
14: [
|
|
function (a, b, c) {
|
|
b.exports = {
|
|
aliceblue: '#f0f8ff',
|
|
antiquewhite: '#faebd7',
|
|
aqua: '#00ffff',
|
|
aquamarine: '#7fffd4',
|
|
azure: '#f0ffff',
|
|
beige: '#f5f5dc',
|
|
bisque: '#ffe4c4',
|
|
black: '#000000',
|
|
blanchedalmond: '#ffebcd',
|
|
blue: '#0000ff',
|
|
blueviolet: '#8a2be2',
|
|
brown: '#a52a2a',
|
|
burlywood: '#deb887',
|
|
cadetblue: '#5f9ea0',
|
|
chartreuse: '#7fff00',
|
|
chocolate: '#d2691e',
|
|
coral: '#ff7f50',
|
|
cornflowerblue: '#6495ed',
|
|
cornsilk: '#fff8dc',
|
|
crimson: '#dc143c',
|
|
cyan: '#00ffff',
|
|
darkblue: '#00008b',
|
|
darkcyan: '#008b8b',
|
|
darkgoldenrod: '#b8860b',
|
|
darkgray: '#a9a9a9',
|
|
darkgrey: '#a9a9a9',
|
|
darkgreen: '#006400',
|
|
darkkhaki: '#bdb76b',
|
|
darkmagenta: '#8b008b',
|
|
darkolivegreen: '#556b2f',
|
|
darkorange: '#ff8c00',
|
|
darkorchid: '#9932cc',
|
|
darkred: '#8b0000',
|
|
darksalmon: '#e9967a',
|
|
darkseagreen: '#8fbc8f',
|
|
darkslateblue: '#483d8b',
|
|
darkslategray: '#2f4f4f',
|
|
darkslategrey: '#2f4f4f',
|
|
darkturquoise: '#00ced1',
|
|
darkviolet: '#9400d3',
|
|
deeppink: '#ff1493',
|
|
deepskyblue: '#00bfff',
|
|
dimgray: '#696969',
|
|
dimgrey: '#696969',
|
|
dodgerblue: '#1e90ff',
|
|
firebrick: '#b22222',
|
|
floralwhite: '#fffaf0',
|
|
forestgreen: '#228b22',
|
|
fuchsia: '#ff00ff',
|
|
gainsboro: '#dcdcdc',
|
|
ghostwhite: '#f8f8ff',
|
|
gold: '#ffd700',
|
|
goldenrod: '#daa520',
|
|
gray: '#808080',
|
|
grey: '#808080',
|
|
green: '#008000',
|
|
greenyellow: '#adff2f',
|
|
honeydew: '#f0fff0',
|
|
hotpink: '#ff69b4',
|
|
indianred: '#cd5c5c',
|
|
indigo: '#4b0082',
|
|
ivory: '#fffff0',
|
|
khaki: '#f0e68c',
|
|
lavender: '#e6e6fa',
|
|
lavenderblush: '#fff0f5',
|
|
lawngreen: '#7cfc00',
|
|
lemonchiffon: '#fffacd',
|
|
lightblue: '#add8e6',
|
|
lightcoral: '#f08080',
|
|
lightcyan: '#e0ffff',
|
|
lightgoldenrodyellow: '#fafad2',
|
|
lightgray: '#d3d3d3',
|
|
lightgrey: '#d3d3d3',
|
|
lightgreen: '#90ee90',
|
|
lightpink: '#ffb6c1',
|
|
lightsalmon: '#ffa07a',
|
|
lightseagreen: '#20b2aa',
|
|
lightskyblue: '#87cefa',
|
|
lightslategray: '#778899',
|
|
lightslategrey: '#778899',
|
|
lightsteelblue: '#b0c4de',
|
|
lightyellow: '#ffffe0',
|
|
lime: '#00ff00',
|
|
limegreen: '#32cd32',
|
|
linen: '#faf0e6',
|
|
magenta: '#ff00ff',
|
|
maroon: '#800000',
|
|
mediumaquamarine: '#66cdaa',
|
|
mediumblue: '#0000cd',
|
|
mediumorchid: '#ba55d3',
|
|
mediumpurple: '#9370d8',
|
|
mediumseagreen: '#3cb371',
|
|
mediumslateblue: '#7b68ee',
|
|
mediumspringgreen: '#00fa9a',
|
|
mediumturquoise: '#48d1cc',
|
|
mediumvioletred: '#c71585',
|
|
midnightblue: '#191970',
|
|
mintcream: '#f5fffa',
|
|
mistyrose: '#ffe4e1',
|
|
moccasin: '#ffe4b5',
|
|
navajowhite: '#ffdead',
|
|
navy: '#000080',
|
|
oldlace: '#fdf5e6',
|
|
olive: '#808000',
|
|
olivedrab: '#6b8e23',
|
|
orange: '#ffa500',
|
|
orangered: '#ff4500',
|
|
orchid: '#da70d6',
|
|
palegoldenrod: '#eee8aa',
|
|
palegreen: '#98fb98',
|
|
paleturquoise: '#afeeee',
|
|
palevioletred: '#d87093',
|
|
papayawhip: '#ffefd5',
|
|
peachpuff: '#ffdab9',
|
|
peru: '#cd853f',
|
|
pink: '#ffc0cb',
|
|
plum: '#dda0dd',
|
|
powderblue: '#b0e0e6',
|
|
purple: '#800080',
|
|
rebeccapurple: '#663399',
|
|
red: '#ff0000',
|
|
rosybrown: '#bc8f8f',
|
|
royalblue: '#4169e1',
|
|
saddlebrown: '#8b4513',
|
|
salmon: '#fa8072',
|
|
sandybrown: '#f4a460',
|
|
seagreen: '#2e8b57',
|
|
seashell: '#fff5ee',
|
|
sienna: '#a0522d',
|
|
silver: '#c0c0c0',
|
|
skyblue: '#87ceeb',
|
|
slateblue: '#6a5acd',
|
|
slategray: '#708090',
|
|
slategrey: '#708090',
|
|
snow: '#fffafa',
|
|
springgreen: '#00ff7f',
|
|
steelblue: '#4682b4',
|
|
tan: '#d2b48c',
|
|
teal: '#008080',
|
|
thistle: '#d8bfd8',
|
|
tomato: '#ff6347',
|
|
turquoise: '#40e0d0',
|
|
violet: '#ee82ee',
|
|
wheat: '#f5deb3',
|
|
white: '#ffffff',
|
|
whitesmoke: '#f5f5f5',
|
|
yellow: '#ffff00',
|
|
yellowgreen: '#9acd32',
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
15: [
|
|
function (a, b, c) {
|
|
b.exports = {
|
|
colors: a('./colors'),
|
|
unitConversions: a('./unit-conversions'),
|
|
};
|
|
},
|
|
{ './colors': 14, './unit-conversions': 16 },
|
|
],
|
|
16: [
|
|
function (a, b, c) {
|
|
b.exports = {
|
|
length: {
|
|
m: 1,
|
|
cm: 0.01,
|
|
mm: 0.001,
|
|
in: 0.0254,
|
|
px: 0.0254 / 96,
|
|
pt: 0.0254 / 72,
|
|
pc: (0.0254 / 72) * 12,
|
|
},
|
|
duration: { s: 1, ms: 0.001 },
|
|
angle: {
|
|
rad: 1 / (2 * Math.PI),
|
|
deg: 1 / 360,
|
|
grad: 0.0025,
|
|
turn: 1,
|
|
},
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
17: [
|
|
function (a, b, c) {
|
|
b.exports = function () {
|
|
return {
|
|
javascriptEnabled: !1,
|
|
depends: !1,
|
|
compress: !1,
|
|
lint: !1,
|
|
paths: [],
|
|
color: !0,
|
|
strictImports: !1,
|
|
insecure: !1,
|
|
rootpath: '',
|
|
rewriteUrls: !1,
|
|
ieCompat: !1,
|
|
math: 0,
|
|
strictUnits: !1,
|
|
globalVars: null,
|
|
modifyVars: null,
|
|
urlArgs: '',
|
|
};
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
18: [
|
|
function (a, b, c) {
|
|
var d = function () {};
|
|
(d.prototype.getPath = function (a) {
|
|
var b = a.lastIndexOf('?');
|
|
return (
|
|
b > 0 && (a = a.slice(0, b)),
|
|
(b = a.lastIndexOf('/')),
|
|
b < 0 && (b = a.lastIndexOf('\\')),
|
|
b < 0 ? '' : a.slice(0, b + 1)
|
|
);
|
|
}),
|
|
(d.prototype.tryAppendExtension = function (a, b) {
|
|
return /(\.[a-z]*$)|([\?;].*)$/.test(a) ? a : a + b;
|
|
}),
|
|
(d.prototype.tryAppendLessExtension = function (a) {
|
|
return this.tryAppendExtension(a, '.less');
|
|
}),
|
|
(d.prototype.supportsSync = function () {
|
|
return !1;
|
|
}),
|
|
(d.prototype.alwaysMakePathsAbsolute = function () {
|
|
return !1;
|
|
}),
|
|
(d.prototype.isPathAbsolute = function (a) {
|
|
return /^(?:[a-z-]+:|\/|\\|#)/i.test(a);
|
|
}),
|
|
(d.prototype.join = function (a, b) {
|
|
return a ? a + b : b;
|
|
}),
|
|
(d.prototype.pathDiff = function (a, b) {
|
|
var c,
|
|
d,
|
|
e,
|
|
f,
|
|
g = this.extractUrlParts(a),
|
|
h = this.extractUrlParts(b),
|
|
i = '';
|
|
if (g.hostPart !== h.hostPart) return '';
|
|
for (
|
|
d = Math.max(h.directories.length, g.directories.length), c = 0;
|
|
c < d && h.directories[c] === g.directories[c];
|
|
c++
|
|
);
|
|
for (
|
|
f = h.directories.slice(c), e = g.directories.slice(c), c = 0;
|
|
c < f.length - 1;
|
|
c++
|
|
)
|
|
i += '../';
|
|
for (c = 0; c < e.length - 1; c++) i += e[c] + '/';
|
|
return i;
|
|
}),
|
|
(d.prototype.extractUrlParts = function (a, b) {
|
|
var c,
|
|
d,
|
|
e =
|
|
/^((?:[a-z-]+:)?\/{2}(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i,
|
|
f = a.match(e),
|
|
g = {},
|
|
h = [],
|
|
i = [];
|
|
if (!f)
|
|
throw new Error("Could not parse sheet href - '" + a + "'");
|
|
if (b && (!f[1] || f[2])) {
|
|
if (((d = b.match(e)), !d))
|
|
throw new Error("Could not parse page url - '" + b + "'");
|
|
(f[1] = f[1] || d[1] || ''), f[2] || (f[3] = d[3] + f[3]);
|
|
}
|
|
if (f[3])
|
|
for (
|
|
h = f[3].replace(/\\/g, '/').split('/'), c = 0;
|
|
c < h.length;
|
|
c++
|
|
)
|
|
'..' === h[c] ? i.pop() : '.' !== h[c] && i.push(h[c]);
|
|
return (
|
|
(g.hostPart = f[1]),
|
|
(g.directories = i),
|
|
(g.rawPath = (f[1] || '') + h.join('/')),
|
|
(g.path = (f[1] || '') + i.join('/')),
|
|
(g.filename = f[4]),
|
|
(g.fileUrl = g.path + (f[4] || '')),
|
|
(g.url = g.fileUrl + (f[5] || '')),
|
|
g
|
|
);
|
|
}),
|
|
(b.exports = d);
|
|
},
|
|
{},
|
|
],
|
|
19: [
|
|
function (a, b, c) {
|
|
var d = a('../functions/function-registry'),
|
|
e = a('../less-error'),
|
|
f = function () {
|
|
this.require = function () {
|
|
return null;
|
|
};
|
|
};
|
|
(f.prototype.evalPlugin = function (a, b, c, f, g) {
|
|
var h, i, j, k, l, m, n;
|
|
(l = b.pluginManager),
|
|
g && (m = 'string' == typeof g ? g : g.filename);
|
|
var o = new this.less.FileManager().extractUrlParts(m).filename;
|
|
if (m && (j = l.get(m))) {
|
|
if ((n = this.trySetOptions(j, m, o, f))) return n;
|
|
try {
|
|
j.use && j.use.call(this.context, j);
|
|
} catch (p) {
|
|
return (
|
|
(p.message = p.message || 'Error during @plugin call'),
|
|
new e(p, c, m)
|
|
);
|
|
}
|
|
return j;
|
|
}
|
|
(k = { exports: {}, pluginManager: l, fileInfo: g }),
|
|
(i = d.create());
|
|
var q = function (a) {
|
|
j = a;
|
|
};
|
|
try {
|
|
(h = new Function(
|
|
'module',
|
|
'require',
|
|
'registerPlugin',
|
|
'functions',
|
|
'tree',
|
|
'less',
|
|
'fileInfo',
|
|
a,
|
|
)),
|
|
h(k, this.require(m), q, i, this.less.tree, this.less, g);
|
|
} catch (p) {
|
|
return new e(p, c, m);
|
|
}
|
|
if (
|
|
(j || (j = k.exports),
|
|
(j = this.validatePlugin(j, m, o)),
|
|
j instanceof e)
|
|
)
|
|
return j;
|
|
if (!j) return new e({ message: 'Not a valid plugin' }, c, m);
|
|
if (
|
|
((j.imports = c),
|
|
(j.filename = m),
|
|
(!j.minVersion ||
|
|
this.compareVersion('3.0.0', j.minVersion) < 0) &&
|
|
(n = this.trySetOptions(j, m, o, f)))
|
|
)
|
|
return n;
|
|
if (
|
|
(l.addPlugin(j, g.filename, i),
|
|
(j.functions = i.getLocalFunctions()),
|
|
(n = this.trySetOptions(j, m, o, f)))
|
|
)
|
|
return n;
|
|
try {
|
|
j.use && j.use.call(this.context, j);
|
|
} catch (p) {
|
|
return (
|
|
(p.message = p.message || 'Error during @plugin call'),
|
|
new e(p, c, m)
|
|
);
|
|
}
|
|
return j;
|
|
}),
|
|
(f.prototype.trySetOptions = function (a, b, c, d) {
|
|
if (d && !a.setOptions)
|
|
return new e({
|
|
message:
|
|
'Options have been provided but the plugin ' +
|
|
c +
|
|
' does not support any options.',
|
|
});
|
|
try {
|
|
a.setOptions && a.setOptions(d);
|
|
} catch (f) {
|
|
return new e(f);
|
|
}
|
|
}),
|
|
(f.prototype.validatePlugin = function (a, b, c) {
|
|
return a
|
|
? ('function' == typeof a && (a = new a()),
|
|
a.minVersion &&
|
|
this.compareVersion(a.minVersion, this.less.version) < 0
|
|
? new e({
|
|
message:
|
|
'Plugin ' +
|
|
c +
|
|
' requires version ' +
|
|
this.versionToString(a.minVersion),
|
|
})
|
|
: a)
|
|
: null;
|
|
}),
|
|
(f.prototype.compareVersion = function (a, b) {
|
|
'string' == typeof a &&
|
|
((a = a.match(/^(\d+)\.?(\d+)?\.?(\d+)?/)), a.shift());
|
|
for (var c = 0; c < a.length; c++)
|
|
if (a[c] !== b[c])
|
|
return parseInt(a[c]) > parseInt(b[c]) ? -1 : 1;
|
|
return 0;
|
|
}),
|
|
(f.prototype.versionToString = function (a) {
|
|
for (var b = '', c = 0; c < a.length; c++)
|
|
b += (b ? '.' : '') + a[c];
|
|
return b;
|
|
}),
|
|
(f.prototype.printUsage = function (a) {
|
|
for (var b = 0; b < a.length; b++) {
|
|
var c = a[b];
|
|
c.printUsage && c.printUsage();
|
|
}
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ '../functions/function-registry': 27, '../less-error': 38 },
|
|
],
|
|
20: [
|
|
function (a, b, c) {
|
|
var d = a('../logger'),
|
|
e = function (a, b) {
|
|
(this.fileManagers = b || []), (a = a || {});
|
|
for (
|
|
var c = [
|
|
'encodeBase64',
|
|
'mimeLookup',
|
|
'charsetLookup',
|
|
'getSourceMapGenerator',
|
|
],
|
|
d = [],
|
|
e = d.concat(c),
|
|
f = 0;
|
|
f < e.length;
|
|
f++
|
|
) {
|
|
var g = e[f],
|
|
h = a[g];
|
|
h
|
|
? (this[g] = h.bind(a))
|
|
: f < d.length &&
|
|
this.warn(
|
|
'missing required function in environment - ' + g,
|
|
);
|
|
}
|
|
};
|
|
(e.prototype.getFileManager = function (a, b, c, e, f) {
|
|
a ||
|
|
d.warn(
|
|
'getFileManager called with no filename.. Please report this issue. continuing.',
|
|
),
|
|
null == b &&
|
|
d.warn(
|
|
'getFileManager called with null directory.. Please report this issue. continuing.',
|
|
);
|
|
var g = this.fileManagers;
|
|
c.pluginManager &&
|
|
(g = [].concat(g).concat(c.pluginManager.getFileManagers()));
|
|
for (var h = g.length - 1; h >= 0; h--) {
|
|
var i = g[h];
|
|
if (i[f ? 'supportsSync' : 'supports'](a, b, c, e)) return i;
|
|
}
|
|
return null;
|
|
}),
|
|
(e.prototype.addFileManager = function (a) {
|
|
this.fileManagers.push(a);
|
|
}),
|
|
(e.prototype.clearFileManagers = function () {
|
|
this.fileManagers = [];
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ '../logger': 39 },
|
|
],
|
|
21: [
|
|
function (a, b, c) {
|
|
var d = a('./function-registry'),
|
|
e = a('../tree/anonymous'),
|
|
f = a('../tree/keyword');
|
|
d.addMultiple({
|
|
boolean: function (a) {
|
|
return a ? f.True : f.False;
|
|
},
|
|
if: function (a, b, c) {
|
|
return a ? b : c || new e();
|
|
},
|
|
});
|
|
},
|
|
{
|
|
'../tree/anonymous': 50,
|
|
'../tree/keyword': 70,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
22: [
|
|
function (a, b, c) {
|
|
function d(a, b, c) {
|
|
var d,
|
|
f,
|
|
g,
|
|
h,
|
|
i = b.alpha,
|
|
j = c.alpha,
|
|
k = [];
|
|
g = j + i * (1 - j);
|
|
for (var l = 0; l < 3; l++)
|
|
(d = b.rgb[l] / 255),
|
|
(f = c.rgb[l] / 255),
|
|
(h = a(d, f)),
|
|
g && (h = (j * f + i * (d - j * (d + f - h))) / g),
|
|
(k[l] = 255 * h);
|
|
return new e(k, g);
|
|
}
|
|
var e = a('../tree/color'),
|
|
f = a('./function-registry'),
|
|
g = {
|
|
multiply: function (a, b) {
|
|
return a * b;
|
|
},
|
|
screen: function (a, b) {
|
|
return a + b - a * b;
|
|
},
|
|
overlay: function (a, b) {
|
|
return (a *= 2), a <= 1 ? g.multiply(a, b) : g.screen(a - 1, b);
|
|
},
|
|
softlight: function (a, b) {
|
|
var c = 1,
|
|
d = a;
|
|
return (
|
|
b > 0.5 &&
|
|
((d = 1),
|
|
(c =
|
|
a > 0.25 ? Math.sqrt(a) : ((16 * a - 12) * a + 4) * a)),
|
|
a - (1 - 2 * b) * d * (c - a)
|
|
);
|
|
},
|
|
hardlight: function (a, b) {
|
|
return g.overlay(b, a);
|
|
},
|
|
difference: function (a, b) {
|
|
return Math.abs(a - b);
|
|
},
|
|
exclusion: function (a, b) {
|
|
return a + b - 2 * a * b;
|
|
},
|
|
average: function (a, b) {
|
|
return (a + b) / 2;
|
|
},
|
|
negation: function (a, b) {
|
|
return 1 - Math.abs(a + b - 1);
|
|
},
|
|
};
|
|
for (var h in g) g.hasOwnProperty(h) && (d[h] = d.bind(null, g[h]));
|
|
f.addMultiple(d);
|
|
},
|
|
{ '../tree/color': 55, './function-registry': 27 },
|
|
],
|
|
23: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
return Math.min(1, Math.max(0, a));
|
|
}
|
|
function e(a, b) {
|
|
var c = h.hsla(b.h, b.s, b.l, b.a);
|
|
if (c)
|
|
return (
|
|
(c.value =
|
|
a.value && /^(rgb|hsl)/.test(a.value) ? a.value : 'rgb'),
|
|
c
|
|
);
|
|
}
|
|
function f(a) {
|
|
if (a instanceof i)
|
|
return parseFloat(a.unit.is('%') ? a.value / 100 : a.value);
|
|
if ('number' == typeof a) return a;
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'color functions take numbers as parameters',
|
|
};
|
|
}
|
|
function g(a, b) {
|
|
return a instanceof i && a.unit.is('%')
|
|
? parseFloat((a.value * b) / 100)
|
|
: f(a);
|
|
}
|
|
var h,
|
|
i = a('../tree/dimension'),
|
|
j = a('../tree/color'),
|
|
k = a('../tree/quoted'),
|
|
l = a('../tree/anonymous'),
|
|
m = a('./function-registry');
|
|
(h = {
|
|
rgb: function (a, b, c) {
|
|
var d = h.rgba(a, b, c, 1);
|
|
if (d) return (d.value = 'rgb'), d;
|
|
},
|
|
rgba: function (a, b, c, d) {
|
|
try {
|
|
if (a instanceof j)
|
|
return (d = b ? f(b) : a.alpha), new j(a.rgb, d, 'rgba');
|
|
var e = [a, b, c].map(function (a) {
|
|
return g(a, 255);
|
|
});
|
|
return (d = f(d)), new j(e, d, 'rgba');
|
|
} catch (h) {}
|
|
},
|
|
hsl: function (a, b, c) {
|
|
var d = h.hsla(a, b, c, 1);
|
|
if (d) return (d.value = 'hsl'), d;
|
|
},
|
|
hsla: function (a, b, c, e) {
|
|
function g(a) {
|
|
return (
|
|
(a = a < 0 ? a + 1 : a > 1 ? a - 1 : a),
|
|
6 * a < 1
|
|
? h + (i - h) * a * 6
|
|
: 2 * a < 1
|
|
? i
|
|
: 3 * a < 2
|
|
? h + (i - h) * (2 / 3 - a) * 6
|
|
: h
|
|
);
|
|
}
|
|
try {
|
|
if (a instanceof j)
|
|
return (e = b ? f(b) : a.alpha), new j(a.rgb, e, 'hsla');
|
|
var h, i;
|
|
(a = (f(a) % 360) / 360),
|
|
(b = d(f(b))),
|
|
(c = d(f(c))),
|
|
(e = d(f(e))),
|
|
(i = c <= 0.5 ? c * (b + 1) : c + b - c * b),
|
|
(h = 2 * c - i);
|
|
var k = [255 * g(a + 1 / 3), 255 * g(a), 255 * g(a - 1 / 3)];
|
|
return (e = f(e)), new j(k, e, 'hsla');
|
|
} catch (l) {}
|
|
},
|
|
hsv: function (a, b, c) {
|
|
return h.hsva(a, b, c, 1);
|
|
},
|
|
hsva: function (a, b, c, d) {
|
|
(a = ((f(a) % 360) / 360) * 360),
|
|
(b = f(b)),
|
|
(c = f(c)),
|
|
(d = f(d));
|
|
var e, g;
|
|
(e = Math.floor((a / 60) % 6)), (g = a / 60 - e);
|
|
var i = [c, c * (1 - b), c * (1 - g * b), c * (1 - (1 - g) * b)],
|
|
j = [
|
|
[0, 3, 1],
|
|
[2, 0, 1],
|
|
[1, 0, 3],
|
|
[1, 2, 0],
|
|
[3, 1, 0],
|
|
[0, 1, 2],
|
|
];
|
|
return h.rgba(
|
|
255 * i[j[e][0]],
|
|
255 * i[j[e][1]],
|
|
255 * i[j[e][2]],
|
|
d,
|
|
);
|
|
},
|
|
hue: function (a) {
|
|
return new i(a.toHSL().h);
|
|
},
|
|
saturation: function (a) {
|
|
return new i(100 * a.toHSL().s, '%');
|
|
},
|
|
lightness: function (a) {
|
|
return new i(100 * a.toHSL().l, '%');
|
|
},
|
|
hsvhue: function (a) {
|
|
return new i(a.toHSV().h);
|
|
},
|
|
hsvsaturation: function (a) {
|
|
return new i(100 * a.toHSV().s, '%');
|
|
},
|
|
hsvvalue: function (a) {
|
|
return new i(100 * a.toHSV().v, '%');
|
|
},
|
|
red: function (a) {
|
|
return new i(a.rgb[0]);
|
|
},
|
|
green: function (a) {
|
|
return new i(a.rgb[1]);
|
|
},
|
|
blue: function (a) {
|
|
return new i(a.rgb[2]);
|
|
},
|
|
alpha: function (a) {
|
|
return new i(a.toHSL().a);
|
|
},
|
|
luma: function (a) {
|
|
return new i(a.luma() * a.alpha * 100, '%');
|
|
},
|
|
luminance: function (a) {
|
|
var b =
|
|
(0.2126 * a.rgb[0]) / 255 +
|
|
(0.7152 * a.rgb[1]) / 255 +
|
|
(0.0722 * a.rgb[2]) / 255;
|
|
return new i(b * a.alpha * 100, '%');
|
|
},
|
|
saturate: function (a, b, c) {
|
|
if (!a.rgb) return null;
|
|
var f = a.toHSL();
|
|
return (
|
|
(f.s +=
|
|
'undefined' != typeof c && 'relative' === c.value
|
|
? (f.s * b.value) / 100
|
|
: b.value / 100),
|
|
(f.s = d(f.s)),
|
|
e(a, f)
|
|
);
|
|
},
|
|
desaturate: function (a, b, c) {
|
|
var f = a.toHSL();
|
|
return (
|
|
(f.s -=
|
|
'undefined' != typeof c && 'relative' === c.value
|
|
? (f.s * b.value) / 100
|
|
: b.value / 100),
|
|
(f.s = d(f.s)),
|
|
e(a, f)
|
|
);
|
|
},
|
|
lighten: function (a, b, c) {
|
|
var f = a.toHSL();
|
|
return (
|
|
(f.l +=
|
|
'undefined' != typeof c && 'relative' === c.value
|
|
? (f.l * b.value) / 100
|
|
: b.value / 100),
|
|
(f.l = d(f.l)),
|
|
e(a, f)
|
|
);
|
|
},
|
|
darken: function (a, b, c) {
|
|
var f = a.toHSL();
|
|
return (
|
|
(f.l -=
|
|
'undefined' != typeof c && 'relative' === c.value
|
|
? (f.l * b.value) / 100
|
|
: b.value / 100),
|
|
(f.l = d(f.l)),
|
|
e(a, f)
|
|
);
|
|
},
|
|
fadein: function (a, b, c) {
|
|
var f = a.toHSL();
|
|
return (
|
|
(f.a +=
|
|
'undefined' != typeof c && 'relative' === c.value
|
|
? (f.a * b.value) / 100
|
|
: b.value / 100),
|
|
(f.a = d(f.a)),
|
|
e(a, f)
|
|
);
|
|
},
|
|
fadeout: function (a, b, c) {
|
|
var f = a.toHSL();
|
|
return (
|
|
(f.a -=
|
|
'undefined' != typeof c && 'relative' === c.value
|
|
? (f.a * b.value) / 100
|
|
: b.value / 100),
|
|
(f.a = d(f.a)),
|
|
e(a, f)
|
|
);
|
|
},
|
|
fade: function (a, b) {
|
|
var c = a.toHSL();
|
|
return (c.a = b.value / 100), (c.a = d(c.a)), e(a, c);
|
|
},
|
|
spin: function (a, b) {
|
|
var c = a.toHSL(),
|
|
d = (c.h + b.value) % 360;
|
|
return (c.h = d < 0 ? 360 + d : d), e(a, c);
|
|
},
|
|
mix: function (a, b, c) {
|
|
(a.toHSL && b.toHSL) || (console.log(b.type), console.dir(b)),
|
|
c || (c = new i(50));
|
|
var d = c.value / 100,
|
|
e = 2 * d - 1,
|
|
f = a.toHSL().a - b.toHSL().a,
|
|
g = ((e * f == -1 ? e : (e + f) / (1 + e * f)) + 1) / 2,
|
|
h = 1 - g,
|
|
k = [
|
|
a.rgb[0] * g + b.rgb[0] * h,
|
|
a.rgb[1] * g + b.rgb[1] * h,
|
|
a.rgb[2] * g + b.rgb[2] * h,
|
|
],
|
|
l = a.alpha * d + b.alpha * (1 - d);
|
|
return new j(k, l);
|
|
},
|
|
greyscale: function (a) {
|
|
return h.desaturate(a, new i(100));
|
|
},
|
|
contrast: function (a, b, c, d) {
|
|
if (!a.rgb) return null;
|
|
if (
|
|
('undefined' == typeof c && (c = h.rgba(255, 255, 255, 1)),
|
|
'undefined' == typeof b && (b = h.rgba(0, 0, 0, 1)),
|
|
b.luma() > c.luma())
|
|
) {
|
|
var e = c;
|
|
(c = b), (b = e);
|
|
}
|
|
return (
|
|
(d = 'undefined' == typeof d ? 0.43 : f(d)),
|
|
a.luma() < d ? c : b
|
|
);
|
|
},
|
|
argb: function (a) {
|
|
return new l(a.toARGB());
|
|
},
|
|
color: function (a) {
|
|
if (
|
|
a instanceof k &&
|
|
/^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})$/i.test(
|
|
a.value,
|
|
)
|
|
) {
|
|
var b = a.value.slice(1);
|
|
return new j(b, void 0, '#' + b);
|
|
}
|
|
if (a instanceof j || (a = j.fromKeyword(a.value)))
|
|
return (a.value = void 0), a;
|
|
throw {
|
|
type: 'Argument',
|
|
message:
|
|
'argument must be a color keyword or 3|4|6|8 digit hex e.g. #FFF',
|
|
};
|
|
},
|
|
tint: function (a, b) {
|
|
return h.mix(h.rgb(255, 255, 255), a, b);
|
|
},
|
|
shade: function (a, b) {
|
|
return h.mix(h.rgb(0, 0, 0), a, b);
|
|
},
|
|
}),
|
|
m.addMultiple(h);
|
|
},
|
|
{
|
|
'../tree/anonymous': 50,
|
|
'../tree/color': 55,
|
|
'../tree/dimension': 62,
|
|
'../tree/quoted': 80,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
24: [
|
|
function (a, b, c) {
|
|
b.exports = function (b) {
|
|
var c = a('../tree/quoted'),
|
|
d = a('../tree/url'),
|
|
e = a('../utils'),
|
|
f = a('./function-registry'),
|
|
g = function (a, b) {
|
|
return new d(b, a.index, a.currentFileInfo).eval(a.context);
|
|
},
|
|
h = a('../logger');
|
|
f.add('data-uri', function (a, f) {
|
|
f || ((f = a), (a = null));
|
|
var i = a && a.value,
|
|
j = f.value,
|
|
k = this.currentFileInfo,
|
|
l = k.rewriteUrls ? k.currentDirectory : k.entryPath,
|
|
m = j.indexOf('#'),
|
|
n = '';
|
|
m !== -1 && ((n = j.slice(m)), (j = j.slice(0, m)));
|
|
var o = e.clone(this.context);
|
|
o.rawBuffer = !0;
|
|
var p = b.getFileManager(j, l, o, b, !0);
|
|
if (!p) return g(this, f);
|
|
var q = !1;
|
|
if (a) q = /;base64$/.test(i);
|
|
else {
|
|
if (((i = b.mimeLookup(j)), 'image/svg+xml' === i)) q = !1;
|
|
else {
|
|
var r = b.charsetLookup(i);
|
|
q = ['US-ASCII', 'UTF-8'].indexOf(r) < 0;
|
|
}
|
|
q && (i += ';base64');
|
|
}
|
|
var s = p.loadFileSync(j, l, o, b);
|
|
if (!s.contents)
|
|
return (
|
|
h.warn(
|
|
'Skipped data-uri embedding of ' +
|
|
j +
|
|
' because file not found',
|
|
),
|
|
g(this, f || a)
|
|
);
|
|
var t = s.contents;
|
|
if (q && !b.encodeBase64) return g(this, f);
|
|
t = q ? b.encodeBase64(t) : encodeURIComponent(t);
|
|
var u = 'data:' + i + ',' + t + n,
|
|
v = 32768;
|
|
return u.length >= v && this.context.ieCompat !== !1
|
|
? (h.warn(
|
|
'Skipped data-uri embedding of ' +
|
|
j +
|
|
' because its size (' +
|
|
u.length +
|
|
' characters) exceeds IE8-safe ' +
|
|
v +
|
|
' characters!',
|
|
),
|
|
g(this, f || a))
|
|
: new d(
|
|
new c(
|
|
'"' + u + '"',
|
|
u,
|
|
!1,
|
|
this.index,
|
|
this.currentFileInfo,
|
|
),
|
|
this.index,
|
|
this.currentFileInfo,
|
|
);
|
|
});
|
|
};
|
|
},
|
|
{
|
|
'../logger': 39,
|
|
'../tree/quoted': 80,
|
|
'../tree/url': 85,
|
|
'../utils': 89,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
25: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/keyword'),
|
|
e = a('./function-registry'),
|
|
f = {
|
|
eval: function () {
|
|
var a = this.value_,
|
|
b = this.error_;
|
|
if (b) throw b;
|
|
if (null != a) return a ? d.True : d.False;
|
|
},
|
|
value: function (a) {
|
|
this.value_ = a;
|
|
},
|
|
error: function (a) {
|
|
this.error_ = a;
|
|
},
|
|
reset: function () {
|
|
this.value_ = this.error_ = null;
|
|
},
|
|
};
|
|
e.add('default', f.eval.bind(f)), (b.exports = f);
|
|
},
|
|
{ '../tree/keyword': 70, './function-registry': 27 },
|
|
],
|
|
26: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/expression'),
|
|
e = function (a, b, c, d) {
|
|
(this.name = a.toLowerCase()),
|
|
(this.index = c),
|
|
(this.context = b),
|
|
(this.currentFileInfo = d),
|
|
(this.func = b.frames[0].functionRegistry.get(this.name));
|
|
};
|
|
(e.prototype.isValid = function () {
|
|
return Boolean(this.func);
|
|
}),
|
|
(e.prototype.call = function (a) {
|
|
return (
|
|
Array.isArray(a) &&
|
|
(a = a
|
|
.filter(function (a) {
|
|
return 'Comment' !== a.type;
|
|
})
|
|
.map(function (a) {
|
|
if ('Expression' === a.type) {
|
|
var b = a.value.filter(function (a) {
|
|
return 'Comment' !== a.type;
|
|
});
|
|
return 1 === b.length ? b[0] : new d(b);
|
|
}
|
|
return a;
|
|
})),
|
|
this.func.apply(this, a)
|
|
);
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ '../tree/expression': 64 },
|
|
],
|
|
27: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
return {
|
|
_data: {},
|
|
add: function (a, b) {
|
|
(a = a.toLowerCase()),
|
|
this._data.hasOwnProperty(a),
|
|
(this._data[a] = b);
|
|
},
|
|
addMultiple: function (a) {
|
|
Object.keys(a).forEach(
|
|
function (b) {
|
|
this.add(b, a[b]);
|
|
}.bind(this),
|
|
);
|
|
},
|
|
get: function (b) {
|
|
return this._data[b] || (a && a.get(b));
|
|
},
|
|
getLocalFunctions: function () {
|
|
return this._data;
|
|
},
|
|
inherit: function () {
|
|
return d(this);
|
|
},
|
|
create: function (a) {
|
|
return d(a);
|
|
},
|
|
};
|
|
}
|
|
b.exports = d(null);
|
|
},
|
|
{},
|
|
],
|
|
28: [
|
|
function (a, b, c) {
|
|
b.exports = function (b) {
|
|
var c = {
|
|
functionRegistry: a('./function-registry'),
|
|
functionCaller: a('./function-caller'),
|
|
};
|
|
return (
|
|
a('./boolean'),
|
|
a('./default'),
|
|
a('./color'),
|
|
a('./color-blending'),
|
|
a('./data-uri')(b),
|
|
a('./list'),
|
|
a('./math'),
|
|
a('./number'),
|
|
a('./string'),
|
|
a('./svg')(b),
|
|
a('./types'),
|
|
c
|
|
);
|
|
};
|
|
},
|
|
{
|
|
'./boolean': 21,
|
|
'./color': 23,
|
|
'./color-blending': 22,
|
|
'./data-uri': 24,
|
|
'./default': 25,
|
|
'./function-caller': 26,
|
|
'./function-registry': 27,
|
|
'./list': 29,
|
|
'./math': 31,
|
|
'./number': 32,
|
|
'./string': 33,
|
|
'./svg': 34,
|
|
'./types': 35,
|
|
},
|
|
],
|
|
29: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/dimension'),
|
|
e = a('../tree/declaration'),
|
|
f = a('../tree/ruleset'),
|
|
g = a('../tree/selector'),
|
|
h = a('../tree/element'),
|
|
i = a('./function-registry'),
|
|
j = function (a) {
|
|
var b = Array.isArray(a.value) ? a.value : Array(a);
|
|
return b;
|
|
};
|
|
i.addMultiple({
|
|
_SELF: function (a) {
|
|
return a;
|
|
},
|
|
extract: function (a, b) {
|
|
return (b = b.value - 1), j(a)[b];
|
|
},
|
|
length: function (a) {
|
|
return new d(j(a).length);
|
|
},
|
|
each: function (a, b) {
|
|
var c,
|
|
i,
|
|
j = 0,
|
|
k = [];
|
|
i = a.value
|
|
? Array.isArray(a.value)
|
|
? a.value
|
|
: [a.value]
|
|
: a.ruleset
|
|
? a.ruleset.rules
|
|
: Array.isArray(a)
|
|
? a
|
|
: [a];
|
|
var l = '@value',
|
|
m = '@key',
|
|
n = '@index';
|
|
return (
|
|
b.params
|
|
? ((l = b.params[0] && b.params[0].name),
|
|
(m = b.params[1] && b.params[1].name),
|
|
(n = b.params[2] && b.params[2].name),
|
|
(b = b.rules))
|
|
: (b = b.ruleset),
|
|
i.forEach(function (a) {
|
|
j += 1;
|
|
var i, o;
|
|
a instanceof e
|
|
? ((i =
|
|
'string' == typeof a.name ? a.name : a.name[0].value),
|
|
(o = a.value))
|
|
: ((i = new d(j)), (o = a)),
|
|
(c = b.rules.slice(0)),
|
|
l &&
|
|
c.push(
|
|
new e(l, o, !1, !1, this.index, this.currentFileInfo),
|
|
),
|
|
n &&
|
|
c.push(
|
|
new e(
|
|
n,
|
|
new d(j),
|
|
!1,
|
|
!1,
|
|
this.index,
|
|
this.currentFileInfo,
|
|
),
|
|
),
|
|
m &&
|
|
c.push(
|
|
new e(m, i, !1, !1, this.index, this.currentFileInfo),
|
|
),
|
|
k.push(
|
|
new f(
|
|
[new g([new h('', '&')])],
|
|
c,
|
|
b.strictImports,
|
|
b.visibilityInfo(),
|
|
),
|
|
);
|
|
}),
|
|
new f(
|
|
[new g([new h('', '&')])],
|
|
k,
|
|
b.strictImports,
|
|
b.visibilityInfo(),
|
|
).eval(this.context)
|
|
);
|
|
},
|
|
});
|
|
},
|
|
{
|
|
'../tree/declaration': 60,
|
|
'../tree/dimension': 62,
|
|
'../tree/element': 63,
|
|
'../tree/ruleset': 81,
|
|
'../tree/selector': 82,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
30: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/dimension'),
|
|
e = function () {};
|
|
(e._math = function (a, b, c) {
|
|
if (!(c instanceof d))
|
|
throw { type: 'Argument', message: 'argument must be a number' };
|
|
return (
|
|
null == b ? (b = c.unit) : (c = c.unify()),
|
|
new d(a(parseFloat(c.value)), b)
|
|
);
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ '../tree/dimension': 62 },
|
|
],
|
|
31: [
|
|
function (a, b, c) {
|
|
var d = a('./function-registry'),
|
|
e = a('./math-helper.js'),
|
|
f = {
|
|
ceil: null,
|
|
floor: null,
|
|
sqrt: null,
|
|
abs: null,
|
|
tan: '',
|
|
sin: '',
|
|
cos: '',
|
|
atan: 'rad',
|
|
asin: 'rad',
|
|
acos: 'rad',
|
|
};
|
|
for (var g in f)
|
|
f.hasOwnProperty(g) && (f[g] = e._math.bind(null, Math[g], f[g]));
|
|
(f.round = function (a, b) {
|
|
var c = 'undefined' == typeof b ? 0 : b.value;
|
|
return e._math(
|
|
function (a) {
|
|
return a.toFixed(c);
|
|
},
|
|
null,
|
|
a,
|
|
);
|
|
}),
|
|
d.addMultiple(f);
|
|
},
|
|
{ './function-registry': 27, './math-helper.js': 30 },
|
|
],
|
|
32: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/dimension'),
|
|
e = a('../tree/anonymous'),
|
|
f = a('./function-registry'),
|
|
g = a('./math-helper.js'),
|
|
h = function (a, b) {
|
|
switch (((b = Array.prototype.slice.call(b)), b.length)) {
|
|
case 0:
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'one or more arguments required',
|
|
};
|
|
}
|
|
var c,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
j,
|
|
k,
|
|
l,
|
|
m = [],
|
|
n = {};
|
|
for (c = 0; c < b.length; c++)
|
|
if (((g = b[c]), g instanceof d))
|
|
if (
|
|
((h =
|
|
'' === g.unit.toString() && void 0 !== l
|
|
? new d(g.value, l).unify()
|
|
: g.unify()),
|
|
(j =
|
|
'' === h.unit.toString() && void 0 !== k
|
|
? k
|
|
: h.unit.toString()),
|
|
(k =
|
|
('' !== j && void 0 === k) ||
|
|
('' !== j && '' === m[0].unify().unit.toString())
|
|
? j
|
|
: k),
|
|
(l = '' !== j && void 0 === l ? g.unit.toString() : l),
|
|
(f =
|
|
void 0 !== n[''] && '' !== j && j === k ? n[''] : n[j]),
|
|
void 0 !== f)
|
|
)
|
|
(i =
|
|
'' === m[f].unit.toString() && void 0 !== l
|
|
? new d(m[f].value, l).unify()
|
|
: m[f].unify()),
|
|
((a && h.value < i.value) || (!a && h.value > i.value)) &&
|
|
(m[f] = g);
|
|
else {
|
|
if (void 0 !== k && j !== k)
|
|
throw { type: 'Argument', message: 'incompatible types' };
|
|
(n[j] = m.length), m.push(g);
|
|
}
|
|
else
|
|
Array.isArray(b[c].value) &&
|
|
Array.prototype.push.apply(
|
|
b,
|
|
Array.prototype.slice.call(b[c].value),
|
|
);
|
|
return 1 == m.length
|
|
? m[0]
|
|
: ((b = m
|
|
.map(function (a) {
|
|
return a.toCSS(this.context);
|
|
})
|
|
.join(this.context.compress ? ',' : ', ')),
|
|
new e((a ? 'min' : 'max') + '(' + b + ')'));
|
|
};
|
|
f.addMultiple({
|
|
min: function () {
|
|
return h(!0, arguments);
|
|
},
|
|
max: function () {
|
|
return h(!1, arguments);
|
|
},
|
|
convert: function (a, b) {
|
|
return a.convertTo(b.value);
|
|
},
|
|
pi: function () {
|
|
return new d(Math.PI);
|
|
},
|
|
mod: function (a, b) {
|
|
return new d(a.value % b.value, a.unit);
|
|
},
|
|
pow: function (a, b) {
|
|
if ('number' == typeof a && 'number' == typeof b)
|
|
(a = new d(a)), (b = new d(b));
|
|
else if (!(a instanceof d && b instanceof d))
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'arguments must be numbers',
|
|
};
|
|
return new d(Math.pow(a.value, b.value), a.unit);
|
|
},
|
|
percentage: function (a) {
|
|
var b = g._math(
|
|
function (a) {
|
|
return 100 * a;
|
|
},
|
|
'%',
|
|
a,
|
|
);
|
|
return b;
|
|
},
|
|
});
|
|
},
|
|
{
|
|
'../tree/anonymous': 50,
|
|
'../tree/dimension': 62,
|
|
'./function-registry': 27,
|
|
'./math-helper.js': 30,
|
|
},
|
|
],
|
|
33: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/quoted'),
|
|
e = a('../tree/anonymous'),
|
|
f = a('../tree/javascript'),
|
|
g = a('./function-registry');
|
|
g.addMultiple({
|
|
e: function (a) {
|
|
return new e(a instanceof f ? a.evaluated : a.value);
|
|
},
|
|
escape: function (a) {
|
|
return new e(
|
|
encodeURI(a.value)
|
|
.replace(/=/g, '%3D')
|
|
.replace(/:/g, '%3A')
|
|
.replace(/#/g, '%23')
|
|
.replace(/;/g, '%3B')
|
|
.replace(/\(/g, '%28')
|
|
.replace(/\)/g, '%29'),
|
|
);
|
|
},
|
|
replace: function (a, b, c, e) {
|
|
var f = a.value;
|
|
return (
|
|
(c = 'Quoted' === c.type ? c.value : c.toCSS()),
|
|
(f = f.replace(new RegExp(b.value, e ? e.value : ''), c)),
|
|
new d(a.quote || '', f, a.escaped)
|
|
);
|
|
},
|
|
'%': function (a) {
|
|
for (
|
|
var b = Array.prototype.slice.call(arguments, 1),
|
|
c = a.value,
|
|
e = 0;
|
|
e < b.length;
|
|
e++
|
|
)
|
|
c = c.replace(/%[sda]/i, function (a) {
|
|
var c =
|
|
'Quoted' === b[e].type && a.match(/s/i)
|
|
? b[e].value
|
|
: b[e].toCSS();
|
|
return a.match(/[A-Z]$/) ? encodeURIComponent(c) : c;
|
|
});
|
|
return (
|
|
(c = c.replace(/%%/g, '%')), new d(a.quote || '', c, a.escaped)
|
|
);
|
|
},
|
|
});
|
|
},
|
|
{
|
|
'../tree/anonymous': 50,
|
|
'../tree/javascript': 68,
|
|
'../tree/quoted': 80,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
34: [
|
|
function (a, b, c) {
|
|
b.exports = function (b) {
|
|
var c = a('../tree/dimension'),
|
|
d = a('../tree/color'),
|
|
e = a('../tree/expression'),
|
|
f = a('../tree/quoted'),
|
|
g = a('../tree/url'),
|
|
h = a('./function-registry');
|
|
h.add('svg-gradient', function (a) {
|
|
function b() {
|
|
throw {
|
|
type: 'Argument',
|
|
message:
|
|
'svg-gradient expects direction, start_color [start_position], [color position,]..., end_color [end_position] or direction, color list',
|
|
};
|
|
}
|
|
var h,
|
|
i,
|
|
j,
|
|
k,
|
|
l,
|
|
m,
|
|
n,
|
|
o,
|
|
p = 'linear',
|
|
q = 'x="0" y="0" width="1" height="1"',
|
|
r = { compress: !1 },
|
|
s = a.toCSS(r);
|
|
switch (
|
|
(2 == arguments.length
|
|
? (arguments[1].value.length < 2 && b(),
|
|
(h = arguments[1].value))
|
|
: arguments.length < 3
|
|
? b()
|
|
: (h = Array.prototype.slice.call(arguments, 1)),
|
|
s)
|
|
) {
|
|
case 'to bottom':
|
|
i = 'x1="0%" y1="0%" x2="0%" y2="100%"';
|
|
break;
|
|
case 'to right':
|
|
i = 'x1="0%" y1="0%" x2="100%" y2="0%"';
|
|
break;
|
|
case 'to bottom right':
|
|
i = 'x1="0%" y1="0%" x2="100%" y2="100%"';
|
|
break;
|
|
case 'to top right':
|
|
i = 'x1="0%" y1="100%" x2="100%" y2="0%"';
|
|
break;
|
|
case 'ellipse':
|
|
case 'ellipse at center':
|
|
(p = 'radial'),
|
|
(i = 'cx="50%" cy="50%" r="75%"'),
|
|
(q = 'x="-50" y="-50" width="101" height="101"');
|
|
break;
|
|
default:
|
|
throw {
|
|
type: 'Argument',
|
|
message:
|
|
"svg-gradient direction must be 'to bottom', 'to right', 'to bottom right', 'to top right' or 'ellipse at center'",
|
|
};
|
|
}
|
|
for (
|
|
j =
|
|
'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"><' +
|
|
p +
|
|
'Gradient id="g" ' +
|
|
i +
|
|
'>',
|
|
k = 0;
|
|
k < h.length;
|
|
k += 1
|
|
)
|
|
h[k] instanceof e
|
|
? ((l = h[k].value[0]), (m = h[k].value[1]))
|
|
: ((l = h[k]), (m = void 0)),
|
|
(l instanceof d &&
|
|
(((0 === k || k + 1 === h.length) && void 0 === m) ||
|
|
m instanceof c)) ||
|
|
b(),
|
|
(n = m ? m.toCSS(r) : 0 === k ? '0%' : '100%'),
|
|
(o = l.alpha),
|
|
(j +=
|
|
'<stop offset="' +
|
|
n +
|
|
'" stop-color="' +
|
|
l.toRGB() +
|
|
'"' +
|
|
(o < 1 ? ' stop-opacity="' + o + '"' : '') +
|
|
'/>');
|
|
return (
|
|
(j +=
|
|
'</' +
|
|
p +
|
|
'Gradient><rect ' +
|
|
q +
|
|
' fill="url(#g)" /></svg>'),
|
|
(j = encodeURIComponent(j)),
|
|
(j = 'data:image/svg+xml,' + j),
|
|
new g(
|
|
new f("'" + j + "'", j, !1, this.index, this.currentFileInfo),
|
|
this.index,
|
|
this.currentFileInfo,
|
|
)
|
|
);
|
|
});
|
|
};
|
|
},
|
|
{
|
|
'../tree/color': 55,
|
|
'../tree/dimension': 62,
|
|
'../tree/expression': 64,
|
|
'../tree/quoted': 80,
|
|
'../tree/url': 85,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
35: [
|
|
function (a, b, c) {
|
|
var d = a('../tree/keyword'),
|
|
e = a('../tree/detached-ruleset'),
|
|
f = a('../tree/dimension'),
|
|
g = a('../tree/color'),
|
|
h = a('../tree/quoted'),
|
|
i = a('../tree/anonymous'),
|
|
j = a('../tree/url'),
|
|
k = a('../tree/operation'),
|
|
l = a('./function-registry'),
|
|
m = function (a, b) {
|
|
return a instanceof b ? d.True : d.False;
|
|
},
|
|
n = function (a, b) {
|
|
if (void 0 === b)
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'missing the required second argument to isunit.',
|
|
};
|
|
if (
|
|
((b = 'string' == typeof b.value ? b.value : b),
|
|
'string' != typeof b)
|
|
)
|
|
throw {
|
|
type: 'Argument',
|
|
message:
|
|
'Second argument to isunit should be a unit or a string.',
|
|
};
|
|
return a instanceof f && a.unit.is(b) ? d.True : d.False;
|
|
};
|
|
l.addMultiple({
|
|
isruleset: function (a) {
|
|
return m(a, e);
|
|
},
|
|
iscolor: function (a) {
|
|
return m(a, g);
|
|
},
|
|
isnumber: function (a) {
|
|
return m(a, f);
|
|
},
|
|
isstring: function (a) {
|
|
return m(a, h);
|
|
},
|
|
iskeyword: function (a) {
|
|
return m(a, d);
|
|
},
|
|
isurl: function (a) {
|
|
return m(a, j);
|
|
},
|
|
ispixel: function (a) {
|
|
return n(a, 'px');
|
|
},
|
|
ispercentage: function (a) {
|
|
return n(a, '%');
|
|
},
|
|
isem: function (a) {
|
|
return n(a, 'em');
|
|
},
|
|
isunit: n,
|
|
unit: function (a, b) {
|
|
if (!(a instanceof f))
|
|
throw {
|
|
type: 'Argument',
|
|
message:
|
|
'the first argument to unit must be a number' +
|
|
(a instanceof k ? '. Have you forgotten parenthesis?' : ''),
|
|
};
|
|
return (
|
|
(b = b ? (b instanceof d ? b.value : b.toCSS()) : ''),
|
|
new f(a.value, b)
|
|
);
|
|
},
|
|
'get-unit': function (a) {
|
|
return new i(a.unit);
|
|
},
|
|
});
|
|
},
|
|
{
|
|
'../tree/anonymous': 50,
|
|
'../tree/color': 55,
|
|
'../tree/detached-ruleset': 61,
|
|
'../tree/dimension': 62,
|
|
'../tree/keyword': 70,
|
|
'../tree/operation': 77,
|
|
'../tree/quoted': 80,
|
|
'../tree/url': 85,
|
|
'./function-registry': 27,
|
|
},
|
|
],
|
|
36: [
|
|
function (a, b, c) {
|
|
var d = a('./contexts'),
|
|
e = a('./parser/parser'),
|
|
f = a('./less-error'),
|
|
g = a('./utils'),
|
|
h =
|
|
('undefined' == typeof Promise ? a('promise') : Promise,
|
|
a('./logger'));
|
|
b.exports = function (a) {
|
|
var b = function (a, b, c) {
|
|
(this.less = a),
|
|
(this.rootFilename = c.filename),
|
|
(this.paths = b.paths || []),
|
|
(this.contents = {}),
|
|
(this.contentsIgnoredChars = {}),
|
|
(this.mime = b.mime),
|
|
(this.error = null),
|
|
(this.context = b),
|
|
(this.queue = []),
|
|
(this.files = {});
|
|
};
|
|
return (
|
|
(b.prototype.push = function (b, c, i, j, k) {
|
|
var l = this,
|
|
m = this.context.pluginManager.Loader;
|
|
this.queue.push(b);
|
|
var n = function (a, c, d) {
|
|
l.queue.splice(l.queue.indexOf(b), 1);
|
|
var e = d === l.rootFilename;
|
|
j.optional && a
|
|
? (k(null, { rules: [] }, !1, null),
|
|
h.info(
|
|
'The file ' +
|
|
d +
|
|
' was skipped because it was not found and the import was marked optional.',
|
|
))
|
|
: (l.files[d] ||
|
|
j.inline ||
|
|
(l.files[d] = { root: c, options: j }),
|
|
a && !l.error && (l.error = a),
|
|
k(a, c, e, d));
|
|
},
|
|
o = {
|
|
rewriteUrls: this.context.rewriteUrls,
|
|
entryPath: i.entryPath,
|
|
rootpath: i.rootpath,
|
|
rootFilename: i.rootFilename,
|
|
},
|
|
p = a.getFileManager(b, i.currentDirectory, this.context, a);
|
|
if (!p)
|
|
return void n({
|
|
message: 'Could not find a file-manager for ' + b,
|
|
});
|
|
var q,
|
|
r = function (a) {
|
|
var b,
|
|
c = a.filename,
|
|
g = a.contents.replace(/^\uFEFF/, '');
|
|
(o.currentDirectory = p.getPath(c)),
|
|
o.rewriteUrls &&
|
|
((o.rootpath = p.join(
|
|
l.context.rootpath || '',
|
|
p.pathDiff(o.currentDirectory, o.entryPath),
|
|
)),
|
|
!p.isPathAbsolute(o.rootpath) &&
|
|
p.alwaysMakePathsAbsolute() &&
|
|
(o.rootpath = p.join(o.entryPath, o.rootpath))),
|
|
(o.filename = c);
|
|
var h = new d.Parse(l.context);
|
|
(h.processImports = !1),
|
|
(l.contents[c] = g),
|
|
(i.reference || j.reference) && (o.reference = !0),
|
|
j.isPlugin
|
|
? ((b = m.evalPlugin(g, h, l, j.pluginArgs, o)),
|
|
b instanceof f ? n(b, null, c) : n(null, b, c))
|
|
: j.inline
|
|
? n(null, g, c)
|
|
: !l.files[c] ||
|
|
l.files[c].options.multiple ||
|
|
j.multiple
|
|
? new e(h, l, o).parse(g, function (a, b) {
|
|
n(a, b, c);
|
|
})
|
|
: n(null, l.files[c].root, c);
|
|
},
|
|
s = g.clone(this.context);
|
|
c && (s.ext = j.isPlugin ? '.js' : '.less'),
|
|
(q = j.isPlugin
|
|
? m.loadPlugin(b, i.currentDirectory, s, a, p)
|
|
: p.loadFile(b, i.currentDirectory, s, a, function (a, b) {
|
|
a ? n(a) : r(b);
|
|
})),
|
|
q && q.then(r, n);
|
|
}),
|
|
b
|
|
);
|
|
};
|
|
},
|
|
{
|
|
'./contexts': 13,
|
|
'./less-error': 38,
|
|
'./logger': 39,
|
|
'./parser/parser': 44,
|
|
'./utils': 89,
|
|
promise: void 0,
|
|
},
|
|
],
|
|
37: [
|
|
function (a, b, c) {
|
|
b.exports = function (b, c) {
|
|
var d,
|
|
e,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
j = {
|
|
version: [3, 8, 1],
|
|
data: a('./data'),
|
|
tree: a('./tree'),
|
|
Environment: (h = a('./environment/environment')),
|
|
AbstractFileManager: a('./environment/abstract-file-manager'),
|
|
AbstractPluginLoader: a('./environment/abstract-plugin-loader'),
|
|
environment: (b = new h(b, c)),
|
|
visitors: a('./visitors'),
|
|
Parser: a('./parser/parser'),
|
|
functions: a('./functions')(b),
|
|
contexts: a('./contexts'),
|
|
SourceMapOutput: (d = a('./source-map-output')(b)),
|
|
SourceMapBuilder: (e = a('./source-map-builder')(d, b)),
|
|
ParseTree: (f = a('./parse-tree')(e)),
|
|
ImportManager: (g = a('./import-manager')(b)),
|
|
render: a('./render')(b, f, g),
|
|
parse: a('./parse')(b, f, g),
|
|
LessError: a('./less-error'),
|
|
transformTree: a('./transform-tree'),
|
|
utils: a('./utils'),
|
|
PluginManager: a('./plugin-manager'),
|
|
logger: a('./logger'),
|
|
},
|
|
k = function (a) {
|
|
return function () {
|
|
var b = Object.create(a.prototype);
|
|
return (
|
|
a.apply(b, Array.prototype.slice.call(arguments, 0)), b
|
|
);
|
|
};
|
|
},
|
|
l = Object.create(j);
|
|
for (var m in j.tree)
|
|
if (((i = j.tree[m]), 'function' == typeof i))
|
|
l[m.toLowerCase()] = k(i);
|
|
else {
|
|
l[m] = Object.create(null);
|
|
for (var n in i) l[m][n.toLowerCase()] = k(i[n]);
|
|
}
|
|
return l;
|
|
};
|
|
},
|
|
{
|
|
'./contexts': 13,
|
|
'./data': 15,
|
|
'./environment/abstract-file-manager': 18,
|
|
'./environment/abstract-plugin-loader': 19,
|
|
'./environment/environment': 20,
|
|
'./functions': 28,
|
|
'./import-manager': 36,
|
|
'./less-error': 38,
|
|
'./logger': 39,
|
|
'./parse': 41,
|
|
'./parse-tree': 40,
|
|
'./parser/parser': 44,
|
|
'./plugin-manager': 45,
|
|
'./render': 46,
|
|
'./source-map-builder': 47,
|
|
'./source-map-output': 48,
|
|
'./transform-tree': 49,
|
|
'./tree': 67,
|
|
'./utils': 89,
|
|
'./visitors': 93,
|
|
},
|
|
],
|
|
38: [
|
|
function (a, b, c) {
|
|
var d = a('./utils'),
|
|
e = (b.exports = function (a, b, c) {
|
|
Error.call(this);
|
|
var e = a.filename || c;
|
|
if (
|
|
((this.message = a.message), (this.stack = a.stack), b && e)
|
|
) {
|
|
var f = b.contents[e],
|
|
g = d.getLocation(a.index, f),
|
|
h = g.line,
|
|
i = g.column,
|
|
j = a.call && d.getLocation(a.call, f).line,
|
|
k = f ? f.split('\n') : '';
|
|
if (
|
|
((this.type = a.type || 'Syntax'),
|
|
(this.filename = e),
|
|
(this.index = a.index),
|
|
(this.line = 'number' == typeof h ? h + 1 : null),
|
|
(this.column = i),
|
|
!this.line && this.stack)
|
|
) {
|
|
var l = this.stack.match(
|
|
/(<anonymous>|Function):(\d+):(\d+)/,
|
|
);
|
|
l &&
|
|
(l[2] && (this.line = parseInt(l[2]) - 2),
|
|
l[3] && (this.column = parseInt(l[3])));
|
|
}
|
|
(this.callLine = j + 1),
|
|
(this.callExtract = k[j]),
|
|
(this.extract = [
|
|
k[this.line - 2],
|
|
k[this.line - 1],
|
|
k[this.line],
|
|
]);
|
|
}
|
|
});
|
|
if ('undefined' == typeof Object.create) {
|
|
var f = function () {};
|
|
(f.prototype = Error.prototype), (e.prototype = new f());
|
|
} else e.prototype = Object.create(Error.prototype);
|
|
(e.prototype.constructor = e),
|
|
(e.prototype.toString = function (a) {
|
|
a = a || {};
|
|
var b = '',
|
|
c = this.extract || [],
|
|
d = [],
|
|
e = function (a) {
|
|
return a;
|
|
};
|
|
if (a.stylize) {
|
|
var f = typeof a.stylize;
|
|
if ('function' !== f)
|
|
throw Error(
|
|
'options.stylize should be a function, got a ' + f + '!',
|
|
);
|
|
e = a.stylize;
|
|
}
|
|
if (null !== this.line) {
|
|
if (
|
|
('string' == typeof c[0] &&
|
|
d.push(e(this.line - 1 + ' ' + c[0], 'grey')),
|
|
'string' == typeof c[1])
|
|
) {
|
|
var g = this.line + ' ';
|
|
c[1] &&
|
|
(g +=
|
|
c[1].slice(0, this.column) +
|
|
e(
|
|
e(
|
|
e(c[1].substr(this.column, 1), 'bold') +
|
|
c[1].slice(this.column + 1),
|
|
'red',
|
|
),
|
|
'inverse',
|
|
)),
|
|
d.push(g);
|
|
}
|
|
'string' == typeof c[2] &&
|
|
d.push(e(this.line + 1 + ' ' + c[2], 'grey')),
|
|
(d = d.join('\n') + e('', 'reset') + '\n');
|
|
}
|
|
return (
|
|
(b += e(this.type + 'Error: ' + this.message, 'red')),
|
|
this.filename && (b += e(' in ', 'red') + this.filename),
|
|
this.line &&
|
|
(b += e(
|
|
' on line ' +
|
|
this.line +
|
|
', column ' +
|
|
(this.column + 1) +
|
|
':',
|
|
'grey',
|
|
)),
|
|
(b += '\n' + d),
|
|
this.callLine &&
|
|
((b += e('from ', 'red') + (this.filename || '') + '/n'),
|
|
(b +=
|
|
e(this.callLine, 'grey') + ' ' + this.callExtract + '/n')),
|
|
b
|
|
);
|
|
});
|
|
},
|
|
{ './utils': 89 },
|
|
],
|
|
39: [
|
|
function (a, b, c) {
|
|
b.exports = {
|
|
error: function (a) {
|
|
this._fireEvent('error', a);
|
|
},
|
|
warn: function (a) {
|
|
this._fireEvent('warn', a);
|
|
},
|
|
info: function (a) {
|
|
this._fireEvent('info', a);
|
|
},
|
|
debug: function (a) {
|
|
this._fireEvent('debug', a);
|
|
},
|
|
addListener: function (a) {
|
|
this._listeners.push(a);
|
|
},
|
|
removeListener: function (a) {
|
|
for (var b = 0; b < this._listeners.length; b++)
|
|
if (this._listeners[b] === a)
|
|
return void this._listeners.splice(b, 1);
|
|
},
|
|
_fireEvent: function (a, b) {
|
|
for (var c = 0; c < this._listeners.length; c++) {
|
|
var d = this._listeners[c][a];
|
|
d && d(b);
|
|
}
|
|
},
|
|
_listeners: [],
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
40: [
|
|
function (a, b, c) {
|
|
var d = a('./less-error'),
|
|
e = a('./transform-tree'),
|
|
f = a('./logger');
|
|
b.exports = function (a) {
|
|
var b = function (a, b) {
|
|
(this.root = a), (this.imports = b);
|
|
};
|
|
return (
|
|
(b.prototype.toCSS = function (b) {
|
|
var c,
|
|
g,
|
|
h = {};
|
|
try {
|
|
c = e(this.root, b);
|
|
} catch (i) {
|
|
throw new d(i, this.imports);
|
|
}
|
|
try {
|
|
var j = Boolean(b.compress);
|
|
j &&
|
|
f.warn(
|
|
'The compress option has been deprecated. We recommend you use a dedicated css minifier, for instance see less-plugin-clean-css.',
|
|
);
|
|
var k = {
|
|
compress: j,
|
|
dumpLineNumbers: b.dumpLineNumbers,
|
|
strictUnits: Boolean(b.strictUnits),
|
|
numPrecision: 8,
|
|
};
|
|
b.sourceMap
|
|
? ((g = new a(b.sourceMap)),
|
|
(h.css = g.toCSS(c, k, this.imports)))
|
|
: (h.css = c.toCSS(k));
|
|
} catch (i) {
|
|
throw new d(i, this.imports);
|
|
}
|
|
if (b.pluginManager)
|
|
for (
|
|
var l = b.pluginManager.getPostProcessors(), m = 0;
|
|
m < l.length;
|
|
m++
|
|
)
|
|
h.css = l[m].process(h.css, {
|
|
sourceMap: g,
|
|
options: b,
|
|
imports: this.imports,
|
|
});
|
|
b.sourceMap && (h.map = g.getExternalSourceMap()),
|
|
(h.imports = []);
|
|
for (var n in this.imports.files)
|
|
this.imports.files.hasOwnProperty(n) &&
|
|
n !== this.imports.rootFilename &&
|
|
h.imports.push(n);
|
|
return h;
|
|
}),
|
|
b
|
|
);
|
|
};
|
|
},
|
|
{ './less-error': 38, './logger': 39, './transform-tree': 49 },
|
|
],
|
|
41: [
|
|
function (a, b, c) {
|
|
var d,
|
|
e = a('./contexts'),
|
|
f = a('./parser/parser'),
|
|
g = a('./plugin-manager'),
|
|
h = a('./less-error'),
|
|
i = a('./utils');
|
|
b.exports = function (b, c, j) {
|
|
var k = function (b, c, l) {
|
|
if (
|
|
('function' == typeof c
|
|
? ((l = c), (c = i.copyOptions(this.options, {})))
|
|
: (c = i.copyOptions(this.options, c || {})),
|
|
!l)
|
|
) {
|
|
d ||
|
|
(d = 'undefined' == typeof Promise ? a('promise') : Promise);
|
|
var m = this;
|
|
return new d(function (a, d) {
|
|
k.call(m, b, c, function (b, c) {
|
|
b ? d(b) : a(c);
|
|
});
|
|
});
|
|
}
|
|
var n,
|
|
o,
|
|
p = new g(this, !c.reUsePluginManager);
|
|
if (((c.pluginManager = p), (n = new e.Parse(c)), c.rootFileInfo))
|
|
o = c.rootFileInfo;
|
|
else {
|
|
var q = c.filename || 'input',
|
|
r = q.replace(/[^\/\\]*$/, '');
|
|
(o = {
|
|
filename: q,
|
|
rewriteUrls: n.rewriteUrls,
|
|
rootpath: n.rootpath || '',
|
|
currentDirectory: r,
|
|
entryPath: r,
|
|
rootFilename: q,
|
|
}),
|
|
o.rootpath &&
|
|
'/' !== o.rootpath.slice(-1) &&
|
|
(o.rootpath += '/');
|
|
}
|
|
var s = new j(this, n, o);
|
|
(this.importManager = s),
|
|
c.plugins &&
|
|
c.plugins.forEach(function (a) {
|
|
var b, c;
|
|
if (a.fileContent) {
|
|
if (
|
|
((c = a.fileContent.replace(/^\uFEFF/, '')),
|
|
(b = p.Loader.evalPlugin(
|
|
c,
|
|
n,
|
|
s,
|
|
a.options,
|
|
a.filename,
|
|
)),
|
|
b instanceof h)
|
|
)
|
|
return l(b);
|
|
} else p.addPlugin(a);
|
|
}),
|
|
new f(n, s, o).parse(
|
|
b,
|
|
function (a, b) {
|
|
return a ? l(a) : void l(null, b, s, c);
|
|
},
|
|
c,
|
|
);
|
|
};
|
|
return k;
|
|
};
|
|
},
|
|
{
|
|
'./contexts': 13,
|
|
'./less-error': 38,
|
|
'./parser/parser': 44,
|
|
'./plugin-manager': 45,
|
|
'./utils': 89,
|
|
promise: void 0,
|
|
},
|
|
],
|
|
42: [
|
|
function (a, b, c) {
|
|
b.exports = function (a, b) {
|
|
function c(b) {
|
|
var c = h - q;
|
|
(c < 512 && !b) || !c || (p.push(a.slice(q, h + 1)), (q = h + 1));
|
|
}
|
|
var d,
|
|
e,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
j,
|
|
k,
|
|
l,
|
|
m = a.length,
|
|
n = 0,
|
|
o = 0,
|
|
p = [],
|
|
q = 0;
|
|
for (h = 0; h < m; h++)
|
|
if (((j = a.charCodeAt(h)), !((j >= 97 && j <= 122) || j < 34)))
|
|
switch (j) {
|
|
case 40:
|
|
o++, (e = h);
|
|
continue;
|
|
case 41:
|
|
if (--o < 0) return b('missing opening `(`', h);
|
|
continue;
|
|
case 59:
|
|
o || c();
|
|
continue;
|
|
case 123:
|
|
n++, (d = h);
|
|
continue;
|
|
case 125:
|
|
if (--n < 0) return b('missing opening `{`', h);
|
|
n || o || c();
|
|
continue;
|
|
case 92:
|
|
if (h < m - 1) {
|
|
h++;
|
|
continue;
|
|
}
|
|
return b('unescaped `\\`', h);
|
|
case 34:
|
|
case 39:
|
|
case 96:
|
|
for (l = 0, i = h, h += 1; h < m; h++)
|
|
if (((k = a.charCodeAt(h)), !(k > 96))) {
|
|
if (k == j) {
|
|
l = 1;
|
|
break;
|
|
}
|
|
if (92 == k) {
|
|
if (h == m - 1) return b('unescaped `\\`', h);
|
|
h++;
|
|
}
|
|
}
|
|
if (l) continue;
|
|
return b('unmatched `' + String.fromCharCode(j) + '`', i);
|
|
case 47:
|
|
if (o || h == m - 1) continue;
|
|
if (((k = a.charCodeAt(h + 1)), 47 == k))
|
|
for (
|
|
h += 2;
|
|
h < m &&
|
|
((k = a.charCodeAt(h)),
|
|
!(k <= 13) || (10 != k && 13 != k));
|
|
h++
|
|
);
|
|
else if (42 == k) {
|
|
for (
|
|
f = i = h, h += 2;
|
|
h < m - 1 &&
|
|
((k = a.charCodeAt(h)),
|
|
125 == k && (g = h),
|
|
42 != k || 47 != a.charCodeAt(h + 1));
|
|
h++
|
|
);
|
|
if (h == m - 1) return b('missing closing `*/`', i);
|
|
h++;
|
|
}
|
|
continue;
|
|
case 42:
|
|
if (h < m - 1 && 47 == a.charCodeAt(h + 1))
|
|
return b('unmatched `/*`', h);
|
|
continue;
|
|
}
|
|
return 0 !== n
|
|
? f > d && g > f
|
|
? b('missing closing `}` or `*/`', d)
|
|
: b('missing closing `}`', d)
|
|
: 0 !== o
|
|
? b('missing closing `)`', e)
|
|
: (c(!0), p);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
43: [
|
|
function (a, b, c) {
|
|
var d = a('./chunker');
|
|
b.exports = function () {
|
|
function a(d) {
|
|
for (
|
|
var e,
|
|
f,
|
|
j,
|
|
p = k.i,
|
|
q = c,
|
|
s = k.i - i,
|
|
t = k.i + h.length - s,
|
|
u = (k.i += d),
|
|
v = b;
|
|
k.i < t;
|
|
k.i++
|
|
) {
|
|
if (((e = v.charCodeAt(k.i)), k.autoCommentAbsorb && e === r)) {
|
|
if (((f = v.charAt(k.i + 1)), '/' === f)) {
|
|
j = { index: k.i, isLineComment: !0 };
|
|
var w = v.indexOf('\n', k.i + 2);
|
|
w < 0 && (w = t),
|
|
(k.i = w),
|
|
(j.text = v.substr(j.index, k.i - j.index)),
|
|
k.commentStore.push(j);
|
|
continue;
|
|
}
|
|
if ('*' === f) {
|
|
var x = v.indexOf('*/', k.i + 2);
|
|
if (x >= 0) {
|
|
(j = {
|
|
index: k.i,
|
|
text: v.substr(k.i, x + 2 - k.i),
|
|
isLineComment: !1,
|
|
}),
|
|
(k.i += j.text.length - 1),
|
|
k.commentStore.push(j);
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (e !== l && e !== n && e !== m && e !== o) break;
|
|
}
|
|
if (((h = h.slice(d + k.i - u + s)), (i = k.i), !h.length)) {
|
|
if (c < g.length - 1) return (h = g[++c]), a(0), !0;
|
|
k.finished = !0;
|
|
}
|
|
return p !== k.i || q !== c;
|
|
}
|
|
var b,
|
|
c,
|
|
e,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
j = [],
|
|
k = {},
|
|
l = 32,
|
|
m = 9,
|
|
n = 10,
|
|
o = 13,
|
|
p = 43,
|
|
q = 44,
|
|
r = 47,
|
|
s = 57;
|
|
return (
|
|
(k.save = function () {
|
|
(i = k.i), j.push({ current: h, i: k.i, j: c });
|
|
}),
|
|
(k.restore = function (a) {
|
|
(k.i > e || (k.i === e && a && !f)) && ((e = k.i), (f = a));
|
|
var b = j.pop();
|
|
(h = b.current), (i = k.i = b.i), (c = b.j);
|
|
}),
|
|
(k.forget = function () {
|
|
j.pop();
|
|
}),
|
|
(k.isWhitespace = function (a) {
|
|
var c = k.i + (a || 0),
|
|
d = b.charCodeAt(c);
|
|
return d === l || d === o || d === m || d === n;
|
|
}),
|
|
(k.$re = function (b) {
|
|
k.i > i && ((h = h.slice(k.i - i)), (i = k.i));
|
|
var c = b.exec(h);
|
|
return c
|
|
? (a(c[0].length),
|
|
'string' == typeof c ? c : 1 === c.length ? c[0] : c)
|
|
: null;
|
|
}),
|
|
(k.$char = function (c) {
|
|
return b.charAt(k.i) !== c ? null : (a(1), c);
|
|
}),
|
|
(k.$str = function (c) {
|
|
for (var d = c.length, e = 0; e < d; e++)
|
|
if (b.charAt(k.i + e) !== c.charAt(e)) return null;
|
|
return a(d), c;
|
|
}),
|
|
(k.$quoted = function (c) {
|
|
var d = c || k.i,
|
|
e = b.charAt(d);
|
|
if ("'" === e || '"' === e) {
|
|
for (var f = b.length, g = d, h = 1; h + g < f; h++) {
|
|
var i = b.charAt(h + g);
|
|
switch (i) {
|
|
case '\\':
|
|
h++;
|
|
continue;
|
|
case '\r':
|
|
case '\n':
|
|
break;
|
|
case e:
|
|
var j = b.substr(g, h + 1);
|
|
return c || 0 === c ? [e, j] : (a(h + 1), j);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}),
|
|
(k.$parseUntil = function (c) {
|
|
var d,
|
|
e = '',
|
|
f = null,
|
|
g = !1,
|
|
h = 0,
|
|
i = [],
|
|
j = [],
|
|
l = b.length,
|
|
m = k.i,
|
|
n = k.i,
|
|
o = k.i,
|
|
p = !0;
|
|
d =
|
|
'string' == typeof c
|
|
? function (a) {
|
|
return a === c;
|
|
}
|
|
: function (a) {
|
|
return c.test(a);
|
|
};
|
|
do {
|
|
var q,
|
|
r = b.charAt(o);
|
|
if (0 === h && d(r))
|
|
(f = b.substr(n, o - n)),
|
|
j.push(f ? f : ' '),
|
|
(f = j),
|
|
a(o - m),
|
|
(p = !1);
|
|
else {
|
|
if (g) {
|
|
'*' === r &&
|
|
'/' === b.charAt(o + 1) &&
|
|
(o++, h--, (g = !1)),
|
|
o++;
|
|
continue;
|
|
}
|
|
switch (r) {
|
|
case '\\':
|
|
o++,
|
|
(r = b.charAt(o)),
|
|
j.push(b.substr(n, o - n + 1)),
|
|
(n = o + 1);
|
|
break;
|
|
case '/':
|
|
'*' === b.charAt(o + 1) && (o++, (g = !0), h++);
|
|
break;
|
|
case "'":
|
|
case '"':
|
|
(e = k.$quoted(o)),
|
|
e
|
|
? (j.push(b.substr(n, o - n), e),
|
|
(o += e[1].length - 1),
|
|
(n = o + 1))
|
|
: (a(o - m), (f = r), (p = !1));
|
|
break;
|
|
case '{':
|
|
i.push('}'), h++;
|
|
break;
|
|
case '(':
|
|
i.push(')'), h++;
|
|
break;
|
|
case '[':
|
|
i.push(']'), h++;
|
|
break;
|
|
case '}':
|
|
case ')':
|
|
case ']':
|
|
var s = i.pop();
|
|
r === s ? h-- : (a(o - m), (f = s), (p = !1));
|
|
}
|
|
o++, o > l && (p = !1);
|
|
}
|
|
q = r;
|
|
} while (p);
|
|
return f ? f : null;
|
|
}),
|
|
(k.autoCommentAbsorb = !0),
|
|
(k.commentStore = []),
|
|
(k.finished = !1),
|
|
(k.peek = function (a) {
|
|
if ('string' == typeof a) {
|
|
for (var c = 0; c < a.length; c++)
|
|
if (b.charAt(k.i + c) !== a.charAt(c)) return !1;
|
|
return !0;
|
|
}
|
|
return a.test(h);
|
|
}),
|
|
(k.peekChar = function (a) {
|
|
return b.charAt(k.i) === a;
|
|
}),
|
|
(k.currentChar = function () {
|
|
return b.charAt(k.i);
|
|
}),
|
|
(k.prevChar = function () {
|
|
return b.charAt(k.i - 1);
|
|
}),
|
|
(k.getInput = function () {
|
|
return b;
|
|
}),
|
|
(k.peekNotNumeric = function () {
|
|
var a = b.charCodeAt(k.i);
|
|
return a > s || a < p || a === r || a === q;
|
|
}),
|
|
(k.start = function (f, j, l) {
|
|
(b = f),
|
|
(k.i = c = i = e = 0),
|
|
(g = j ? d(f, l) : [f]),
|
|
(h = g[0]),
|
|
a(0);
|
|
}),
|
|
(k.end = function () {
|
|
var a,
|
|
c = k.i >= b.length;
|
|
return (
|
|
k.i < e && ((a = f), (k.i = e)),
|
|
{
|
|
isFinished: c,
|
|
furthest: k.i,
|
|
furthestPossibleErrorMessage: a,
|
|
furthestReachedEnd: k.i >= b.length - 1,
|
|
furthestChar: b[k.i],
|
|
}
|
|
);
|
|
}),
|
|
k
|
|
);
|
|
};
|
|
},
|
|
{ './chunker': 42 },
|
|
],
|
|
44: [
|
|
function (a, b, c) {
|
|
var d = a('../less-error'),
|
|
e = a('../tree'),
|
|
f = a('../visitors'),
|
|
g = a('./parser-input'),
|
|
h = a('../utils'),
|
|
i = a('../functions/function-registry'),
|
|
j = function k(a, b, c) {
|
|
function j(a, e) {
|
|
throw new d(
|
|
{
|
|
index: q.i,
|
|
filename: c.filename,
|
|
type: e || 'Syntax',
|
|
message: a,
|
|
},
|
|
b,
|
|
);
|
|
}
|
|
function l(a, b) {
|
|
var c = a instanceof Function ? a.call(p) : q.$re(a);
|
|
return c
|
|
? c
|
|
: void j(
|
|
b ||
|
|
('string' == typeof a
|
|
? "expected '" + a + "' got '" + q.currentChar() + "'"
|
|
: 'unexpected token'),
|
|
);
|
|
}
|
|
function m(a, b) {
|
|
return q.$char(a)
|
|
? a
|
|
: void j(
|
|
b || "expected '" + a + "' got '" + q.currentChar() + "'",
|
|
);
|
|
}
|
|
function n(a) {
|
|
var b = c.filename;
|
|
return {
|
|
lineNumber: h.getLocation(a, q.getInput()).line + 1,
|
|
fileName: b,
|
|
};
|
|
}
|
|
function o(a, c, e, f, g) {
|
|
var h,
|
|
i = [],
|
|
j = q;
|
|
try {
|
|
j.start(a, !1, function (a, b) {
|
|
g({ message: a, index: b + e });
|
|
});
|
|
for (var k, l, m = 0; (k = c[m]); m++)
|
|
(l = j.i),
|
|
(h = p[k]()),
|
|
h
|
|
? ((h._index = l + e), (h._fileInfo = f), i.push(h))
|
|
: i.push(null);
|
|
var n = j.end();
|
|
n.isFinished ? g(null, i) : g(!0, null);
|
|
} catch (o) {
|
|
throw new d(
|
|
{ index: o.index + e, message: o.message },
|
|
b,
|
|
f.filename,
|
|
);
|
|
}
|
|
}
|
|
var p,
|
|
q = g();
|
|
return {
|
|
parserInput: q,
|
|
imports: b,
|
|
fileInfo: c,
|
|
parseNode: o,
|
|
parse: function (g, h, j) {
|
|
var l,
|
|
m,
|
|
n,
|
|
o,
|
|
p = null,
|
|
r = '';
|
|
if (
|
|
((m =
|
|
j && j.globalVars
|
|
? k.serializeVars(j.globalVars) + '\n'
|
|
: ''),
|
|
(n =
|
|
j && j.modifyVars
|
|
? '\n' + k.serializeVars(j.modifyVars)
|
|
: ''),
|
|
a.pluginManager)
|
|
)
|
|
for (
|
|
var s = a.pluginManager.getPreProcessors(), t = 0;
|
|
t < s.length;
|
|
t++
|
|
)
|
|
g = s[t].process(g, {
|
|
context: a,
|
|
imports: b,
|
|
fileInfo: c,
|
|
});
|
|
(m || (j && j.banner)) &&
|
|
((r = (j && j.banner ? j.banner : '') + m),
|
|
(o = b.contentsIgnoredChars),
|
|
(o[c.filename] = o[c.filename] || 0),
|
|
(o[c.filename] += r.length)),
|
|
(g = g.replace(/\r\n?/g, '\n')),
|
|
(g = r + g.replace(/^\uFEFF/, '') + n),
|
|
(b.contents[c.filename] = g);
|
|
try {
|
|
q.start(g, a.chunkInput, function (a, e) {
|
|
throw new d(
|
|
{
|
|
index: e,
|
|
type: 'Parse',
|
|
message: a,
|
|
filename: c.filename,
|
|
},
|
|
b,
|
|
);
|
|
}),
|
|
(e.Node.prototype.parse = this),
|
|
(l = new e.Ruleset(null, this.parsers.primary())),
|
|
(e.Node.prototype.rootNode = l),
|
|
(l.root = !0),
|
|
(l.firstRoot = !0),
|
|
(l.functionRegistry = i.inherit());
|
|
} catch (u) {
|
|
return h(new d(u, b, c.filename));
|
|
}
|
|
var v = q.end();
|
|
if (!v.isFinished) {
|
|
var w = v.furthestPossibleErrorMessage;
|
|
w ||
|
|
((w = 'Unrecognised input'),
|
|
'}' === v.furthestChar
|
|
? (w += ". Possibly missing opening '{'")
|
|
: ')' === v.furthestChar
|
|
? (w += ". Possibly missing opening '('")
|
|
: v.furthestReachedEnd &&
|
|
(w += '. Possibly missing something')),
|
|
(p = new d(
|
|
{
|
|
type: 'Parse',
|
|
message: w,
|
|
index: v.furthest,
|
|
filename: c.filename,
|
|
},
|
|
b,
|
|
));
|
|
}
|
|
var x = function (a) {
|
|
return (
|
|
(a = p || a || b.error),
|
|
a
|
|
? (a instanceof d || (a = new d(a, b, c.filename)),
|
|
h(a))
|
|
: h(null, l)
|
|
);
|
|
};
|
|
return a.processImports === !1
|
|
? x()
|
|
: void new f.ImportVisitor(b, x).run(l);
|
|
},
|
|
parsers: (p = {
|
|
primary: function () {
|
|
for (var a, b = this.mixin, c = []; ; ) {
|
|
for (;;) {
|
|
if (((a = this.comment()), !a)) break;
|
|
c.push(a);
|
|
}
|
|
if (q.finished) break;
|
|
if (q.peek('}')) break;
|
|
if ((a = this.extendRule())) c = c.concat(a);
|
|
else if (
|
|
(a =
|
|
b.definition() ||
|
|
this.declaration() ||
|
|
this.ruleset() ||
|
|
b.call(!1, !1) ||
|
|
this.variableCall() ||
|
|
this.entities.call() ||
|
|
this.atrule())
|
|
)
|
|
c.push(a);
|
|
else {
|
|
for (var d = !1; q.$char(';'); ) d = !0;
|
|
if (!d) break;
|
|
}
|
|
}
|
|
return c;
|
|
},
|
|
comment: function () {
|
|
if (q.commentStore.length) {
|
|
var a = q.commentStore.shift();
|
|
return new e.Comment(a.text, a.isLineComment, a.index, c);
|
|
}
|
|
},
|
|
entities: {
|
|
mixinLookup: function () {
|
|
return p.mixin.call(!0, !0);
|
|
},
|
|
quoted: function (a) {
|
|
var b,
|
|
d = q.i,
|
|
f = !1;
|
|
if ((q.save(), q.$char('~'))) f = !0;
|
|
else if (a) return void q.restore();
|
|
return (b = q.$quoted())
|
|
? (q.forget(),
|
|
new e.Quoted(
|
|
b.charAt(0),
|
|
b.substr(1, b.length - 2),
|
|
f,
|
|
d,
|
|
c,
|
|
))
|
|
: void q.restore();
|
|
},
|
|
keyword: function () {
|
|
var a =
|
|
q.$char('%') ||
|
|
q.$re(
|
|
/^\[?(?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+\]?/,
|
|
);
|
|
if (a) return e.Color.fromKeyword(a) || new e.Keyword(a);
|
|
},
|
|
call: function () {
|
|
var a,
|
|
b,
|
|
d,
|
|
f = q.i;
|
|
if (!q.peek(/^url\(/i))
|
|
return (
|
|
q.save(),
|
|
(a = q.$re(/^([\w-]+|%|progid:[\w\.]+)\(/))
|
|
? ((a = a[1]),
|
|
(d = this.customFuncCall(a)),
|
|
d && ((b = d.parse()), b && d.stop)
|
|
? (q.forget(), b)
|
|
: ((b = this.arguments(b)),
|
|
q.$char(')')
|
|
? (q.forget(), new e.Call(a, b, f, c))
|
|
: void q.restore(
|
|
"Could not parse call arguments or missing ')'",
|
|
)))
|
|
: void q.forget()
|
|
);
|
|
},
|
|
customFuncCall: function (a) {
|
|
function b(a, b) {
|
|
return { parse: a, stop: b };
|
|
}
|
|
function c() {
|
|
return [l(p.condition, 'expected condition')];
|
|
}
|
|
return {
|
|
alpha: b(p.ieAlpha, !0),
|
|
boolean: b(c),
|
|
if: b(c),
|
|
}[a.toLowerCase()];
|
|
},
|
|
arguments: function (a) {
|
|
var b,
|
|
c,
|
|
d = a || [],
|
|
f = [];
|
|
for (q.save(); ; ) {
|
|
if (a) a = !1;
|
|
else {
|
|
if (
|
|
((c =
|
|
p.detachedRuleset() ||
|
|
this.assignment() ||
|
|
p.expression()),
|
|
!c)
|
|
)
|
|
break;
|
|
c.value && 1 == c.value.length && (c = c.value[0]),
|
|
d.push(c);
|
|
}
|
|
q.$char(',') ||
|
|
((q.$char(';') || b) &&
|
|
((b = !0),
|
|
(c = d.length < 1 ? d[0] : new e.Value(d)),
|
|
f.push(c),
|
|
(d = [])));
|
|
}
|
|
return q.forget(), b ? f : d;
|
|
},
|
|
literal: function () {
|
|
return (
|
|
this.dimension() ||
|
|
this.color() ||
|
|
this.quoted() ||
|
|
this.unicodeDescriptor()
|
|
);
|
|
},
|
|
assignment: function () {
|
|
var a, b;
|
|
return (
|
|
q.save(),
|
|
(a = q.$re(/^\w+(?=\s?=)/i)) &&
|
|
q.$char('=') &&
|
|
(b = p.entity())
|
|
? (q.forget(), new e.Assignment(a, b))
|
|
: void q.restore()
|
|
);
|
|
},
|
|
url: function () {
|
|
var a,
|
|
b = q.i;
|
|
return (
|
|
(q.autoCommentAbsorb = !1),
|
|
q.$str('url(')
|
|
? ((a =
|
|
this.quoted() ||
|
|
this.variable() ||
|
|
this.property() ||
|
|
q.$re(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) ||
|
|
''),
|
|
(q.autoCommentAbsorb = !0),
|
|
m(')'),
|
|
new e.URL(
|
|
null != a.value ||
|
|
a instanceof e.Variable ||
|
|
a instanceof e.Property
|
|
? a
|
|
: new e.Anonymous(a, b),
|
|
b,
|
|
c,
|
|
))
|
|
: void (q.autoCommentAbsorb = !0)
|
|
);
|
|
},
|
|
variable: function () {
|
|
var a,
|
|
b,
|
|
d = q.i;
|
|
if (
|
|
(q.save(),
|
|
'@' === q.currentChar() && (b = q.$re(/^@@?[\w-]+/)))
|
|
) {
|
|
if (
|
|
((a = q.currentChar()),
|
|
'(' === a ||
|
|
('[' === a && !q.prevChar().match(/^\s/)))
|
|
) {
|
|
var f = p.variableCall(b);
|
|
if (f) return q.forget(), f;
|
|
}
|
|
return q.forget(), new e.Variable(b, d, c);
|
|
}
|
|
q.restore();
|
|
},
|
|
variableCurly: function () {
|
|
var a,
|
|
b = q.i;
|
|
if (
|
|
'@' === q.currentChar() &&
|
|
(a = q.$re(/^@\{([\w-]+)\}/))
|
|
)
|
|
return new e.Variable('@' + a[1], b, c);
|
|
},
|
|
property: function () {
|
|
var a,
|
|
b = q.i;
|
|
if ('$' === q.currentChar() && (a = q.$re(/^\$[\w-]+/)))
|
|
return new e.Property(a, b, c);
|
|
},
|
|
propertyCurly: function () {
|
|
var a,
|
|
b = q.i;
|
|
if (
|
|
'$' === q.currentChar() &&
|
|
(a = q.$re(/^\$\{([\w-]+)\}/))
|
|
)
|
|
return new e.Property('$' + a[1], b, c);
|
|
},
|
|
color: function () {
|
|
var a;
|
|
if (
|
|
'#' === q.currentChar() &&
|
|
(a = q.$re(
|
|
/^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})/,
|
|
))
|
|
)
|
|
return new e.Color(a[1], void 0, a[0]);
|
|
},
|
|
colorKeyword: function () {
|
|
q.save();
|
|
var a = q.autoCommentAbsorb;
|
|
q.autoCommentAbsorb = !1;
|
|
var b = q.$re(/^[_A-Za-z-][_A-Za-z0-9-]+/);
|
|
if (((q.autoCommentAbsorb = a), !b))
|
|
return void q.forget();
|
|
q.restore();
|
|
var c = e.Color.fromKeyword(b);
|
|
return c ? (q.$str(b), c) : void 0;
|
|
},
|
|
dimension: function () {
|
|
if (!q.peekNotNumeric()) {
|
|
var a = q.$re(/^([+-]?\d*\.?\d+)(%|[a-z_]+)?/i);
|
|
return a ? new e.Dimension(a[1], a[2]) : void 0;
|
|
}
|
|
},
|
|
unicodeDescriptor: function () {
|
|
var a;
|
|
if ((a = q.$re(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/)))
|
|
return new e.UnicodeDescriptor(a[0]);
|
|
},
|
|
javascript: function () {
|
|
var a,
|
|
b = q.i;
|
|
q.save();
|
|
var d = q.$char('~'),
|
|
f = q.$char('`');
|
|
return f
|
|
? (a = q.$re(/^[^`]*`/))
|
|
? (q.forget(),
|
|
new e.JavaScript(
|
|
a.substr(0, a.length - 1),
|
|
Boolean(d),
|
|
b,
|
|
c,
|
|
))
|
|
: void q.restore('invalid javascript definition')
|
|
: void q.restore();
|
|
},
|
|
},
|
|
variable: function () {
|
|
var a;
|
|
if (
|
|
'@' === q.currentChar() &&
|
|
(a = q.$re(/^(@[\w-]+)\s*:/))
|
|
)
|
|
return a[1];
|
|
},
|
|
variableCall: function (a) {
|
|
var b,
|
|
d,
|
|
f = q.i,
|
|
g = !!a,
|
|
h = a;
|
|
if (
|
|
(q.save(),
|
|
h ||
|
|
('@' === q.currentChar() &&
|
|
(h = q.$re(/^(@[\w-]+)(\(\s*\))?/))))
|
|
) {
|
|
if (
|
|
((b = this.mixin.ruleLookups()),
|
|
!b && ((g && '()' !== q.$str('()')) || '()' !== h[2]))
|
|
)
|
|
return void q.restore(
|
|
"Missing '[...]' lookup in variable call",
|
|
);
|
|
g || (h = h[1]), b && p.important() && (d = !0);
|
|
var i = new e.VariableCall(h, f, c);
|
|
return !g && p.end()
|
|
? (q.forget(), i)
|
|
: (q.forget(), new e.NamespaceValue(i, b, d, f, c));
|
|
}
|
|
q.restore();
|
|
},
|
|
extend: function (a) {
|
|
var b,
|
|
d,
|
|
f,
|
|
g,
|
|
h,
|
|
i = q.i;
|
|
if (q.$str(a ? '&:extend(' : ':extend(')) {
|
|
do {
|
|
for (
|
|
f = null, b = null;
|
|
!(f = q.$re(/^(all)(?=\s*(\)|,))/)) &&
|
|
(d = this.element());
|
|
|
|
)
|
|
b ? b.push(d) : (b = [d]);
|
|
(f = f && f[1]),
|
|
b || j('Missing target selector for :extend().'),
|
|
(h = new e.Extend(new e.Selector(b), f, i, c)),
|
|
g ? g.push(h) : (g = [h]);
|
|
} while (q.$char(','));
|
|
return l(/^\)/), a && l(/^;/), g;
|
|
}
|
|
},
|
|
extendRule: function () {
|
|
return this.extend(!0);
|
|
},
|
|
mixin: {
|
|
call: function (a, b) {
|
|
var d,
|
|
f,
|
|
g,
|
|
h,
|
|
i = q.currentChar(),
|
|
j = !1,
|
|
k = q.i;
|
|
if ('.' === i || '#' === i) {
|
|
if ((q.save(), (f = this.elements()))) {
|
|
if (
|
|
(q.$char('(') &&
|
|
((g = this.args(!0).args), m(')'), (h = !0)),
|
|
b !== !1 && (d = this.ruleLookups()),
|
|
b === !0 && !d)
|
|
)
|
|
return void q.restore();
|
|
if (a && !d && !h) return void q.restore();
|
|
if ((!a && p.important() && (j = !0), a || p.end())) {
|
|
q.forget();
|
|
var l = new e.mixin.Call(f, g, k, c, !d && j);
|
|
return d ? new e.NamespaceValue(l, d, j) : l;
|
|
}
|
|
}
|
|
q.restore();
|
|
}
|
|
},
|
|
elements: function () {
|
|
for (
|
|
var a,
|
|
b,
|
|
d,
|
|
f,
|
|
g,
|
|
h =
|
|
/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/;
|
|
;
|
|
|
|
) {
|
|
if (((g = q.i), (b = q.$re(h)), !b)) break;
|
|
(f = new e.Element(d, b, !1, g, c)),
|
|
a ? a.push(f) : (a = [f]),
|
|
(d = q.$char('>'));
|
|
}
|
|
return a;
|
|
},
|
|
args: function (a) {
|
|
var b,
|
|
c,
|
|
d,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
k = p.entities,
|
|
l = { args: null, variadic: !1 },
|
|
m = [],
|
|
n = [],
|
|
o = [],
|
|
r = !0;
|
|
for (q.save(); ; ) {
|
|
if (a) h = p.detachedRuleset() || p.expression();
|
|
else {
|
|
if (((q.commentStore.length = 0), q.$str('...'))) {
|
|
(l.variadic = !0),
|
|
q.$char(';') && !b && (b = !0),
|
|
(b ? n : o).push({ variadic: !0 });
|
|
break;
|
|
}
|
|
h =
|
|
k.variable() ||
|
|
k.property() ||
|
|
k.literal() ||
|
|
k.keyword() ||
|
|
this.call(!0);
|
|
}
|
|
if (!h || !r) break;
|
|
(f = null),
|
|
h.throwAwayComments && h.throwAwayComments(),
|
|
(g = h);
|
|
var s = null;
|
|
if (
|
|
(a
|
|
? h.value && 1 == h.value.length && (s = h.value[0])
|
|
: (s = h),
|
|
s &&
|
|
(s instanceof e.Variable ||
|
|
s instanceof e.Property))
|
|
)
|
|
if (q.$char(':')) {
|
|
if (
|
|
(m.length > 0 &&
|
|
(b &&
|
|
j('Cannot mix ; and , as delimiter types'),
|
|
(c = !0)),
|
|
(g = p.detachedRuleset() || p.expression()),
|
|
!g)
|
|
) {
|
|
if (!a) return q.restore(), (l.args = []), l;
|
|
j(
|
|
'could not understand value for named argument',
|
|
);
|
|
}
|
|
f = d = s.name;
|
|
} else if (q.$str('...')) {
|
|
if (!a) {
|
|
(l.variadic = !0),
|
|
q.$char(';') && !b && (b = !0),
|
|
(b ? n : o).push({
|
|
name: h.name,
|
|
variadic: !0,
|
|
});
|
|
break;
|
|
}
|
|
i = !0;
|
|
} else a || ((d = f = s.name), (g = null));
|
|
g && m.push(g),
|
|
o.push({ name: f, value: g, expand: i }),
|
|
q.$char(',')
|
|
? (r = !0)
|
|
: ((r = ';' === q.$char(';')),
|
|
(r || b) &&
|
|
(c &&
|
|
j('Cannot mix ; and , as delimiter types'),
|
|
(b = !0),
|
|
m.length > 1 && (g = new e.Value(m)),
|
|
n.push({ name: d, value: g, expand: i }),
|
|
(d = null),
|
|
(m = []),
|
|
(c = !1)));
|
|
}
|
|
return q.forget(), (l.args = b ? n : o), l;
|
|
},
|
|
definition: function () {
|
|
var a,
|
|
b,
|
|
c,
|
|
d,
|
|
f = [],
|
|
g = !1;
|
|
if (
|
|
!(
|
|
('.' !== q.currentChar() &&
|
|
'#' !== q.currentChar()) ||
|
|
q.peek(/^[^{]*\}/)
|
|
)
|
|
)
|
|
if (
|
|
(q.save(),
|
|
(b = q.$re(
|
|
/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/,
|
|
)))
|
|
) {
|
|
a = b[1];
|
|
var h = this.args(!1);
|
|
if (((f = h.args), (g = h.variadic), !q.$char(')')))
|
|
return void q.restore("Missing closing ')'");
|
|
if (
|
|
((q.commentStore.length = 0),
|
|
q.$str('when') &&
|
|
(d = l(p.conditions, 'expected condition')),
|
|
(c = p.block()))
|
|
)
|
|
return (
|
|
q.forget(), new e.mixin.Definition(a, f, c, d, g)
|
|
);
|
|
q.restore();
|
|
} else q.forget();
|
|
},
|
|
ruleLookups: function () {
|
|
var a,
|
|
b,
|
|
c = [];
|
|
if ('[' === q.currentChar()) {
|
|
for (;;) {
|
|
if (
|
|
(q.save(),
|
|
(b = null),
|
|
(a = this.lookupValue()),
|
|
!a && '' !== a)
|
|
) {
|
|
q.restore();
|
|
break;
|
|
}
|
|
c.push(a), q.forget();
|
|
}
|
|
return c.length > 0 ? c : void 0;
|
|
}
|
|
},
|
|
lookupValue: function () {
|
|
if ((q.save(), !q.$char('['))) return void q.restore();
|
|
var a = q.$re(/^(?:[@$]{0,2})[_a-zA-Z0-9-]*/);
|
|
return q.$char(']') && (a || '' === a)
|
|
? (q.forget(), a)
|
|
: void q.restore();
|
|
},
|
|
},
|
|
entity: function () {
|
|
var a = this.entities;
|
|
return (
|
|
this.comment() ||
|
|
a.literal() ||
|
|
a.variable() ||
|
|
a.url() ||
|
|
a.property() ||
|
|
a.call() ||
|
|
a.keyword() ||
|
|
this.mixin.call(!0) ||
|
|
a.javascript()
|
|
);
|
|
},
|
|
end: function () {
|
|
return q.$char(';') || q.peek('}');
|
|
},
|
|
ieAlpha: function () {
|
|
var a;
|
|
if (q.$re(/^opacity=/i))
|
|
return (
|
|
(a = q.$re(/^\d+/)),
|
|
a ||
|
|
((a = l(
|
|
p.entities.variable,
|
|
'Could not parse alpha',
|
|
)),
|
|
(a = '@{' + a.name.slice(1) + '}')),
|
|
m(')'),
|
|
new e.Quoted('', 'alpha(opacity=' + a + ')')
|
|
);
|
|
},
|
|
element: function () {
|
|
var a,
|
|
b,
|
|
d,
|
|
f = q.i;
|
|
if (
|
|
((b = this.combinator()),
|
|
(a =
|
|
q.$re(/^(?:\d+\.\d+|\d+)%/) ||
|
|
q.$re(
|
|
/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/,
|
|
) ||
|
|
q.$char('*') ||
|
|
q.$char('&') ||
|
|
this.attribute() ||
|
|
q.$re(/^\([^&()@]+\)/) ||
|
|
q.$re(/^[\.#:](?=@)/) ||
|
|
this.entities.variableCurly()),
|
|
a ||
|
|
(q.save(),
|
|
q.$char('(')
|
|
? (d = this.selector(!1)) && q.$char(')')
|
|
? ((a = new e.Paren(d)), q.forget())
|
|
: q.restore("Missing closing ')'")
|
|
: q.forget()),
|
|
a)
|
|
)
|
|
return new e.Element(b, a, a instanceof e.Variable, f, c);
|
|
},
|
|
combinator: function () {
|
|
var a = q.currentChar();
|
|
if ('/' === a) {
|
|
q.save();
|
|
var b = q.$re(/^\/[a-z]+\//i);
|
|
if (b) return q.forget(), new e.Combinator(b);
|
|
q.restore();
|
|
}
|
|
if (
|
|
'>' === a ||
|
|
'+' === a ||
|
|
'~' === a ||
|
|
'|' === a ||
|
|
'^' === a
|
|
) {
|
|
for (
|
|
q.i++,
|
|
'^' === a &&
|
|
'^' === q.currentChar() &&
|
|
((a = '^^'), q.i++);
|
|
q.isWhitespace();
|
|
|
|
)
|
|
q.i++;
|
|
return new e.Combinator(a);
|
|
}
|
|
return new e.Combinator(q.isWhitespace(-1) ? ' ' : null);
|
|
},
|
|
selector: function (a) {
|
|
var b,
|
|
d,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
k,
|
|
m = q.i;
|
|
for (
|
|
a = a !== !1;
|
|
((a && (d = this.extend())) ||
|
|
(a && (i = q.$str('when'))) ||
|
|
(g = this.element())) &&
|
|
(i
|
|
? (k = l(this.conditions, 'expected condition'))
|
|
: k
|
|
? j('CSS guard can only be used at the end of selector')
|
|
: d
|
|
? (h = h ? h.concat(d) : d)
|
|
: (h &&
|
|
j('Extend can only be used at the end of selector'),
|
|
(f = q.currentChar()),
|
|
b ? b.push(g) : (b = [g]),
|
|
(g = null)),
|
|
'{' !== f &&
|
|
'}' !== f &&
|
|
';' !== f &&
|
|
',' !== f &&
|
|
')' !== f);
|
|
|
|
);
|
|
return b
|
|
? new e.Selector(b, h, k, m, c)
|
|
: void (
|
|
h &&
|
|
j(
|
|
'Extend must be used to extend a selector, it cannot be used on its own',
|
|
)
|
|
);
|
|
},
|
|
selectors: function () {
|
|
for (var a, b; ; ) {
|
|
if (((a = this.selector()), !a)) break;
|
|
if (
|
|
(b ? b.push(a) : (b = [a]),
|
|
(q.commentStore.length = 0),
|
|
a.condition &&
|
|
b.length > 1 &&
|
|
j(
|
|
'Guards are only currently allowed on a single selector.',
|
|
),
|
|
!q.$char(','))
|
|
)
|
|
break;
|
|
a.condition &&
|
|
j(
|
|
'Guards are only currently allowed on a single selector.',
|
|
),
|
|
(q.commentStore.length = 0);
|
|
}
|
|
return b;
|
|
},
|
|
attribute: function () {
|
|
if (q.$char('[')) {
|
|
var a,
|
|
b,
|
|
c,
|
|
d = this.entities;
|
|
return (
|
|
(a = d.variableCurly()) ||
|
|
(a = l(
|
|
/^(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/,
|
|
)),
|
|
(c = q.$re(/^[|~*$^]?=/)),
|
|
c &&
|
|
(b =
|
|
d.quoted() ||
|
|
q.$re(/^[0-9]+%/) ||
|
|
q.$re(/^[\w-]+/) ||
|
|
d.variableCurly()),
|
|
m(']'),
|
|
new e.Attribute(a, c, b)
|
|
);
|
|
}
|
|
},
|
|
block: function () {
|
|
var a;
|
|
if (q.$char('{') && (a = this.primary()) && q.$char('}'))
|
|
return a;
|
|
},
|
|
blockRuleset: function () {
|
|
var a = this.block();
|
|
return a && (a = new e.Ruleset(null, a)), a;
|
|
},
|
|
detachedRuleset: function () {
|
|
var a, b, c;
|
|
if (
|
|
(q.save(),
|
|
q.$re(/^[.#]\(/) &&
|
|
((a = this.mixin.args(!1)),
|
|
(b = a.args),
|
|
(c = a.variadic),
|
|
!q.$char(')')))
|
|
)
|
|
return void q.restore();
|
|
var d = this.blockRuleset();
|
|
return d
|
|
? (q.forget(),
|
|
b
|
|
? new e.mixin.Definition(null, b, d, null, c)
|
|
: new e.DetachedRuleset(d))
|
|
: void q.restore();
|
|
},
|
|
ruleset: function () {
|
|
var b, c, d;
|
|
if (
|
|
(q.save(),
|
|
a.dumpLineNumbers && (d = n(q.i)),
|
|
(b = this.selectors()),
|
|
b && (c = this.block()))
|
|
) {
|
|
q.forget();
|
|
var f = new e.Ruleset(b, c, a.strictImports);
|
|
return a.dumpLineNumbers && (f.debugInfo = d), f;
|
|
}
|
|
q.restore();
|
|
},
|
|
declaration: function () {
|
|
var a,
|
|
b,
|
|
d,
|
|
f,
|
|
g,
|
|
h,
|
|
i = q.i,
|
|
j = q.currentChar();
|
|
if ('.' !== j && '#' !== j && '&' !== j && ':' !== j)
|
|
if (
|
|
(q.save(), (a = this.variable() || this.ruleProperty()))
|
|
) {
|
|
if (
|
|
((h = 'string' == typeof a),
|
|
h && ((b = this.detachedRuleset()), b && (d = !0)),
|
|
(q.commentStore.length = 0),
|
|
!b)
|
|
) {
|
|
if (
|
|
((g = !h && a.length > 1 && a.pop().value),
|
|
(b =
|
|
a[0].value && '--' === a[0].value.slice(0, 2)
|
|
? this.permissiveValue()
|
|
: this.anonymousValue()))
|
|
)
|
|
return (
|
|
q.forget(), new e.Declaration(a, b, !1, g, i, c)
|
|
);
|
|
b || (b = this.value()),
|
|
b
|
|
? (f = this.important())
|
|
: h && (b = this.permissiveValue());
|
|
}
|
|
if (b && (this.end() || d))
|
|
return (
|
|
q.forget(), new e.Declaration(a, b, f, g, i, c)
|
|
);
|
|
q.restore();
|
|
} else q.restore();
|
|
},
|
|
anonymousValue: function () {
|
|
var a = q.i,
|
|
b = q.$re(/^([^.#@\$+\/'"*`(;{}-]*);/);
|
|
if (b) return new e.Anonymous(b[1], a);
|
|
},
|
|
permissiveValue: function (a) {
|
|
function b() {
|
|
var a = q.currentChar();
|
|
return 'string' == typeof i ? a === i : i.test(a);
|
|
}
|
|
var d,
|
|
f,
|
|
g,
|
|
h,
|
|
i = a || ';',
|
|
k = q.i,
|
|
l = [];
|
|
if (!b()) {
|
|
h = [];
|
|
do
|
|
(f = this.comment()),
|
|
f ? h.push(f) : ((f = this.entity()), f && h.push(f));
|
|
while (f);
|
|
if (((g = b()), h.length > 0)) {
|
|
if (((h = new e.Expression(h)), g)) return h;
|
|
l.push(h),
|
|
' ' === q.prevChar() &&
|
|
l.push(new e.Anonymous(' ', k));
|
|
}
|
|
if ((q.save(), (h = q.$parseUntil(i)))) {
|
|
if (
|
|
('string' == typeof h &&
|
|
j("Expected '" + h + "'", 'Parse'),
|
|
1 === h.length && ' ' === h[0])
|
|
)
|
|
return q.forget(), new e.Anonymous('', k);
|
|
var m;
|
|
for (d = 0; d < h.length; d++)
|
|
if (((m = h[d]), Array.isArray(m)))
|
|
l.push(new e.Quoted(m[0], m[1], !0, k, c));
|
|
else {
|
|
d === h.length - 1 && (m = m.trim());
|
|
var n = new e.Quoted("'", m, !0, k, c);
|
|
(n.variableRegex = /@([\w-]+)/g),
|
|
(n.propRegex = /\$([\w-]+)/g),
|
|
l.push(n);
|
|
}
|
|
return q.forget(), new e.Expression(l, !0);
|
|
}
|
|
q.restore();
|
|
}
|
|
},
|
|
import: function () {
|
|
var a,
|
|
b,
|
|
d = q.i,
|
|
f = q.$re(/^@import?\s+/);
|
|
if (f) {
|
|
var g = (f ? this.importOptions() : null) || {};
|
|
if ((a = this.entities.quoted() || this.entities.url()))
|
|
return (
|
|
(b = this.mediaFeatures()),
|
|
q.$char(';') ||
|
|
((q.i = d),
|
|
j(
|
|
'missing semi-colon or unrecognised media features on import',
|
|
)),
|
|
(b = b && new e.Value(b)),
|
|
new e.Import(a, b, g, d, c)
|
|
);
|
|
(q.i = d), j('malformed import statement');
|
|
}
|
|
},
|
|
importOptions: function () {
|
|
var a,
|
|
b,
|
|
c,
|
|
d = {};
|
|
if (!q.$char('(')) return null;
|
|
do
|
|
if ((a = this.importOption())) {
|
|
switch (((b = a), (c = !0), b)) {
|
|
case 'css':
|
|
(b = 'less'), (c = !1);
|
|
break;
|
|
case 'once':
|
|
(b = 'multiple'), (c = !1);
|
|
}
|
|
if (((d[b] = c), !q.$char(','))) break;
|
|
}
|
|
while (a);
|
|
return m(')'), d;
|
|
},
|
|
importOption: function () {
|
|
var a = q.$re(
|
|
/^(less|css|multiple|once|inline|reference|optional)/,
|
|
);
|
|
if (a) return a[1];
|
|
},
|
|
mediaFeature: function () {
|
|
var a,
|
|
b,
|
|
d = this.entities,
|
|
f = [];
|
|
q.save();
|
|
do
|
|
(a = d.keyword() || d.variable() || d.mixinLookup()),
|
|
a
|
|
? f.push(a)
|
|
: q.$char('(') &&
|
|
((b = this.property()),
|
|
(a = this.value()),
|
|
q.$char(')')
|
|
? b && a
|
|
? f.push(
|
|
new e.Paren(
|
|
new e.Declaration(
|
|
b,
|
|
a,
|
|
null,
|
|
null,
|
|
q.i,
|
|
c,
|
|
!0,
|
|
),
|
|
),
|
|
)
|
|
: a
|
|
? f.push(new e.Paren(a))
|
|
: j('badly formed media feature definition')
|
|
: j("Missing closing ')'", 'Parse'));
|
|
while (a);
|
|
if ((q.forget(), f.length > 0)) return new e.Expression(f);
|
|
},
|
|
mediaFeatures: function () {
|
|
var a,
|
|
b = this.entities,
|
|
c = [];
|
|
do
|
|
if ((a = this.mediaFeature())) {
|
|
if ((c.push(a), !q.$char(','))) break;
|
|
} else if (
|
|
((a = b.variable() || b.mixinLookup()),
|
|
a && (c.push(a), !q.$char(',')))
|
|
)
|
|
break;
|
|
while (a);
|
|
return c.length > 0 ? c : null;
|
|
},
|
|
media: function () {
|
|
var b,
|
|
d,
|
|
f,
|
|
g,
|
|
h = q.i;
|
|
return (
|
|
a.dumpLineNumbers && (g = n(h)),
|
|
q.save(),
|
|
q.$str('@media')
|
|
? ((b = this.mediaFeatures()),
|
|
(d = this.block()),
|
|
d ||
|
|
j(
|
|
'media definitions require block statements after any features',
|
|
),
|
|
q.forget(),
|
|
(f = new e.Media(d, b, h, c)),
|
|
a.dumpLineNumbers && (f.debugInfo = g),
|
|
f)
|
|
: void q.restore()
|
|
);
|
|
},
|
|
plugin: function () {
|
|
var a,
|
|
b,
|
|
d,
|
|
f = q.i,
|
|
g = q.$re(/^@plugin?\s+/);
|
|
if (g) {
|
|
if (
|
|
((b = this.pluginArgs()),
|
|
(d = b
|
|
? { pluginArgs: b, isPlugin: !0 }
|
|
: { isPlugin: !0 }),
|
|
(a = this.entities.quoted() || this.entities.url()))
|
|
)
|
|
return (
|
|
q.$char(';') ||
|
|
((q.i = f), j('missing semi-colon on @plugin')),
|
|
new e.Import(a, null, d, f, c)
|
|
);
|
|
(q.i = f), j('malformed @plugin statement');
|
|
}
|
|
},
|
|
pluginArgs: function () {
|
|
if ((q.save(), !q.$char('('))) return q.restore(), null;
|
|
var a = q.$re(/^\s*([^\);]+)\)\s*/);
|
|
return a[1]
|
|
? (q.forget(), a[1].trim())
|
|
: (q.restore(), null);
|
|
},
|
|
atrule: function () {
|
|
var b,
|
|
d,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
k,
|
|
l = q.i,
|
|
m = !0,
|
|
o = !0;
|
|
if ('@' === q.currentChar()) {
|
|
if (
|
|
(d = this['import']() || this.plugin() || this.media())
|
|
)
|
|
return d;
|
|
if ((q.save(), (b = q.$re(/^@[a-z-]+/)))) {
|
|
switch (
|
|
((g = b),
|
|
'-' == b.charAt(1) &&
|
|
b.indexOf('-', 2) > 0 &&
|
|
(g = '@' + b.slice(b.indexOf('-', 2) + 1)),
|
|
g)
|
|
) {
|
|
case '@charset':
|
|
(h = !0), (m = !1);
|
|
break;
|
|
case '@namespace':
|
|
(i = !0), (m = !1);
|
|
break;
|
|
case '@keyframes':
|
|
case '@counter-style':
|
|
h = !0;
|
|
break;
|
|
case '@sample':
|
|
case '@supports':
|
|
(k = !0), (o = !1);
|
|
break;
|
|
default:
|
|
k = !0;
|
|
}
|
|
return (
|
|
(q.commentStore.length = 0),
|
|
h
|
|
? ((d = this.entity()),
|
|
d || j('expected ' + b + ' identifier'))
|
|
: i
|
|
? ((d = this.expression()),
|
|
d || j('expected ' + b + ' expression'))
|
|
: k &&
|
|
((d = this.permissiveValue(/^[{;]/)),
|
|
(m = '{' === q.currentChar()),
|
|
d
|
|
? d.value || (d = null)
|
|
: m ||
|
|
';' === q.currentChar() ||
|
|
j(
|
|
b +
|
|
' rule is missing block or ending semi-colon',
|
|
)),
|
|
m && (f = this.blockRuleset()),
|
|
f || (!m && d && q.$char(';'))
|
|
? (q.forget(),
|
|
new e.AtRule(
|
|
b,
|
|
d,
|
|
f,
|
|
l,
|
|
c,
|
|
a.dumpLineNumbers ? n(l) : null,
|
|
o,
|
|
))
|
|
: void q.restore('at-rule options not recognised')
|
|
);
|
|
}
|
|
}
|
|
},
|
|
value: function () {
|
|
var a,
|
|
b = [],
|
|
c = q.i;
|
|
do
|
|
if (
|
|
((a = this.expression()),
|
|
a && (b.push(a), !q.$char(',')))
|
|
)
|
|
break;
|
|
while (a);
|
|
if (b.length > 0) return new e.Value(b, c);
|
|
},
|
|
important: function () {
|
|
if ('!' === q.currentChar()) return q.$re(/^! *important/);
|
|
},
|
|
sub: function () {
|
|
var a, b;
|
|
return (
|
|
q.save(),
|
|
q.$char('(')
|
|
? ((a = this.addition()),
|
|
a && q.$char(')')
|
|
? (q.forget(),
|
|
(b = new e.Expression([a])),
|
|
(b.parens = !0),
|
|
b)
|
|
: void q.restore("Expected ')'"))
|
|
: void q.restore()
|
|
);
|
|
},
|
|
multiplication: function () {
|
|
var a, b, c, d, f;
|
|
if ((a = this.operand())) {
|
|
for (f = q.isWhitespace(-1); ; ) {
|
|
if (q.peek(/^\/[*\/]/)) break;
|
|
if (
|
|
(q.save(),
|
|
(c = q.$char('/') || q.$char('*') || q.$str('./')),
|
|
!c)
|
|
) {
|
|
q.forget();
|
|
break;
|
|
}
|
|
if (((b = this.operand()), !b)) {
|
|
q.restore();
|
|
break;
|
|
}
|
|
q.forget(),
|
|
(a.parensInOp = !0),
|
|
(b.parensInOp = !0),
|
|
(d = new e.Operation(c, [d || a, b], f)),
|
|
(f = q.isWhitespace(-1));
|
|
}
|
|
return d || a;
|
|
}
|
|
},
|
|
addition: function () {
|
|
var a, b, c, d, f;
|
|
if ((a = this.multiplication())) {
|
|
for (f = q.isWhitespace(-1); ; ) {
|
|
if (
|
|
((c =
|
|
q.$re(/^[-+]\s+/) ||
|
|
(!f && (q.$char('+') || q.$char('-')))),
|
|
!c)
|
|
)
|
|
break;
|
|
if (((b = this.multiplication()), !b)) break;
|
|
(a.parensInOp = !0),
|
|
(b.parensInOp = !0),
|
|
(d = new e.Operation(c, [d || a, b], f)),
|
|
(f = q.isWhitespace(-1));
|
|
}
|
|
return d || a;
|
|
}
|
|
},
|
|
conditions: function () {
|
|
var a,
|
|
b,
|
|
c,
|
|
d = q.i;
|
|
if ((a = this.condition(!0))) {
|
|
for (;;) {
|
|
if (!q.peek(/^,\s*(not\s*)?\(/) || !q.$char(',')) break;
|
|
if (((b = this.condition(!0)), !b)) break;
|
|
c = new e.Condition('or', c || a, b, d);
|
|
}
|
|
return c || a;
|
|
}
|
|
},
|
|
condition: function (a) {
|
|
function b() {
|
|
return q.$str('or');
|
|
}
|
|
var c, d, f;
|
|
if ((c = this.conditionAnd(a))) {
|
|
if ((d = b())) {
|
|
if (((f = this.condition(a)), !f)) return;
|
|
c = new e.Condition(d, c, f);
|
|
}
|
|
return c;
|
|
}
|
|
},
|
|
conditionAnd: function (a) {
|
|
function b() {
|
|
var b =
|
|
h.negatedCondition(a) || h.parenthesisCondition(a);
|
|
return b || a ? b : h.atomicCondition(a);
|
|
}
|
|
function c() {
|
|
return q.$str('and');
|
|
}
|
|
var d,
|
|
f,
|
|
g,
|
|
h = this;
|
|
if ((d = b())) {
|
|
if ((f = c())) {
|
|
if (((g = this.conditionAnd(a)), !g)) return;
|
|
d = new e.Condition(f, d, g);
|
|
}
|
|
return d;
|
|
}
|
|
},
|
|
negatedCondition: function (a) {
|
|
if (q.$str('not')) {
|
|
var b = this.parenthesisCondition(a);
|
|
return b && (b.negate = !b.negate), b;
|
|
}
|
|
},
|
|
parenthesisCondition: function (a) {
|
|
function b(b) {
|
|
var c;
|
|
return (
|
|
q.save(),
|
|
(c = b.condition(a)) && q.$char(')')
|
|
? (q.forget(), c)
|
|
: void q.restore()
|
|
);
|
|
}
|
|
var c;
|
|
return (
|
|
q.save(),
|
|
q.$str('(')
|
|
? (c = b(this))
|
|
? (q.forget(), c)
|
|
: (c = this.atomicCondition(a))
|
|
? q.$char(')')
|
|
? (q.forget(), c)
|
|
: void q.restore(
|
|
"expected ')' got '" + q.currentChar() + "'",
|
|
)
|
|
: void q.restore()
|
|
: void q.restore()
|
|
);
|
|
},
|
|
atomicCondition: function (a) {
|
|
function b() {
|
|
return (
|
|
this.addition() ||
|
|
h.keyword() ||
|
|
h.quoted() ||
|
|
h.mixinLookup()
|
|
);
|
|
}
|
|
var c,
|
|
d,
|
|
f,
|
|
g,
|
|
h = this.entities,
|
|
i = q.i;
|
|
if (((b = b.bind(this)), (c = b())))
|
|
return (
|
|
q.$char('>')
|
|
? (g = q.$char('=') ? '>=' : '>')
|
|
: q.$char('<')
|
|
? (g = q.$char('=') ? '<=' : '<')
|
|
: q.$char('=') &&
|
|
(g = q.$char('>')
|
|
? '=>'
|
|
: q.$char('<')
|
|
? '=<'
|
|
: '='),
|
|
g
|
|
? ((d = b()),
|
|
d
|
|
? (f = new e.Condition(g, c, d, i, !1))
|
|
: j('expected expression'))
|
|
: (f = new e.Condition(
|
|
'=',
|
|
c,
|
|
new e.Keyword('true'),
|
|
i,
|
|
!1,
|
|
)),
|
|
f
|
|
);
|
|
},
|
|
operand: function () {
|
|
var a,
|
|
b = this.entities;
|
|
q.peek(/^-[@\$\(]/) && (a = q.$char('-'));
|
|
var c =
|
|
this.sub() ||
|
|
b.dimension() ||
|
|
b.color() ||
|
|
b.variable() ||
|
|
b.property() ||
|
|
b.call() ||
|
|
b.quoted(!0) ||
|
|
b.colorKeyword() ||
|
|
b.mixinLookup();
|
|
return (
|
|
a && ((c.parensInOp = !0), (c = new e.Negative(c))), c
|
|
);
|
|
},
|
|
expression: function () {
|
|
var a,
|
|
b,
|
|
c = [],
|
|
d = q.i;
|
|
do
|
|
(a = this.comment()),
|
|
a
|
|
? c.push(a)
|
|
: ((a = this.addition() || this.entity()),
|
|
a &&
|
|
(c.push(a),
|
|
q.peek(/^\/[\/*]/) ||
|
|
((b = q.$char('/')),
|
|
b && c.push(new e.Anonymous(b, d)))));
|
|
while (a);
|
|
if (c.length > 0) return new e.Expression(c);
|
|
},
|
|
property: function () {
|
|
var a = q.$re(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/);
|
|
if (a) return a[1];
|
|
},
|
|
ruleProperty: function () {
|
|
function a(a) {
|
|
var b = q.i,
|
|
c = q.$re(a);
|
|
if (c) return g.push(b), f.push(c[1]);
|
|
}
|
|
var b,
|
|
d,
|
|
f = [],
|
|
g = [];
|
|
q.save();
|
|
var h = q.$re(/^([_a-zA-Z0-9-]+)\s*:/);
|
|
if (h) return (f = [new e.Keyword(h[1])]), q.forget(), f;
|
|
for (a(/^(\*?)/); ; )
|
|
if (!a(/^((?:[\w-]+)|(?:[@\$]\{[\w-]+\}))/)) break;
|
|
if (f.length > 1 && a(/^((?:\+_|\+)?)\s*:/)) {
|
|
for (
|
|
q.forget(),
|
|
'' === f[0] && (f.shift(), g.shift()),
|
|
d = 0;
|
|
d < f.length;
|
|
d++
|
|
)
|
|
(b = f[d]),
|
|
(f[d] =
|
|
'@' !== b.charAt(0) && '$' !== b.charAt(0)
|
|
? new e.Keyword(b)
|
|
: '@' === b.charAt(0)
|
|
? new e.Variable('@' + b.slice(2, -1), g[d], c)
|
|
: new e.Property('$' + b.slice(2, -1), g[d], c));
|
|
return f;
|
|
}
|
|
q.restore();
|
|
},
|
|
}),
|
|
};
|
|
};
|
|
(j.serializeVars = function (a) {
|
|
var b = '';
|
|
for (var c in a)
|
|
if (Object.hasOwnProperty.call(a, c)) {
|
|
var d = a[c];
|
|
b +=
|
|
('@' === c[0] ? '' : '@') +
|
|
c +
|
|
': ' +
|
|
d +
|
|
(';' === String(d).slice(-1) ? '' : ';');
|
|
}
|
|
return b;
|
|
}),
|
|
(b.exports = j);
|
|
},
|
|
{
|
|
'../functions/function-registry': 27,
|
|
'../less-error': 38,
|
|
'../tree': 67,
|
|
'../utils': 89,
|
|
'../visitors': 93,
|
|
'./parser-input': 43,
|
|
},
|
|
],
|
|
45: [
|
|
function (a, b, c) {
|
|
var d,
|
|
e = function (a) {
|
|
(this.less = a),
|
|
(this.visitors = []),
|
|
(this.preProcessors = []),
|
|
(this.postProcessors = []),
|
|
(this.installedPlugins = []),
|
|
(this.fileManagers = []),
|
|
(this.iterator = -1),
|
|
(this.pluginCache = {}),
|
|
(this.Loader = new a.PluginLoader(a));
|
|
},
|
|
f = function (a, b) {
|
|
return (!b && d) || (d = new e(a)), d;
|
|
};
|
|
(e.prototype.addPlugins = function (a) {
|
|
if (a) for (var b = 0; b < a.length; b++) this.addPlugin(a[b]);
|
|
}),
|
|
(e.prototype.addPlugin = function (a, b, c) {
|
|
this.installedPlugins.push(a),
|
|
b && (this.pluginCache[b] = a),
|
|
a.install &&
|
|
a.install(
|
|
this.less,
|
|
this,
|
|
c || this.less.functions.functionRegistry,
|
|
);
|
|
}),
|
|
(e.prototype.get = function (a) {
|
|
return this.pluginCache[a];
|
|
}),
|
|
(e.prototype.addVisitor = function (a) {
|
|
this.visitors.push(a);
|
|
}),
|
|
(e.prototype.addPreProcessor = function (a, b) {
|
|
var c;
|
|
for (
|
|
c = 0;
|
|
c < this.preProcessors.length &&
|
|
!(this.preProcessors[c].priority >= b);
|
|
c++
|
|
);
|
|
this.preProcessors.splice(c, 0, { preProcessor: a, priority: b });
|
|
}),
|
|
(e.prototype.addPostProcessor = function (a, b) {
|
|
var c;
|
|
for (
|
|
c = 0;
|
|
c < this.postProcessors.length &&
|
|
!(this.postProcessors[c].priority >= b);
|
|
c++
|
|
);
|
|
this.postProcessors.splice(c, 0, {
|
|
postProcessor: a,
|
|
priority: b,
|
|
});
|
|
}),
|
|
(e.prototype.addFileManager = function (a) {
|
|
this.fileManagers.push(a);
|
|
}),
|
|
(e.prototype.getPreProcessors = function () {
|
|
for (var a = [], b = 0; b < this.preProcessors.length; b++)
|
|
a.push(this.preProcessors[b].preProcessor);
|
|
return a;
|
|
}),
|
|
(e.prototype.getPostProcessors = function () {
|
|
for (var a = [], b = 0; b < this.postProcessors.length; b++)
|
|
a.push(this.postProcessors[b].postProcessor);
|
|
return a;
|
|
}),
|
|
(e.prototype.getVisitors = function () {
|
|
return this.visitors;
|
|
}),
|
|
(e.prototype.visitor = function () {
|
|
var a = this;
|
|
return {
|
|
first: function () {
|
|
return (a.iterator = -1), a.visitors[a.iterator];
|
|
},
|
|
get: function () {
|
|
return (a.iterator += 1), a.visitors[a.iterator];
|
|
},
|
|
};
|
|
}),
|
|
(e.prototype.getFileManagers = function () {
|
|
return this.fileManagers;
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{},
|
|
],
|
|
46: [
|
|
function (a, b, c) {
|
|
var d,
|
|
e = a('./utils');
|
|
b.exports = function (b, c, f) {
|
|
var g = function (b, f, h) {
|
|
if (
|
|
('function' == typeof f
|
|
? ((h = f), (f = e.copyOptions(this.options, {})))
|
|
: (f = e.copyOptions(this.options, f || {})),
|
|
!h)
|
|
) {
|
|
d ||
|
|
(d = 'undefined' == typeof Promise ? a('promise') : Promise);
|
|
var i = this;
|
|
return new d(function (a, c) {
|
|
g.call(i, b, f, function (b, d) {
|
|
b ? c(b) : a(d);
|
|
});
|
|
});
|
|
}
|
|
this.parse(b, f, function (a, b, d, e) {
|
|
if (a) return h(a);
|
|
var f;
|
|
try {
|
|
var g = new c(b, d);
|
|
f = g.toCSS(e);
|
|
} catch (a) {
|
|
return h(a);
|
|
}
|
|
h(null, f);
|
|
});
|
|
};
|
|
return g;
|
|
};
|
|
},
|
|
{ './utils': 89, promise: void 0 },
|
|
],
|
|
47: [
|
|
function (a, b, c) {
|
|
b.exports = function (a, b) {
|
|
var c = function (a) {
|
|
this.options = a;
|
|
};
|
|
return (
|
|
(c.prototype.toCSS = function (b, c, d) {
|
|
var e = new a({
|
|
contentsIgnoredCharsMap: d.contentsIgnoredChars,
|
|
rootNode: b,
|
|
contentsMap: d.contents,
|
|
sourceMapFilename: this.options.sourceMapFilename,
|
|
sourceMapURL: this.options.sourceMapURL,
|
|
outputFilename: this.options.sourceMapOutputFilename,
|
|
sourceMapBasepath: this.options.sourceMapBasepath,
|
|
sourceMapRootpath: this.options.sourceMapRootpath,
|
|
outputSourceFiles: this.options.outputSourceFiles,
|
|
sourceMapGenerator: this.options.sourceMapGenerator,
|
|
sourceMapFileInline: this.options.sourceMapFileInline,
|
|
}),
|
|
f = e.toCSS(c);
|
|
return (
|
|
(this.sourceMap = e.sourceMap),
|
|
(this.sourceMapURL = e.sourceMapURL),
|
|
this.options.sourceMapInputFilename &&
|
|
(this.sourceMapInputFilename = e.normalizeFilename(
|
|
this.options.sourceMapInputFilename,
|
|
)),
|
|
void 0 !== this.options.sourceMapBasepath &&
|
|
void 0 !== this.sourceMapURL &&
|
|
(this.sourceMapURL = e.removeBasepath(this.sourceMapURL)),
|
|
f + this.getCSSAppendage()
|
|
);
|
|
}),
|
|
(c.prototype.getCSSAppendage = function () {
|
|
var a = this.sourceMapURL;
|
|
if (this.options.sourceMapFileInline) {
|
|
if (void 0 === this.sourceMap) return '';
|
|
a =
|
|
'data:application/json;base64,' +
|
|
b.encodeBase64(this.sourceMap);
|
|
}
|
|
return a ? '/*# sourceMappingURL=' + a + ' */' : '';
|
|
}),
|
|
(c.prototype.getExternalSourceMap = function () {
|
|
return this.sourceMap;
|
|
}),
|
|
(c.prototype.setExternalSourceMap = function (a) {
|
|
this.sourceMap = a;
|
|
}),
|
|
(c.prototype.isInline = function () {
|
|
return this.options.sourceMapFileInline;
|
|
}),
|
|
(c.prototype.getSourceMapURL = function () {
|
|
return this.sourceMapURL;
|
|
}),
|
|
(c.prototype.getOutputFilename = function () {
|
|
return this.options.sourceMapOutputFilename;
|
|
}),
|
|
(c.prototype.getInputFilename = function () {
|
|
return this.sourceMapInputFilename;
|
|
}),
|
|
c
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
48: [
|
|
function (a, b, c) {
|
|
b.exports = function (a) {
|
|
var b = function (b) {
|
|
(this._css = []),
|
|
(this._rootNode = b.rootNode),
|
|
(this._contentsMap = b.contentsMap),
|
|
(this._contentsIgnoredCharsMap = b.contentsIgnoredCharsMap),
|
|
b.sourceMapFilename &&
|
|
(this._sourceMapFilename = b.sourceMapFilename.replace(
|
|
/\\/g,
|
|
'/',
|
|
)),
|
|
(this._outputFilename = b.outputFilename),
|
|
(this.sourceMapURL = b.sourceMapURL),
|
|
b.sourceMapBasepath &&
|
|
(this._sourceMapBasepath = b.sourceMapBasepath.replace(
|
|
/\\/g,
|
|
'/',
|
|
)),
|
|
b.sourceMapRootpath
|
|
? ((this._sourceMapRootpath = b.sourceMapRootpath.replace(
|
|
/\\/g,
|
|
'/',
|
|
)),
|
|
'/' !==
|
|
this._sourceMapRootpath.charAt(
|
|
this._sourceMapRootpath.length - 1,
|
|
) && (this._sourceMapRootpath += '/'))
|
|
: (this._sourceMapRootpath = ''),
|
|
(this._outputSourceFiles = b.outputSourceFiles),
|
|
(this._sourceMapGeneratorConstructor =
|
|
a.getSourceMapGenerator()),
|
|
(this._lineNumber = 0),
|
|
(this._column = 0);
|
|
};
|
|
return (
|
|
(b.prototype.removeBasepath = function (a) {
|
|
return (
|
|
this._sourceMapBasepath &&
|
|
0 === a.indexOf(this._sourceMapBasepath) &&
|
|
((a = a.substring(this._sourceMapBasepath.length)),
|
|
('\\' !== a.charAt(0) && '/' !== a.charAt(0)) ||
|
|
(a = a.substring(1))),
|
|
a
|
|
);
|
|
}),
|
|
(b.prototype.normalizeFilename = function (a) {
|
|
return (
|
|
(a = a.replace(/\\/g, '/')),
|
|
(a = this.removeBasepath(a)),
|
|
(this._sourceMapRootpath || '') + a
|
|
);
|
|
}),
|
|
(b.prototype.add = function (a, b, c, d) {
|
|
if (a) {
|
|
var e, f, g, h, i;
|
|
if (b && b.filename) {
|
|
var j = this._contentsMap[b.filename];
|
|
this._contentsIgnoredCharsMap[b.filename] &&
|
|
((c -= this._contentsIgnoredCharsMap[b.filename]),
|
|
c < 0 && (c = 0),
|
|
(j = j.slice(this._contentsIgnoredCharsMap[b.filename]))),
|
|
(j = j.substring(0, c)),
|
|
(f = j.split('\n')),
|
|
(h = f[f.length - 1]);
|
|
}
|
|
if (
|
|
((e = a.split('\n')),
|
|
(g = e[e.length - 1]),
|
|
b && b.filename)
|
|
)
|
|
if (d)
|
|
for (i = 0; i < e.length; i++)
|
|
this._sourceMapGenerator.addMapping({
|
|
generated: {
|
|
line: this._lineNumber + i + 1,
|
|
column: 0 === i ? this._column : 0,
|
|
},
|
|
original: {
|
|
line: f.length + i,
|
|
column: 0 === i ? h.length : 0,
|
|
},
|
|
source: this.normalizeFilename(b.filename),
|
|
});
|
|
else
|
|
this._sourceMapGenerator.addMapping({
|
|
generated: {
|
|
line: this._lineNumber + 1,
|
|
column: this._column,
|
|
},
|
|
original: { line: f.length, column: h.length },
|
|
source: this.normalizeFilename(b.filename),
|
|
});
|
|
1 === e.length
|
|
? (this._column += g.length)
|
|
: ((this._lineNumber += e.length - 1),
|
|
(this._column = g.length)),
|
|
this._css.push(a);
|
|
}
|
|
}),
|
|
(b.prototype.isEmpty = function () {
|
|
return 0 === this._css.length;
|
|
}),
|
|
(b.prototype.toCSS = function (a) {
|
|
if (
|
|
((this._sourceMapGenerator =
|
|
new this._sourceMapGeneratorConstructor({
|
|
file: this._outputFilename,
|
|
sourceRoot: null,
|
|
})),
|
|
this._outputSourceFiles)
|
|
)
|
|
for (var b in this._contentsMap)
|
|
if (this._contentsMap.hasOwnProperty(b)) {
|
|
var c = this._contentsMap[b];
|
|
this._contentsIgnoredCharsMap[b] &&
|
|
(c = c.slice(this._contentsIgnoredCharsMap[b])),
|
|
this._sourceMapGenerator.setSourceContent(
|
|
this.normalizeFilename(b),
|
|
c,
|
|
);
|
|
}
|
|
if ((this._rootNode.genCSS(a, this), this._css.length > 0)) {
|
|
var d,
|
|
e = JSON.stringify(this._sourceMapGenerator.toJSON());
|
|
this.sourceMapURL
|
|
? (d = this.sourceMapURL)
|
|
: this._sourceMapFilename && (d = this._sourceMapFilename),
|
|
(this.sourceMapURL = d),
|
|
(this.sourceMap = e);
|
|
}
|
|
return this._css.join('');
|
|
}),
|
|
b
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
49: [
|
|
function (a, b, c) {
|
|
var d = a('./contexts'),
|
|
e = a('./visitors'),
|
|
f = a('./tree');
|
|
b.exports = function (a, b) {
|
|
b = b || {};
|
|
var c,
|
|
g = b.variables,
|
|
h = new d.Eval(b);
|
|
'object' != typeof g ||
|
|
Array.isArray(g) ||
|
|
((g = Object.keys(g).map(function (a) {
|
|
var b = g[a];
|
|
return (
|
|
b instanceof f.Value ||
|
|
(b instanceof f.Expression || (b = new f.Expression([b])),
|
|
(b = new f.Value([b]))),
|
|
new f.Declaration('@' + a, b, !1, null, 0)
|
|
);
|
|
})),
|
|
(h.frames = [new f.Ruleset(null, g)]));
|
|
var i,
|
|
j,
|
|
k = [
|
|
new e.JoinSelectorVisitor(),
|
|
new e.MarkVisibleSelectorsVisitor(!0),
|
|
new e.ExtendVisitor(),
|
|
new e.ToCSSVisitor({ compress: Boolean(b.compress) }),
|
|
],
|
|
l = [];
|
|
if (b.pluginManager) {
|
|
j = b.pluginManager.visitor();
|
|
for (var m = 0; m < 2; m++)
|
|
for (j.first(); (i = j.get()); )
|
|
i.isPreEvalVisitor
|
|
? (0 !== m && l.indexOf(i) !== -1) || (l.push(i), i.run(a))
|
|
: (0 !== m && k.indexOf(i) !== -1) ||
|
|
(i.isPreVisitor ? k.unshift(i) : k.push(i));
|
|
}
|
|
c = a.eval(h);
|
|
for (var m = 0; m < k.length; m++) k[m].run(c);
|
|
if (b.pluginManager)
|
|
for (j.first(); (i = j.get()); )
|
|
k.indexOf(i) === -1 && l.indexOf(i) === -1 && i.run(c);
|
|
return c;
|
|
};
|
|
},
|
|
{ './contexts': 13, './tree': 67, './visitors': 93 },
|
|
],
|
|
50: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a, b, c, d, e, f) {
|
|
(this.value = a),
|
|
(this._index = b),
|
|
(this._fileInfo = c),
|
|
(this.mapLines = d),
|
|
(this.rulesetLike = 'undefined' != typeof e && e),
|
|
(this.allowRoot = !0),
|
|
this.copyVisibilityInfo(f);
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Anonymous'),
|
|
(e.prototype.eval = function () {
|
|
return new e(
|
|
this.value,
|
|
this._index,
|
|
this._fileInfo,
|
|
this.mapLines,
|
|
this.rulesetLike,
|
|
this.visibilityInfo(),
|
|
);
|
|
}),
|
|
(e.prototype.compare = function (a) {
|
|
return a.toCSS && this.toCSS() === a.toCSS() ? 0 : void 0;
|
|
}),
|
|
(e.prototype.isRulesetLike = function () {
|
|
return this.rulesetLike;
|
|
}),
|
|
(e.prototype.genCSS = function (a, b) {
|
|
(this.nodeVisible = Boolean(this.value)),
|
|
this.nodeVisible &&
|
|
b.add(this.value, this._fileInfo, this._index, this.mapLines);
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
51: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a, b) {
|
|
(this.key = a), (this.value = b);
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Assignment'),
|
|
(e.prototype.accept = function (a) {
|
|
this.value = a.visit(this.value);
|
|
}),
|
|
(e.prototype.eval = function (a) {
|
|
return this.value.eval
|
|
? new e(this.key, this.value.eval(a))
|
|
: this;
|
|
}),
|
|
(e.prototype.genCSS = function (a, b) {
|
|
b.add(this.key + '='),
|
|
this.value.genCSS ? this.value.genCSS(a, b) : b.add(this.value);
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
52: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./selector'),
|
|
f = a('./ruleset'),
|
|
g = a('./anonymous'),
|
|
h = function (a, b, c, f, h, i, j, k) {
|
|
var l;
|
|
if (
|
|
((this.name = a),
|
|
(this.value = b instanceof d ? b : b ? new g(b) : b),
|
|
c)
|
|
) {
|
|
for (
|
|
Array.isArray(c)
|
|
? (this.rules = c)
|
|
: ((this.rules = [c]),
|
|
(this.rules[0].selectors = new e(
|
|
[],
|
|
null,
|
|
null,
|
|
f,
|
|
h,
|
|
).createEmptySelectors())),
|
|
l = 0;
|
|
l < this.rules.length;
|
|
l++
|
|
)
|
|
this.rules[l].allowImports = !0;
|
|
this.setParent(this.rules, this);
|
|
}
|
|
(this._index = f),
|
|
(this._fileInfo = h),
|
|
(this.debugInfo = i),
|
|
(this.isRooted = j || !1),
|
|
this.copyVisibilityInfo(k),
|
|
(this.allowRoot = !0);
|
|
};
|
|
(h.prototype = new d()),
|
|
(h.prototype.type = 'AtRule'),
|
|
(h.prototype.accept = function (a) {
|
|
var b = this.value,
|
|
c = this.rules;
|
|
c && (this.rules = a.visitArray(c)),
|
|
b && (this.value = a.visit(b));
|
|
}),
|
|
(h.prototype.isRulesetLike = function () {
|
|
return this.rules || !this.isCharset();
|
|
}),
|
|
(h.prototype.isCharset = function () {
|
|
return '@charset' === this.name;
|
|
}),
|
|
(h.prototype.genCSS = function (a, b) {
|
|
var c = this.value,
|
|
d = this.rules;
|
|
b.add(this.name, this.fileInfo(), this.getIndex()),
|
|
c && (b.add(' '), c.genCSS(a, b)),
|
|
d ? this.outputRuleset(a, b, d) : b.add(';');
|
|
}),
|
|
(h.prototype.eval = function (a) {
|
|
var b,
|
|
c,
|
|
d = this.value,
|
|
e = this.rules;
|
|
return (
|
|
(b = a.mediaPath),
|
|
(c = a.mediaBlocks),
|
|
(a.mediaPath = []),
|
|
(a.mediaBlocks = []),
|
|
d && (d = d.eval(a)),
|
|
e && ((e = [e[0].eval(a)]), (e[0].root = !0)),
|
|
(a.mediaPath = b),
|
|
(a.mediaBlocks = c),
|
|
new h(
|
|
this.name,
|
|
d,
|
|
e,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.debugInfo,
|
|
this.isRooted,
|
|
this.visibilityInfo(),
|
|
)
|
|
);
|
|
}),
|
|
(h.prototype.variable = function (a) {
|
|
if (this.rules)
|
|
return f.prototype.variable.call(this.rules[0], a);
|
|
}),
|
|
(h.prototype.find = function () {
|
|
if (this.rules)
|
|
return f.prototype.find.apply(this.rules[0], arguments);
|
|
}),
|
|
(h.prototype.rulesets = function () {
|
|
if (this.rules) return f.prototype.rulesets.apply(this.rules[0]);
|
|
}),
|
|
(h.prototype.outputRuleset = function (a, b, c) {
|
|
var d,
|
|
e = c.length;
|
|
if (((a.tabLevel = (0 | a.tabLevel) + 1), a.compress)) {
|
|
for (b.add('{'), d = 0; d < e; d++) c[d].genCSS(a, b);
|
|
return b.add('}'), void a.tabLevel--;
|
|
}
|
|
var f = '\n' + Array(a.tabLevel).join(' '),
|
|
g = f + ' ';
|
|
if (e) {
|
|
for (b.add(' {' + g), c[0].genCSS(a, b), d = 1; d < e; d++)
|
|
b.add(g), c[d].genCSS(a, b);
|
|
b.add(f + '}');
|
|
} else b.add(' {' + f + '}');
|
|
a.tabLevel--;
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{ './anonymous': 50, './node': 76, './ruleset': 81, './selector': 82 },
|
|
],
|
|
53: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a, b, c) {
|
|
(this.key = a), (this.op = b), (this.value = c);
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Attribute'),
|
|
(e.prototype.eval = function (a) {
|
|
return new e(
|
|
this.key.eval ? this.key.eval(a) : this.key,
|
|
this.op,
|
|
this.value && this.value.eval ? this.value.eval(a) : this.value,
|
|
);
|
|
}),
|
|
(e.prototype.genCSS = function (a, b) {
|
|
b.add(this.toCSS(a));
|
|
}),
|
|
(e.prototype.toCSS = function (a) {
|
|
var b = this.key.toCSS ? this.key.toCSS(a) : this.key;
|
|
return (
|
|
this.op &&
|
|
((b += this.op),
|
|
(b += this.value.toCSS ? this.value.toCSS(a) : this.value)),
|
|
'[' + b + ']'
|
|
);
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
54: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./anonymous'),
|
|
f = a('../functions/function-caller'),
|
|
g = function (a, b, c, d) {
|
|
(this.name = a),
|
|
(this.args = b),
|
|
(this.calc = 'calc' === a),
|
|
(this._index = c),
|
|
(this._fileInfo = d);
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'Call'),
|
|
(g.prototype.accept = function (a) {
|
|
this.args && (this.args = a.visitArray(this.args));
|
|
}),
|
|
(g.prototype.eval = function (a) {
|
|
var b = a.mathOn;
|
|
(a.mathOn = !this.calc), (this.calc || a.inCalc) && a.enterCalc();
|
|
var c = this.args.map(function (b) {
|
|
return b.eval(a);
|
|
});
|
|
(this.calc || a.inCalc) && a.exitCalc(), (a.mathOn = b);
|
|
var h,
|
|
i = new f(this.name, a, this.getIndex(), this.fileInfo());
|
|
if (i.isValid()) {
|
|
try {
|
|
h = i.call(c);
|
|
} catch (j) {
|
|
throw {
|
|
type: j.type || 'Runtime',
|
|
message:
|
|
'error evaluating function `' +
|
|
this.name +
|
|
'`' +
|
|
(j.message ? ': ' + j.message : ''),
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
line: j.lineNumber,
|
|
column: j.columnNumber,
|
|
};
|
|
}
|
|
if (null !== h && void 0 !== h)
|
|
return (
|
|
h instanceof d ||
|
|
(h = new e(h && h !== !0 ? h.toString() : null)),
|
|
(h._index = this._index),
|
|
(h._fileInfo = this._fileInfo),
|
|
h
|
|
);
|
|
}
|
|
return new g(this.name, c, this.getIndex(), this.fileInfo());
|
|
}),
|
|
(g.prototype.genCSS = function (a, b) {
|
|
b.add(this.name + '(', this.fileInfo(), this.getIndex());
|
|
for (var c = 0; c < this.args.length; c++)
|
|
this.args[c].genCSS(a, b),
|
|
c + 1 < this.args.length && b.add(', ');
|
|
b.add(')');
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ '../functions/function-caller': 26, './anonymous': 50, './node': 76 },
|
|
],
|
|
55: [
|
|
function (a, b, c) {
|
|
function d(a, b) {
|
|
return Math.min(Math.max(a, 0), b);
|
|
}
|
|
function e(a) {
|
|
return (
|
|
'#' +
|
|
a
|
|
.map(function (a) {
|
|
return (
|
|
(a = d(Math.round(a), 255)),
|
|
(a < 16 ? '0' : '') + a.toString(16)
|
|
);
|
|
})
|
|
.join('')
|
|
);
|
|
}
|
|
var f = a('./node'),
|
|
g = a('../data/colors'),
|
|
h = function (a, b, c) {
|
|
var d = this;
|
|
Array.isArray(a)
|
|
? (this.rgb = a)
|
|
: a.length >= 6
|
|
? ((this.rgb = []),
|
|
a.match(/.{2}/g).map(function (a, b) {
|
|
b < 3
|
|
? d.rgb.push(parseInt(a, 16))
|
|
: (d.alpha = parseInt(a, 16) / 255);
|
|
}))
|
|
: ((this.rgb = []),
|
|
a.split('').map(function (a, b) {
|
|
b < 3
|
|
? d.rgb.push(parseInt(a + a, 16))
|
|
: (d.alpha = parseInt(a + a, 16) / 255);
|
|
})),
|
|
(this.alpha = this.alpha || ('number' == typeof b ? b : 1)),
|
|
'undefined' != typeof c && (this.value = c);
|
|
};
|
|
(h.prototype = new f()),
|
|
(h.prototype.type = 'Color'),
|
|
(h.prototype.luma = function () {
|
|
var a = this.rgb[0] / 255,
|
|
b = this.rgb[1] / 255,
|
|
c = this.rgb[2] / 255;
|
|
return (
|
|
(a =
|
|
a <= 0.03928
|
|
? a / 12.92
|
|
: Math.pow((a + 0.055) / 1.055, 2.4)),
|
|
(b =
|
|
b <= 0.03928
|
|
? b / 12.92
|
|
: Math.pow((b + 0.055) / 1.055, 2.4)),
|
|
(c =
|
|
c <= 0.03928
|
|
? c / 12.92
|
|
: Math.pow((c + 0.055) / 1.055, 2.4)),
|
|
0.2126 * a + 0.7152 * b + 0.0722 * c
|
|
);
|
|
}),
|
|
(h.prototype.genCSS = function (a, b) {
|
|
b.add(this.toCSS(a));
|
|
}),
|
|
(h.prototype.toCSS = function (a, b) {
|
|
var c,
|
|
e,
|
|
f,
|
|
g = a && a.compress && !b,
|
|
h = [];
|
|
if (((e = this.fround(a, this.alpha)), this.value))
|
|
if (0 === this.value.indexOf('rgb')) e < 1 && (f = 'rgba');
|
|
else {
|
|
if (0 !== this.value.indexOf('hsl')) return this.value;
|
|
f = e < 1 ? 'hsla' : 'hsl';
|
|
}
|
|
else e < 1 && (f = 'rgba');
|
|
switch (f) {
|
|
case 'rgba':
|
|
h = this.rgb
|
|
.map(function (a) {
|
|
return d(Math.round(a), 255);
|
|
})
|
|
.concat(d(e, 1));
|
|
break;
|
|
case 'hsla':
|
|
h.push(d(e, 1));
|
|
case 'hsl':
|
|
(c = this.toHSL()),
|
|
(h = [
|
|
this.fround(a, c.h),
|
|
this.fround(a, 100 * c.s) + '%',
|
|
this.fround(a, 100 * c.l) + '%',
|
|
].concat(h));
|
|
}
|
|
if (f) return f + '(' + h.join(',' + (g ? '' : ' ')) + ')';
|
|
if (((c = this.toRGB()), g)) {
|
|
var i = c.split('');
|
|
i[1] === i[2] &&
|
|
i[3] === i[4] &&
|
|
i[5] === i[6] &&
|
|
(c = '#' + i[1] + i[3] + i[5]);
|
|
}
|
|
return c;
|
|
}),
|
|
(h.prototype.operate = function (a, b, c) {
|
|
for (
|
|
var d = new Array(3),
|
|
e = this.alpha * (1 - c.alpha) + c.alpha,
|
|
f = 0;
|
|
f < 3;
|
|
f++
|
|
)
|
|
d[f] = this._operate(a, b, this.rgb[f], c.rgb[f]);
|
|
return new h(d, e);
|
|
}),
|
|
(h.prototype.toRGB = function () {
|
|
return e(this.rgb);
|
|
}),
|
|
(h.prototype.toHSL = function () {
|
|
var a,
|
|
b,
|
|
c = this.rgb[0] / 255,
|
|
d = this.rgb[1] / 255,
|
|
e = this.rgb[2] / 255,
|
|
f = this.alpha,
|
|
g = Math.max(c, d, e),
|
|
h = Math.min(c, d, e),
|
|
i = (g + h) / 2,
|
|
j = g - h;
|
|
if (g === h) a = b = 0;
|
|
else {
|
|
switch (((b = i > 0.5 ? j / (2 - g - h) : j / (g + h)), g)) {
|
|
case c:
|
|
a = (d - e) / j + (d < e ? 6 : 0);
|
|
break;
|
|
case d:
|
|
a = (e - c) / j + 2;
|
|
break;
|
|
case e:
|
|
a = (c - d) / j + 4;
|
|
}
|
|
a /= 6;
|
|
}
|
|
return { h: 360 * a, s: b, l: i, a: f };
|
|
}),
|
|
(h.prototype.toHSV = function () {
|
|
var a,
|
|
b,
|
|
c = this.rgb[0] / 255,
|
|
d = this.rgb[1] / 255,
|
|
e = this.rgb[2] / 255,
|
|
f = this.alpha,
|
|
g = Math.max(c, d, e),
|
|
h = Math.min(c, d, e),
|
|
i = g,
|
|
j = g - h;
|
|
if (((b = 0 === g ? 0 : j / g), g === h)) a = 0;
|
|
else {
|
|
switch (g) {
|
|
case c:
|
|
a = (d - e) / j + (d < e ? 6 : 0);
|
|
break;
|
|
case d:
|
|
a = (e - c) / j + 2;
|
|
break;
|
|
case e:
|
|
a = (c - d) / j + 4;
|
|
}
|
|
a /= 6;
|
|
}
|
|
return { h: 360 * a, s: b, v: i, a: f };
|
|
}),
|
|
(h.prototype.toARGB = function () {
|
|
return e([255 * this.alpha].concat(this.rgb));
|
|
}),
|
|
(h.prototype.compare = function (a) {
|
|
return a.rgb &&
|
|
a.rgb[0] === this.rgb[0] &&
|
|
a.rgb[1] === this.rgb[1] &&
|
|
a.rgb[2] === this.rgb[2] &&
|
|
a.alpha === this.alpha
|
|
? 0
|
|
: void 0;
|
|
}),
|
|
(h.fromKeyword = function (a) {
|
|
var b,
|
|
c = a.toLowerCase();
|
|
if (
|
|
(g.hasOwnProperty(c)
|
|
? (b = new h(g[c].slice(1)))
|
|
: 'transparent' === c && (b = new h([0, 0, 0], 0)),
|
|
b)
|
|
)
|
|
return (b.value = a), b;
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{ '../data/colors': 14, './node': 76 },
|
|
],
|
|
56: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a) {
|
|
' ' === a
|
|
? ((this.value = ' '), (this.emptyOrWhitespace = !0))
|
|
: ((this.value = a ? a.trim() : ''),
|
|
(this.emptyOrWhitespace = '' === this.value));
|
|
};
|
|
(e.prototype = new d()), (e.prototype.type = 'Combinator');
|
|
var f = { '': !0, ' ': !0, '|': !0 };
|
|
(e.prototype.genCSS = function (a, b) {
|
|
var c = a.compress || f[this.value] ? '' : ' ';
|
|
b.add(c + this.value + c);
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
57: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./debug-info'),
|
|
f = function (a, b, c, d) {
|
|
(this.value = a),
|
|
(this.isLineComment = b),
|
|
(this._index = c),
|
|
(this._fileInfo = d),
|
|
(this.allowRoot = !0);
|
|
};
|
|
(f.prototype = new d()),
|
|
(f.prototype.type = 'Comment'),
|
|
(f.prototype.genCSS = function (a, b) {
|
|
this.debugInfo &&
|
|
b.add(e(a, this), this.fileInfo(), this.getIndex()),
|
|
b.add(this.value);
|
|
}),
|
|
(f.prototype.isSilent = function (a) {
|
|
var b = a.compress && '!' !== this.value[2];
|
|
return this.isLineComment || b;
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ './debug-info': 59, './node': 76 },
|
|
],
|
|
58: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a, b, c, d, e) {
|
|
(this.op = a.trim()),
|
|
(this.lvalue = b),
|
|
(this.rvalue = c),
|
|
(this._index = d),
|
|
(this.negate = e);
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Condition'),
|
|
(e.prototype.accept = function (a) {
|
|
(this.lvalue = a.visit(this.lvalue)),
|
|
(this.rvalue = a.visit(this.rvalue));
|
|
}),
|
|
(e.prototype.eval = function (a) {
|
|
var b = (function (a, b, c) {
|
|
switch (a) {
|
|
case 'and':
|
|
return b && c;
|
|
case 'or':
|
|
return b || c;
|
|
default:
|
|
switch (d.compare(b, c)) {
|
|
case -1:
|
|
return '<' === a || '=<' === a || '<=' === a;
|
|
case 0:
|
|
return (
|
|
'=' === a || '>=' === a || '=<' === a || '<=' === a
|
|
);
|
|
case 1:
|
|
return '>' === a || '>=' === a;
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
})(this.op, this.lvalue.eval(a), this.rvalue.eval(a));
|
|
return this.negate ? !b : b;
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
59: [
|
|
function (a, b, c) {
|
|
var d = function (a, b, c) {
|
|
var e = '';
|
|
if (a.dumpLineNumbers && !a.compress)
|
|
switch (a.dumpLineNumbers) {
|
|
case 'comments':
|
|
e = d.asComment(b);
|
|
break;
|
|
case 'mediaquery':
|
|
e = d.asMediaQuery(b);
|
|
break;
|
|
case 'all':
|
|
e = d.asComment(b) + (c || '') + d.asMediaQuery(b);
|
|
}
|
|
return e;
|
|
};
|
|
(d.asComment = function (a) {
|
|
return (
|
|
'/* line ' +
|
|
a.debugInfo.lineNumber +
|
|
', ' +
|
|
a.debugInfo.fileName +
|
|
' */\n'
|
|
);
|
|
}),
|
|
(d.asMediaQuery = function (a) {
|
|
var b = a.debugInfo.fileName;
|
|
return (
|
|
/^[a-z]+:\/\//i.test(b) || (b = 'file://' + b),
|
|
'@media -sass-debug-info{filename{font-family:' +
|
|
b.replace(/([.:\/\\])/g, function (a) {
|
|
return '\\' == a && (a = '/'), '\\' + a;
|
|
}) +
|
|
'}line{font-family:\\00003' +
|
|
a.debugInfo.lineNumber +
|
|
'}}\n'
|
|
);
|
|
}),
|
|
(b.exports = d);
|
|
},
|
|
{},
|
|
],
|
|
60: [
|
|
function (a, b, c) {
|
|
function d(a, b) {
|
|
var c,
|
|
d = '',
|
|
e = b.length,
|
|
f = {
|
|
add: function (a) {
|
|
d += a;
|
|
},
|
|
};
|
|
for (c = 0; c < e; c++) b[c].eval(a).genCSS(a, f);
|
|
return d;
|
|
}
|
|
var e = a('./node'),
|
|
f = a('./value'),
|
|
g = a('./keyword'),
|
|
h = a('./anonymous'),
|
|
i = a('../constants').Math,
|
|
j = function (a, b, c, d, g, i, j, k) {
|
|
(this.name = a),
|
|
(this.value =
|
|
b instanceof e ? b : new f([b ? new h(b) : null])),
|
|
(this.important = c ? ' ' + c.trim() : ''),
|
|
(this.merge = d),
|
|
(this._index = g),
|
|
(this._fileInfo = i),
|
|
(this.inline = j || !1),
|
|
(this.variable =
|
|
void 0 !== k ? k : a.charAt && '@' === a.charAt(0)),
|
|
(this.allowRoot = !0),
|
|
this.setParent(this.value, this);
|
|
};
|
|
(j.prototype = new e()),
|
|
(j.prototype.type = 'Declaration'),
|
|
(j.prototype.genCSS = function (a, b) {
|
|
b.add(
|
|
this.name + (a.compress ? ':' : ': '),
|
|
this.fileInfo(),
|
|
this.getIndex(),
|
|
);
|
|
try {
|
|
this.value.genCSS(a, b);
|
|
} catch (c) {
|
|
throw (
|
|
((c.index = this._index),
|
|
(c.filename = this._fileInfo.filename),
|
|
c)
|
|
);
|
|
}
|
|
b.add(
|
|
this.important +
|
|
(this.inline || (a.lastRule && a.compress) ? '' : ';'),
|
|
this._fileInfo,
|
|
this._index,
|
|
);
|
|
}),
|
|
(j.prototype.eval = function (a) {
|
|
var b,
|
|
c,
|
|
e = !1,
|
|
f = this.name,
|
|
h = this.variable;
|
|
'string' != typeof f &&
|
|
((f =
|
|
1 === f.length && f[0] instanceof g ? f[0].value : d(a, f)),
|
|
(h = !1)),
|
|
'font' === f &&
|
|
a.math === i.ALWAYS &&
|
|
((e = !0), (b = a.math), (a.math = i.PARENS_DIVISION));
|
|
try {
|
|
if (
|
|
(a.importantScope.push({}),
|
|
(c = this.value.eval(a)),
|
|
!this.variable && 'DetachedRuleset' === c.type)
|
|
)
|
|
throw {
|
|
message: 'Rulesets cannot be evaluated on a property.',
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
};
|
|
var k = this.important,
|
|
l = a.importantScope.pop();
|
|
return (
|
|
!k && l.important && (k = l.important),
|
|
new j(
|
|
f,
|
|
c,
|
|
k,
|
|
this.merge,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.inline,
|
|
h,
|
|
)
|
|
);
|
|
} catch (m) {
|
|
throw (
|
|
('number' != typeof m.index &&
|
|
((m.index = this.getIndex()),
|
|
(m.filename = this.fileInfo().filename)),
|
|
m)
|
|
);
|
|
} finally {
|
|
e && (a.math = b);
|
|
}
|
|
}),
|
|
(j.prototype.makeImportant = function () {
|
|
return new j(
|
|
this.name,
|
|
this.value,
|
|
'!important',
|
|
this.merge,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.inline,
|
|
);
|
|
}),
|
|
(b.exports = j);
|
|
},
|
|
{
|
|
'../constants': 12,
|
|
'./anonymous': 50,
|
|
'./keyword': 70,
|
|
'./node': 76,
|
|
'./value': 86,
|
|
},
|
|
],
|
|
61: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('../contexts'),
|
|
f = a('../utils'),
|
|
g = function (a, b) {
|
|
(this.ruleset = a),
|
|
(this.frames = b),
|
|
this.setParent(this.ruleset, this);
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'DetachedRuleset'),
|
|
(g.prototype.evalFirst = !0),
|
|
(g.prototype.accept = function (a) {
|
|
this.ruleset = a.visit(this.ruleset);
|
|
}),
|
|
(g.prototype.eval = function (a) {
|
|
var b = this.frames || f.copyArray(a.frames);
|
|
return new g(this.ruleset, b);
|
|
}),
|
|
(g.prototype.callEval = function (a) {
|
|
return this.ruleset.eval(
|
|
this.frames ? new e.Eval(a, this.frames.concat(a.frames)) : a,
|
|
);
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ '../contexts': 13, '../utils': 89, './node': 76 },
|
|
],
|
|
62: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('../data/unit-conversions'),
|
|
f = a('./unit'),
|
|
g = a('./color'),
|
|
h = function (a, b) {
|
|
if (((this.value = parseFloat(a)), isNaN(this.value)))
|
|
throw new Error('Dimension is not a number.');
|
|
(this.unit = b && b instanceof f ? b : new f(b ? [b] : void 0)),
|
|
this.setParent(this.unit, this);
|
|
};
|
|
(h.prototype = new d()),
|
|
(h.prototype.type = 'Dimension'),
|
|
(h.prototype.accept = function (a) {
|
|
this.unit = a.visit(this.unit);
|
|
}),
|
|
(h.prototype.eval = function (a) {
|
|
return this;
|
|
}),
|
|
(h.prototype.toColor = function () {
|
|
return new g([this.value, this.value, this.value]);
|
|
}),
|
|
(h.prototype.genCSS = function (a, b) {
|
|
if (a && a.strictUnits && !this.unit.isSingular())
|
|
throw new Error(
|
|
'Multiple units in dimension. Correct the units or use the unit function. Bad unit: ' +
|
|
this.unit.toString(),
|
|
);
|
|
var c = this.fround(a, this.value),
|
|
d = String(c);
|
|
if (
|
|
(0 !== c &&
|
|
c < 1e-6 &&
|
|
c > -1e-6 &&
|
|
(d = c.toFixed(20).replace(/0+$/, '')),
|
|
a && a.compress)
|
|
) {
|
|
if (0 === c && this.unit.isLength()) return void b.add(d);
|
|
c > 0 && c < 1 && (d = d.substr(1));
|
|
}
|
|
b.add(d), this.unit.genCSS(a, b);
|
|
}),
|
|
(h.prototype.operate = function (a, b, c) {
|
|
var d = this._operate(a, b, this.value, c.value),
|
|
e = this.unit.clone();
|
|
if ('+' === b || '-' === b)
|
|
if (0 === e.numerator.length && 0 === e.denominator.length)
|
|
(e = c.unit.clone()),
|
|
this.unit.backupUnit &&
|
|
(e.backupUnit = this.unit.backupUnit);
|
|
else if (
|
|
0 === c.unit.numerator.length &&
|
|
0 === e.denominator.length
|
|
);
|
|
else {
|
|
if (
|
|
((c = c.convertTo(this.unit.usedUnits())),
|
|
a.strictUnits && c.unit.toString() !== e.toString())
|
|
)
|
|
throw new Error(
|
|
"Incompatible units. Change the units or use the unit function. Bad units: '" +
|
|
e.toString() +
|
|
"' and '" +
|
|
c.unit.toString() +
|
|
"'.",
|
|
);
|
|
d = this._operate(a, b, this.value, c.value);
|
|
}
|
|
else
|
|
'*' === b
|
|
? ((e.numerator = e.numerator
|
|
.concat(c.unit.numerator)
|
|
.sort()),
|
|
(e.denominator = e.denominator
|
|
.concat(c.unit.denominator)
|
|
.sort()),
|
|
e.cancel())
|
|
: '/' === b &&
|
|
((e.numerator = e.numerator
|
|
.concat(c.unit.denominator)
|
|
.sort()),
|
|
(e.denominator = e.denominator
|
|
.concat(c.unit.numerator)
|
|
.sort()),
|
|
e.cancel());
|
|
return new h(d, e);
|
|
}),
|
|
(h.prototype.compare = function (a) {
|
|
var b, c;
|
|
if (a instanceof h) {
|
|
if (this.unit.isEmpty() || a.unit.isEmpty())
|
|
(b = this), (c = a);
|
|
else if (
|
|
((b = this.unify()),
|
|
(c = a.unify()),
|
|
0 !== b.unit.compare(c.unit))
|
|
)
|
|
return;
|
|
return d.numericCompare(b.value, c.value);
|
|
}
|
|
}),
|
|
(h.prototype.unify = function () {
|
|
return this.convertTo({
|
|
length: 'px',
|
|
duration: 's',
|
|
angle: 'rad',
|
|
});
|
|
}),
|
|
(h.prototype.convertTo = function (a) {
|
|
var b,
|
|
c,
|
|
d,
|
|
f,
|
|
g,
|
|
i = this.value,
|
|
j = this.unit.clone(),
|
|
k = {};
|
|
if ('string' == typeof a) {
|
|
for (b in e) e[b].hasOwnProperty(a) && ((k = {}), (k[b] = a));
|
|
a = k;
|
|
}
|
|
g = function (a, b) {
|
|
return d.hasOwnProperty(a)
|
|
? (b ? (i /= d[a] / d[f]) : (i *= d[a] / d[f]), f)
|
|
: a;
|
|
};
|
|
for (c in a)
|
|
a.hasOwnProperty(c) && ((f = a[c]), (d = e[c]), j.map(g));
|
|
return j.cancel(), new h(i, j);
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{
|
|
'../data/unit-conversions': 16,
|
|
'./color': 55,
|
|
'./node': 76,
|
|
'./unit': 84,
|
|
},
|
|
],
|
|
63: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./paren'),
|
|
f = a('./combinator'),
|
|
g = function (a, b, c, d, e, g) {
|
|
(this.combinator = a instanceof f ? a : new f(a)),
|
|
(this.value = 'string' == typeof b ? b.trim() : b ? b : ''),
|
|
(this.isVariable = c),
|
|
(this._index = d),
|
|
(this._fileInfo = e),
|
|
this.copyVisibilityInfo(g),
|
|
this.setParent(this.combinator, this);
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'Element'),
|
|
(g.prototype.accept = function (a) {
|
|
var b = this.value;
|
|
(this.combinator = a.visit(this.combinator)),
|
|
'object' == typeof b && (this.value = a.visit(b));
|
|
}),
|
|
(g.prototype.eval = function (a) {
|
|
return new g(
|
|
this.combinator,
|
|
this.value.eval ? this.value.eval(a) : this.value,
|
|
this.isVariable,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.visibilityInfo(),
|
|
);
|
|
}),
|
|
(g.prototype.clone = function () {
|
|
return new g(
|
|
this.combinator,
|
|
this.value,
|
|
this.isVariable,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.visibilityInfo(),
|
|
);
|
|
}),
|
|
(g.prototype.genCSS = function (a, b) {
|
|
b.add(this.toCSS(a), this.fileInfo(), this.getIndex());
|
|
}),
|
|
(g.prototype.toCSS = function (a) {
|
|
a = a || {};
|
|
var b = this.value,
|
|
c = a.firstSelector;
|
|
return (
|
|
b instanceof e && (a.firstSelector = !0),
|
|
(b = b.toCSS ? b.toCSS(a) : b),
|
|
(a.firstSelector = c),
|
|
'' === b && '&' === this.combinator.value.charAt(0)
|
|
? ''
|
|
: this.combinator.toCSS(a) + b
|
|
);
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ './combinator': 56, './node': 76, './paren': 78 },
|
|
],
|
|
64: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./paren'),
|
|
f = a('./comment'),
|
|
g = a('./dimension'),
|
|
h = a('../constants').Math,
|
|
i = function (a, b) {
|
|
if (((this.value = a), (this.noSpacing = b), !a))
|
|
throw new Error('Expression requires an array parameter');
|
|
};
|
|
(i.prototype = new d()),
|
|
(i.prototype.type = 'Expression'),
|
|
(i.prototype.accept = function (a) {
|
|
this.value = a.visitArray(this.value);
|
|
}),
|
|
(i.prototype.eval = function (a) {
|
|
var b,
|
|
c = a.isMathOn(),
|
|
d =
|
|
this.parens &&
|
|
(a.math !== h.STRICT_LEGACY || !this.parensInOp),
|
|
f = !1;
|
|
return (
|
|
d && a.inParenthesis(),
|
|
this.value.length > 1
|
|
? (b = new i(
|
|
this.value.map(function (b) {
|
|
return b.eval ? b.eval(a) : b;
|
|
}),
|
|
this.noSpacing,
|
|
))
|
|
: 1 === this.value.length
|
|
? (!this.value[0].parens ||
|
|
this.value[0].parensInOp ||
|
|
a.inCalc ||
|
|
(f = !0),
|
|
(b = this.value[0].eval(a)))
|
|
: (b = this),
|
|
d && a.outOfParenthesis(),
|
|
!this.parens ||
|
|
!this.parensInOp ||
|
|
c ||
|
|
f ||
|
|
b instanceof g ||
|
|
(b = new e(b)),
|
|
b
|
|
);
|
|
}),
|
|
(i.prototype.genCSS = function (a, b) {
|
|
for (var c = 0; c < this.value.length; c++)
|
|
this.value[c].genCSS(a, b),
|
|
!this.noSpacing && c + 1 < this.value.length && b.add(' ');
|
|
}),
|
|
(i.prototype.throwAwayComments = function () {
|
|
this.value = this.value.filter(function (a) {
|
|
return !(a instanceof f);
|
|
});
|
|
}),
|
|
(b.exports = i);
|
|
},
|
|
{
|
|
'../constants': 12,
|
|
'./comment': 57,
|
|
'./dimension': 62,
|
|
'./node': 76,
|
|
'./paren': 78,
|
|
},
|
|
],
|
|
65: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./selector'),
|
|
f = function g(a, b, c, d, e) {
|
|
switch (
|
|
((this.selector = a),
|
|
(this.option = b),
|
|
(this.object_id = g.next_id++),
|
|
(this.parent_ids = [this.object_id]),
|
|
(this._index = c),
|
|
(this._fileInfo = d),
|
|
this.copyVisibilityInfo(e),
|
|
(this.allowRoot = !0),
|
|
b)
|
|
) {
|
|
case 'all':
|
|
(this.allowBefore = !0), (this.allowAfter = !0);
|
|
break;
|
|
default:
|
|
(this.allowBefore = !1), (this.allowAfter = !1);
|
|
}
|
|
this.setParent(this.selector, this);
|
|
};
|
|
(f.next_id = 0),
|
|
(f.prototype = new d()),
|
|
(f.prototype.type = 'Extend'),
|
|
(f.prototype.accept = function (a) {
|
|
this.selector = a.visit(this.selector);
|
|
}),
|
|
(f.prototype.eval = function (a) {
|
|
return new f(
|
|
this.selector.eval(a),
|
|
this.option,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.visibilityInfo(),
|
|
);
|
|
}),
|
|
(f.prototype.clone = function (a) {
|
|
return new f(
|
|
this.selector,
|
|
this.option,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.visibilityInfo(),
|
|
);
|
|
}),
|
|
(f.prototype.findSelfSelectors = function (a) {
|
|
var b,
|
|
c,
|
|
d = [];
|
|
for (b = 0; b < a.length; b++)
|
|
(c = a[b].elements),
|
|
b > 0 &&
|
|
c.length &&
|
|
'' === c[0].combinator.value &&
|
|
(c[0].combinator.value = ' '),
|
|
(d = d.concat(a[b].elements));
|
|
(this.selfSelectors = [new e(d)]),
|
|
this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ './node': 76, './selector': 82 },
|
|
],
|
|
66: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./media'),
|
|
f = a('./url'),
|
|
g = a('./quoted'),
|
|
h = a('./ruleset'),
|
|
i = a('./anonymous'),
|
|
j = a('../utils'),
|
|
k = a('../less-error'),
|
|
l = function (a, b, c, d, e, f) {
|
|
if (
|
|
((this.options = c),
|
|
(this._index = d),
|
|
(this._fileInfo = e),
|
|
(this.path = a),
|
|
(this.features = b),
|
|
(this.allowRoot = !0),
|
|
void 0 !== this.options.less || this.options.inline)
|
|
)
|
|
this.css = !this.options.less || this.options.inline;
|
|
else {
|
|
var g = this.getPath();
|
|
g && /[#\.\&\?]css([\?;].*)?$/.test(g) && (this.css = !0);
|
|
}
|
|
this.copyVisibilityInfo(f),
|
|
this.setParent(this.features, this),
|
|
this.setParent(this.path, this);
|
|
};
|
|
(l.prototype = new d()),
|
|
(l.prototype.type = 'Import'),
|
|
(l.prototype.accept = function (a) {
|
|
this.features && (this.features = a.visit(this.features)),
|
|
(this.path = a.visit(this.path)),
|
|
this.options.isPlugin ||
|
|
this.options.inline ||
|
|
!this.root ||
|
|
(this.root = a.visit(this.root));
|
|
}),
|
|
(l.prototype.genCSS = function (a, b) {
|
|
this.css &&
|
|
void 0 === this.path._fileInfo.reference &&
|
|
(b.add('@import ', this._fileInfo, this._index),
|
|
this.path.genCSS(a, b),
|
|
this.features && (b.add(' '), this.features.genCSS(a, b)),
|
|
b.add(';'));
|
|
}),
|
|
(l.prototype.getPath = function () {
|
|
return this.path instanceof f
|
|
? this.path.value.value
|
|
: this.path.value;
|
|
}),
|
|
(l.prototype.isVariableImport = function () {
|
|
var a = this.path;
|
|
return (
|
|
a instanceof f && (a = a.value),
|
|
!(a instanceof g) || a.containsVariables()
|
|
);
|
|
}),
|
|
(l.prototype.evalForImport = function (a) {
|
|
var b = this.path;
|
|
return (
|
|
b instanceof f && (b = b.value),
|
|
new l(
|
|
b.eval(a),
|
|
this.features,
|
|
this.options,
|
|
this._index,
|
|
this._fileInfo,
|
|
this.visibilityInfo(),
|
|
)
|
|
);
|
|
}),
|
|
(l.prototype.evalPath = function (a) {
|
|
var b = this.path.eval(a),
|
|
c = this._fileInfo;
|
|
if (!(b instanceof f)) {
|
|
var d = b.value;
|
|
b.value =
|
|
c && d && a.pathRequiresRewrite(d)
|
|
? a.rewritePath(d, c.rootpath)
|
|
: a.normalizePath(b.value);
|
|
}
|
|
return b;
|
|
}),
|
|
(l.prototype.eval = function (a) {
|
|
var b = this.doEval(a);
|
|
return (
|
|
(this.options.reference || this.blocksVisibility()) &&
|
|
(b.length || 0 === b.length
|
|
? b.forEach(function (a) {
|
|
a.addVisibilityBlock();
|
|
})
|
|
: b.addVisibilityBlock()),
|
|
b
|
|
);
|
|
}),
|
|
(l.prototype.doEval = function (a) {
|
|
var b,
|
|
c,
|
|
d = this.features && this.features.eval(a);
|
|
if (this.options.isPlugin) {
|
|
if (this.root && this.root.eval)
|
|
try {
|
|
this.root.eval(a);
|
|
} catch (f) {
|
|
throw (
|
|
((f.message = 'Plugin error during evaluation'),
|
|
new k(f, this.root.imports, this.root.filename))
|
|
);
|
|
}
|
|
return (
|
|
(c = a.frames[0] && a.frames[0].functionRegistry),
|
|
c &&
|
|
this.root &&
|
|
this.root.functions &&
|
|
c.addMultiple(this.root.functions),
|
|
[]
|
|
);
|
|
}
|
|
if (
|
|
this.skip &&
|
|
('function' == typeof this.skip && (this.skip = this.skip()),
|
|
this.skip)
|
|
)
|
|
return [];
|
|
if (this.options.inline) {
|
|
var g = new i(
|
|
this.root,
|
|
0,
|
|
{
|
|
filename: this.importedFilename,
|
|
reference:
|
|
this.path._fileInfo && this.path._fileInfo.reference,
|
|
},
|
|
!0,
|
|
!0,
|
|
);
|
|
return this.features ? new e([g], this.features.value) : [g];
|
|
}
|
|
if (this.css) {
|
|
var m = new l(this.evalPath(a), d, this.options, this._index);
|
|
if (!m.css && this.error) throw this.error;
|
|
return m;
|
|
}
|
|
return (
|
|
(b = new h(null, j.copyArray(this.root.rules))),
|
|
b.evalImports(a),
|
|
this.features ? new e(b.rules, this.features.value) : b.rules
|
|
);
|
|
}),
|
|
(b.exports = l);
|
|
},
|
|
{
|
|
'../less-error': 38,
|
|
'../utils': 89,
|
|
'./anonymous': 50,
|
|
'./media': 71,
|
|
'./node': 76,
|
|
'./quoted': 80,
|
|
'./ruleset': 81,
|
|
'./url': 85,
|
|
},
|
|
],
|
|
67: [
|
|
function (a, b, c) {
|
|
var d = Object.create(null);
|
|
(d.Node = a('./node')),
|
|
(d.Color = a('./color')),
|
|
(d.AtRule = a('./atrule')),
|
|
(d.DetachedRuleset = a('./detached-ruleset')),
|
|
(d.Operation = a('./operation')),
|
|
(d.Dimension = a('./dimension')),
|
|
(d.Unit = a('./unit')),
|
|
(d.Keyword = a('./keyword')),
|
|
(d.Variable = a('./variable')),
|
|
(d.Property = a('./property')),
|
|
(d.Ruleset = a('./ruleset')),
|
|
(d.Element = a('./element')),
|
|
(d.Attribute = a('./attribute')),
|
|
(d.Combinator = a('./combinator')),
|
|
(d.Selector = a('./selector')),
|
|
(d.Quoted = a('./quoted')),
|
|
(d.Expression = a('./expression')),
|
|
(d.Declaration = a('./declaration')),
|
|
(d.Call = a('./call')),
|
|
(d.URL = a('./url')),
|
|
(d.Import = a('./import')),
|
|
(d.mixin = {
|
|
Call: a('./mixin-call'),
|
|
Definition: a('./mixin-definition'),
|
|
}),
|
|
(d.Comment = a('./comment')),
|
|
(d.Anonymous = a('./anonymous')),
|
|
(d.Value = a('./value')),
|
|
(d.JavaScript = a('./javascript')),
|
|
(d.Assignment = a('./assignment')),
|
|
(d.Condition = a('./condition')),
|
|
(d.Paren = a('./paren')),
|
|
(d.Media = a('./media')),
|
|
(d.UnicodeDescriptor = a('./unicode-descriptor')),
|
|
(d.Negative = a('./negative')),
|
|
(d.Extend = a('./extend')),
|
|
(d.VariableCall = a('./variable-call')),
|
|
(d.NamespaceValue = a('./namespace-value')),
|
|
(b.exports = d);
|
|
},
|
|
{
|
|
'./anonymous': 50,
|
|
'./assignment': 51,
|
|
'./atrule': 52,
|
|
'./attribute': 53,
|
|
'./call': 54,
|
|
'./color': 55,
|
|
'./combinator': 56,
|
|
'./comment': 57,
|
|
'./condition': 58,
|
|
'./declaration': 60,
|
|
'./detached-ruleset': 61,
|
|
'./dimension': 62,
|
|
'./element': 63,
|
|
'./expression': 64,
|
|
'./extend': 65,
|
|
'./import': 66,
|
|
'./javascript': 68,
|
|
'./keyword': 70,
|
|
'./media': 71,
|
|
'./mixin-call': 72,
|
|
'./mixin-definition': 73,
|
|
'./namespace-value': 74,
|
|
'./negative': 75,
|
|
'./node': 76,
|
|
'./operation': 77,
|
|
'./paren': 78,
|
|
'./property': 79,
|
|
'./quoted': 80,
|
|
'./ruleset': 81,
|
|
'./selector': 82,
|
|
'./unicode-descriptor': 83,
|
|
'./unit': 84,
|
|
'./url': 85,
|
|
'./value': 86,
|
|
'./variable': 88,
|
|
'./variable-call': 87,
|
|
},
|
|
],
|
|
68: [
|
|
function (a, b, c) {
|
|
var d = a('./js-eval-node'),
|
|
e = a('./dimension'),
|
|
f = a('./quoted'),
|
|
g = a('./anonymous'),
|
|
h = function (a, b, c, d) {
|
|
(this.escaped = b),
|
|
(this.expression = a),
|
|
(this._index = c),
|
|
(this._fileInfo = d);
|
|
};
|
|
(h.prototype = new d()),
|
|
(h.prototype.type = 'JavaScript'),
|
|
(h.prototype.eval = function (a) {
|
|
var b = this.evaluateJavaScript(this.expression, a),
|
|
c = typeof b;
|
|
return 'number' !== c || isNaN(b)
|
|
? 'string' === c
|
|
? new f('"' + b + '"', b, this.escaped, this._index)
|
|
: new g(Array.isArray(b) ? b.join(', ') : b)
|
|
: new e(b);
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{
|
|
'./anonymous': 50,
|
|
'./dimension': 62,
|
|
'./js-eval-node': 69,
|
|
'./quoted': 80,
|
|
},
|
|
],
|
|
69: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./variable'),
|
|
f = function () {};
|
|
(f.prototype = new d()),
|
|
(f.prototype.evaluateJavaScript = function (a, b) {
|
|
var c,
|
|
d = this,
|
|
f = {};
|
|
if (!b.javascriptEnabled)
|
|
throw {
|
|
message:
|
|
'Inline JavaScript is not enabled. Is it set in your options?',
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
a = a.replace(/@\{([\w-]+)\}/g, function (a, c) {
|
|
return d.jsify(
|
|
new e('@' + c, d.getIndex(), d.fileInfo()).eval(b),
|
|
);
|
|
});
|
|
try {
|
|
a = new Function('return (' + a + ')');
|
|
} catch (g) {
|
|
throw {
|
|
message:
|
|
'JavaScript evaluation error: ' +
|
|
g.message +
|
|
' from `' +
|
|
a +
|
|
'`',
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
}
|
|
var h = b.frames[0].variables();
|
|
for (var i in h)
|
|
h.hasOwnProperty(i) &&
|
|
(f[i.slice(1)] = {
|
|
value: h[i].value,
|
|
toJS: function () {
|
|
return this.value.eval(b).toCSS();
|
|
},
|
|
});
|
|
try {
|
|
c = a.call(f);
|
|
} catch (g) {
|
|
throw {
|
|
message:
|
|
"JavaScript evaluation error: '" +
|
|
g.name +
|
|
': ' +
|
|
g.message.replace(/["]/g, "'") +
|
|
"'",
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
}
|
|
return c;
|
|
}),
|
|
(f.prototype.jsify = function (a) {
|
|
return Array.isArray(a.value) && a.value.length > 1
|
|
? '[' +
|
|
a.value
|
|
.map(function (a) {
|
|
return a.toCSS();
|
|
})
|
|
.join(', ') +
|
|
']'
|
|
: a.toCSS();
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ './node': 76, './variable': 88 },
|
|
],
|
|
70: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a) {
|
|
this.value = a;
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Keyword'),
|
|
(e.prototype.genCSS = function (a, b) {
|
|
if ('%' === this.value)
|
|
throw { type: 'Syntax', message: 'Invalid % without number' };
|
|
b.add(this.value);
|
|
}),
|
|
(e.True = new e('true')),
|
|
(e.False = new e('false')),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
71: [
|
|
function (a, b, c) {
|
|
var d = a('./ruleset'),
|
|
e = a('./value'),
|
|
f = a('./selector'),
|
|
g = a('./anonymous'),
|
|
h = a('./expression'),
|
|
i = a('./atrule'),
|
|
j = a('../utils'),
|
|
k = function (a, b, c, g, h) {
|
|
(this._index = c), (this._fileInfo = g);
|
|
var i = new f(
|
|
[],
|
|
null,
|
|
null,
|
|
this._index,
|
|
this._fileInfo,
|
|
).createEmptySelectors();
|
|
(this.features = new e(b)),
|
|
(this.rules = [new d(i, a)]),
|
|
(this.rules[0].allowImports = !0),
|
|
this.copyVisibilityInfo(h),
|
|
(this.allowRoot = !0),
|
|
this.setParent(i, this),
|
|
this.setParent(this.features, this),
|
|
this.setParent(this.rules, this);
|
|
};
|
|
(k.prototype = new i()),
|
|
(k.prototype.type = 'Media'),
|
|
(k.prototype.isRulesetLike = function () {
|
|
return !0;
|
|
}),
|
|
(k.prototype.accept = function (a) {
|
|
this.features && (this.features = a.visit(this.features)),
|
|
this.rules && (this.rules = a.visitArray(this.rules));
|
|
}),
|
|
(k.prototype.genCSS = function (a, b) {
|
|
b.add('@media ', this._fileInfo, this._index),
|
|
this.features.genCSS(a, b),
|
|
this.outputRuleset(a, b, this.rules);
|
|
}),
|
|
(k.prototype.eval = function (a) {
|
|
a.mediaBlocks || ((a.mediaBlocks = []), (a.mediaPath = []));
|
|
var b = new k(
|
|
null,
|
|
[],
|
|
this._index,
|
|
this._fileInfo,
|
|
this.visibilityInfo(),
|
|
);
|
|
return (
|
|
this.debugInfo &&
|
|
((this.rules[0].debugInfo = this.debugInfo),
|
|
(b.debugInfo = this.debugInfo)),
|
|
(b.features = this.features.eval(a)),
|
|
a.mediaPath.push(b),
|
|
a.mediaBlocks.push(b),
|
|
(this.rules[0].functionRegistry =
|
|
a.frames[0].functionRegistry.inherit()),
|
|
a.frames.unshift(this.rules[0]),
|
|
(b.rules = [this.rules[0].eval(a)]),
|
|
a.frames.shift(),
|
|
a.mediaPath.pop(),
|
|
0 === a.mediaPath.length ? b.evalTop(a) : b.evalNested(a)
|
|
);
|
|
}),
|
|
(k.prototype.evalTop = function (a) {
|
|
var b = this;
|
|
if (a.mediaBlocks.length > 1) {
|
|
var c = new f(
|
|
[],
|
|
null,
|
|
null,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
).createEmptySelectors();
|
|
(b = new d(c, a.mediaBlocks)),
|
|
(b.multiMedia = !0),
|
|
b.copyVisibilityInfo(this.visibilityInfo()),
|
|
this.setParent(b, this);
|
|
}
|
|
return delete a.mediaBlocks, delete a.mediaPath, b;
|
|
}),
|
|
(k.prototype.evalNested = function (a) {
|
|
var b,
|
|
c,
|
|
f = a.mediaPath.concat([this]);
|
|
for (b = 0; b < f.length; b++)
|
|
(c =
|
|
f[b].features instanceof e
|
|
? f[b].features.value
|
|
: f[b].features),
|
|
(f[b] = Array.isArray(c) ? c : [c]);
|
|
return (
|
|
(this.features = new e(
|
|
this.permute(f).map(function (a) {
|
|
for (
|
|
a = a.map(function (a) {
|
|
return a.toCSS ? a : new g(a);
|
|
}),
|
|
b = a.length - 1;
|
|
b > 0;
|
|
b--
|
|
)
|
|
a.splice(b, 0, new g('and'));
|
|
return new h(a);
|
|
}),
|
|
)),
|
|
this.setParent(this.features, this),
|
|
new d([], [])
|
|
);
|
|
}),
|
|
(k.prototype.permute = function (a) {
|
|
if (0 === a.length) return [];
|
|
if (1 === a.length) return a[0];
|
|
for (
|
|
var b = [], c = this.permute(a.slice(1)), d = 0;
|
|
d < c.length;
|
|
d++
|
|
)
|
|
for (var e = 0; e < a[0].length; e++)
|
|
b.push([a[0][e]].concat(c[d]));
|
|
return b;
|
|
}),
|
|
(k.prototype.bubbleSelectors = function (a) {
|
|
a &&
|
|
((this.rules = [new d(j.copyArray(a), [this.rules[0]])]),
|
|
this.setParent(this.rules, this));
|
|
}),
|
|
(b.exports = k);
|
|
},
|
|
{
|
|
'../utils': 89,
|
|
'./anonymous': 50,
|
|
'./atrule': 52,
|
|
'./expression': 64,
|
|
'./ruleset': 81,
|
|
'./selector': 82,
|
|
'./value': 86,
|
|
},
|
|
],
|
|
72: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./selector'),
|
|
f = a('./mixin-definition'),
|
|
g = a('../functions/default'),
|
|
h = function (a, b, c, d, f) {
|
|
(this.selector = new e(a)),
|
|
(this.arguments = b || []),
|
|
(this._index = c),
|
|
(this._fileInfo = d),
|
|
(this.important = f),
|
|
(this.allowRoot = !0),
|
|
this.setParent(this.selector, this);
|
|
};
|
|
(h.prototype = new d()),
|
|
(h.prototype.type = 'MixinCall'),
|
|
(h.prototype.accept = function (a) {
|
|
this.selector && (this.selector = a.visit(this.selector)),
|
|
this.arguments.length &&
|
|
(this.arguments = a.visitArray(this.arguments));
|
|
}),
|
|
(h.prototype.eval = function (a) {
|
|
function b(b, c) {
|
|
var d, e, f;
|
|
for (d = 0; d < 2; d++) {
|
|
for (x[d] = !0, g.value(d), e = 0; e < c.length && x[d]; e++)
|
|
(f = c[e]),
|
|
f.matchCondition &&
|
|
(x[d] = x[d] && f.matchCondition(null, a));
|
|
b.matchCondition && (x[d] = x[d] && b.matchCondition(t, a));
|
|
}
|
|
return x[0] || x[1] ? (x[0] != x[1] ? (x[1] ? A : B) : z) : y;
|
|
}
|
|
var c,
|
|
d,
|
|
e,
|
|
h,
|
|
i,
|
|
j,
|
|
k,
|
|
l,
|
|
m,
|
|
n,
|
|
o,
|
|
p,
|
|
q,
|
|
r,
|
|
s,
|
|
t = [],
|
|
u = [],
|
|
v = !1,
|
|
w = [],
|
|
x = [],
|
|
y = -1,
|
|
z = 0,
|
|
A = 1,
|
|
B = 2;
|
|
for (
|
|
this.selector = this.selector.eval(a), j = 0;
|
|
j < this.arguments.length;
|
|
j++
|
|
)
|
|
if (
|
|
((h = this.arguments[j]),
|
|
(i = h.value.eval(a)),
|
|
h.expand && Array.isArray(i.value))
|
|
)
|
|
for (i = i.value, k = 0; k < i.length; k++)
|
|
t.push({ value: i[k] });
|
|
else t.push({ name: h.name, value: i });
|
|
for (
|
|
s = function (b) {
|
|
return b.matchArgs(null, a);
|
|
},
|
|
j = 0;
|
|
j < a.frames.length;
|
|
j++
|
|
)
|
|
if ((c = a.frames[j].find(this.selector, null, s)).length > 0) {
|
|
for (n = !0, k = 0; k < c.length; k++) {
|
|
for (
|
|
d = c[k].rule, e = c[k].path, m = !1, l = 0;
|
|
l < a.frames.length;
|
|
l++
|
|
)
|
|
if (
|
|
!(d instanceof f) &&
|
|
d === (a.frames[l].originalRuleset || a.frames[l])
|
|
) {
|
|
m = !0;
|
|
break;
|
|
}
|
|
m ||
|
|
(d.matchArgs(t, a) &&
|
|
((o = { mixin: d, group: b(d, e) }),
|
|
o.group !== y && w.push(o),
|
|
(v = !0)));
|
|
}
|
|
for (g.reset(), q = [0, 0, 0], k = 0; k < w.length; k++)
|
|
q[w[k].group]++;
|
|
if (q[z] > 0) p = B;
|
|
else if (((p = A), q[A] + q[B] > 1))
|
|
throw {
|
|
type: 'Runtime',
|
|
message:
|
|
'Ambiguous use of `default()` found when matching for `' +
|
|
this.format(t) +
|
|
'`',
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
};
|
|
for (k = 0; k < w.length; k++)
|
|
if (((o = w[k].group), o === z || o === p))
|
|
try {
|
|
(d = w[k].mixin),
|
|
d instanceof f ||
|
|
((r = d.originalRuleset || d),
|
|
(d = new f(
|
|
'',
|
|
[],
|
|
d.rules,
|
|
null,
|
|
!1,
|
|
null,
|
|
r.visibilityInfo(),
|
|
)),
|
|
(d.originalRuleset = r));
|
|
var C = d.evalCall(a, t, this.important).rules;
|
|
this._setVisibilityToReplacement(C),
|
|
Array.prototype.push.apply(u, C);
|
|
} catch (D) {
|
|
throw {
|
|
message: D.message,
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
stack: D.stack,
|
|
};
|
|
}
|
|
if (v) return u;
|
|
}
|
|
throw n
|
|
? {
|
|
type: 'Runtime',
|
|
message:
|
|
'No matching definition was found for `' +
|
|
this.format(t) +
|
|
'`',
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
}
|
|
: {
|
|
type: 'Name',
|
|
message: this.selector.toCSS().trim() + ' is undefined',
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
};
|
|
}),
|
|
(h.prototype._setVisibilityToReplacement = function (a) {
|
|
var b, c;
|
|
if (this.blocksVisibility())
|
|
for (b = 0; b < a.length; b++)
|
|
(c = a[b]), c.addVisibilityBlock();
|
|
}),
|
|
(h.prototype.format = function (a) {
|
|
return (
|
|
this.selector.toCSS().trim() +
|
|
'(' +
|
|
(a
|
|
? a
|
|
.map(function (a) {
|
|
var b = '';
|
|
return (
|
|
a.name && (b += a.name + ':'),
|
|
(b += a.value.toCSS ? a.value.toCSS() : '???')
|
|
);
|
|
})
|
|
.join(', ')
|
|
: '') +
|
|
')'
|
|
);
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{
|
|
'../functions/default': 25,
|
|
'./mixin-definition': 73,
|
|
'./node': 76,
|
|
'./selector': 82,
|
|
},
|
|
],
|
|
73: [
|
|
function (a, b, c) {
|
|
var d = a('./selector'),
|
|
e = a('./element'),
|
|
f = a('./ruleset'),
|
|
g = a('./declaration'),
|
|
h = a('./detached-ruleset'),
|
|
i = a('./expression'),
|
|
j = a('../contexts'),
|
|
k = a('../utils'),
|
|
l = function (a, b, c, f, g, h, i) {
|
|
(this.name = a || 'anonymous mixin'),
|
|
(this.selectors = [
|
|
new d([new e(null, a, !1, this._index, this._fileInfo)]),
|
|
]),
|
|
(this.params = b),
|
|
(this.condition = f),
|
|
(this.variadic = g),
|
|
(this.arity = b.length),
|
|
(this.rules = c),
|
|
(this._lookups = {});
|
|
var j = [];
|
|
(this.required = b.reduce(function (a, b) {
|
|
return !b.name || (b.name && !b.value)
|
|
? a + 1
|
|
: (j.push(b.name), a);
|
|
}, 0)),
|
|
(this.optionalParameters = j),
|
|
(this.frames = h),
|
|
this.copyVisibilityInfo(i),
|
|
(this.allowRoot = !0);
|
|
};
|
|
(l.prototype = new f()),
|
|
(l.prototype.type = 'MixinDefinition'),
|
|
(l.prototype.evalFirst = !0),
|
|
(l.prototype.accept = function (a) {
|
|
this.params &&
|
|
this.params.length &&
|
|
(this.params = a.visitArray(this.params)),
|
|
(this.rules = a.visitArray(this.rules)),
|
|
this.condition && (this.condition = a.visit(this.condition));
|
|
}),
|
|
(l.prototype.evalParams = function (a, b, c, d) {
|
|
var e,
|
|
l,
|
|
m,
|
|
n,
|
|
o,
|
|
p,
|
|
q,
|
|
r,
|
|
s = new f(null, null),
|
|
t = k.copyArray(this.params),
|
|
u = 0;
|
|
if (
|
|
(b.frames &&
|
|
b.frames[0] &&
|
|
b.frames[0].functionRegistry &&
|
|
(s.functionRegistry = b.frames[0].functionRegistry.inherit()),
|
|
(b = new j.Eval(b, [s].concat(b.frames))),
|
|
c)
|
|
)
|
|
for (c = k.copyArray(c), u = c.length, m = 0; m < u; m++)
|
|
if (((l = c[m]), (p = l && l.name))) {
|
|
for (q = !1, n = 0; n < t.length; n++)
|
|
if (!d[n] && p === t[n].name) {
|
|
(d[n] = l.value.eval(a)),
|
|
s.prependRule(new g(p, l.value.eval(a))),
|
|
(q = !0);
|
|
break;
|
|
}
|
|
if (q) {
|
|
c.splice(m, 1), m--;
|
|
continue;
|
|
}
|
|
throw {
|
|
type: 'Runtime',
|
|
message:
|
|
'Named argument for ' +
|
|
this.name +
|
|
' ' +
|
|
c[m].name +
|
|
' not found',
|
|
};
|
|
}
|
|
for (r = 0, m = 0; m < t.length; m++)
|
|
if (!d[m]) {
|
|
if (((l = c && c[r]), (p = t[m].name)))
|
|
if (t[m].variadic) {
|
|
for (e = [], n = r; n < u; n++)
|
|
e.push(c[n].value.eval(a));
|
|
s.prependRule(new g(p, new i(e).eval(a)));
|
|
} else {
|
|
if ((o = l && l.value))
|
|
o = Array.isArray(o) ? new h(new f('', o)) : o.eval(a);
|
|
else {
|
|
if (!t[m].value)
|
|
throw {
|
|
type: 'Runtime',
|
|
message:
|
|
'wrong number of arguments for ' +
|
|
this.name +
|
|
' (' +
|
|
u +
|
|
' for ' +
|
|
this.arity +
|
|
')',
|
|
};
|
|
(o = t[m].value.eval(b)), s.resetCache();
|
|
}
|
|
s.prependRule(new g(p, o)), (d[m] = o);
|
|
}
|
|
if (t[m].variadic && c)
|
|
for (n = r; n < u; n++) d[n] = c[n].value.eval(a);
|
|
r++;
|
|
}
|
|
return s;
|
|
}),
|
|
(l.prototype.makeImportant = function () {
|
|
var a = this.rules
|
|
? this.rules.map(function (a) {
|
|
return a.makeImportant ? a.makeImportant(!0) : a;
|
|
})
|
|
: this.rules,
|
|
b = new l(
|
|
this.name,
|
|
this.params,
|
|
a,
|
|
this.condition,
|
|
this.variadic,
|
|
this.frames,
|
|
);
|
|
return b;
|
|
}),
|
|
(l.prototype.eval = function (a) {
|
|
return new l(
|
|
this.name,
|
|
this.params,
|
|
this.rules,
|
|
this.condition,
|
|
this.variadic,
|
|
this.frames || k.copyArray(a.frames),
|
|
);
|
|
}),
|
|
(l.prototype.evalCall = function (a, b, c) {
|
|
var d,
|
|
e,
|
|
h = [],
|
|
l = this.frames ? this.frames.concat(a.frames) : a.frames,
|
|
m = this.evalParams(a, new j.Eval(a, l), b, h);
|
|
return (
|
|
m.prependRule(new g('@arguments', new i(h).eval(a))),
|
|
(d = k.copyArray(this.rules)),
|
|
(e = new f(null, d)),
|
|
(e.originalRuleset = this),
|
|
(e = e.eval(new j.Eval(a, [this, m].concat(l)))),
|
|
c && (e = e.makeImportant()),
|
|
e
|
|
);
|
|
}),
|
|
(l.prototype.matchCondition = function (a, b) {
|
|
return !(
|
|
this.condition &&
|
|
!this.condition.eval(
|
|
new j.Eval(
|
|
b,
|
|
[
|
|
this.evalParams(
|
|
b,
|
|
new j.Eval(
|
|
b,
|
|
this.frames ? this.frames.concat(b.frames) : b.frames,
|
|
),
|
|
a,
|
|
[],
|
|
),
|
|
]
|
|
.concat(this.frames || [])
|
|
.concat(b.frames),
|
|
),
|
|
)
|
|
);
|
|
}),
|
|
(l.prototype.matchArgs = function (a, b) {
|
|
var c,
|
|
d = (a && a.length) || 0,
|
|
e = this.optionalParameters,
|
|
f = a
|
|
? a.reduce(function (a, b) {
|
|
return e.indexOf(b.name) < 0 ? a + 1 : a;
|
|
}, 0)
|
|
: 0;
|
|
if (this.variadic) {
|
|
if (f < this.required - 1) return !1;
|
|
} else {
|
|
if (f < this.required) return !1;
|
|
if (d > this.params.length) return !1;
|
|
}
|
|
c = Math.min(f, this.arity);
|
|
for (var g = 0; g < c; g++)
|
|
if (
|
|
!this.params[g].name &&
|
|
!this.params[g].variadic &&
|
|
a[g].value.eval(b).toCSS() !=
|
|
this.params[g].value.eval(b).toCSS()
|
|
)
|
|
return !1;
|
|
return !0;
|
|
}),
|
|
(b.exports = l);
|
|
},
|
|
{
|
|
'../contexts': 13,
|
|
'../utils': 89,
|
|
'./declaration': 60,
|
|
'./detached-ruleset': 61,
|
|
'./element': 63,
|
|
'./expression': 64,
|
|
'./ruleset': 81,
|
|
'./selector': 82,
|
|
},
|
|
],
|
|
74: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./variable'),
|
|
f = a('./ruleset'),
|
|
g = a('./selector'),
|
|
h = function (a, b, c, d, e) {
|
|
(this.value = a),
|
|
(this.lookups = b),
|
|
(this.important = c),
|
|
(this._index = d),
|
|
(this._fileInfo = e);
|
|
};
|
|
(h.prototype = new d()),
|
|
(h.prototype.type = 'NamespaceValue'),
|
|
(h.prototype.eval = function (a) {
|
|
var b,
|
|
c,
|
|
d = this.value.eval(a);
|
|
for (b = 0; b < this.lookups.length; b++) {
|
|
if (
|
|
((c = this.lookups[b]),
|
|
Array.isArray(d) && (d = new f([new g()], d)),
|
|
'' === c)
|
|
)
|
|
d = d.lastDeclaration();
|
|
else if ('@' === c.charAt(0)) {
|
|
if (
|
|
('@' === c.charAt(1) &&
|
|
(c = '@' + new e(c.substr(1)).eval(a).value),
|
|
d.variables && (d = d.variable(c)),
|
|
!d)
|
|
)
|
|
throw {
|
|
type: 'Name',
|
|
message: 'variable ' + c + ' not found',
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
} else {
|
|
if (
|
|
((c =
|
|
'$@' === c.substring(0, 2)
|
|
? '$' + new e(c.substr(1)).eval(a).value
|
|
: '$' === c.charAt(0)
|
|
? c
|
|
: '$' + c),
|
|
d.properties && (d = d.property(c)),
|
|
!d)
|
|
)
|
|
throw {
|
|
type: 'Name',
|
|
message: 'property "' + c.substr(1) + '" not found',
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
d = d[d.length - 1];
|
|
}
|
|
d.value && (d = d.eval(a).value),
|
|
d.ruleset && (d = d.ruleset.eval(a));
|
|
}
|
|
return d;
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{ './node': 76, './ruleset': 81, './selector': 82, './variable': 88 },
|
|
],
|
|
75: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./operation'),
|
|
f = a('./dimension'),
|
|
g = function (a) {
|
|
this.value = a;
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'Negative'),
|
|
(g.prototype.genCSS = function (a, b) {
|
|
b.add('-'), this.value.genCSS(a, b);
|
|
}),
|
|
(g.prototype.eval = function (a) {
|
|
return a.isMathOn()
|
|
? new e('*', [new f(-1), this.value]).eval(a)
|
|
: new g(this.value.eval(a));
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ './dimension': 62, './node': 76, './operation': 77 },
|
|
],
|
|
76: [
|
|
function (a, b, c) {
|
|
var d = function () {
|
|
(this.parent = null),
|
|
(this.visibilityBlocks = void 0),
|
|
(this.nodeVisible = void 0),
|
|
(this.rootNode = null),
|
|
(this.parsed = null);
|
|
var a = this;
|
|
Object.defineProperty(this, 'currentFileInfo', {
|
|
get: function () {
|
|
return a.fileInfo();
|
|
},
|
|
}),
|
|
Object.defineProperty(this, 'index', {
|
|
get: function () {
|
|
return a.getIndex();
|
|
},
|
|
});
|
|
};
|
|
(d.prototype.setParent = function (a, b) {
|
|
function c(a) {
|
|
a && a instanceof d && (a.parent = b);
|
|
}
|
|
Array.isArray(a) ? a.forEach(c) : c(a);
|
|
}),
|
|
(d.prototype.getIndex = function () {
|
|
return (
|
|
this._index || (this.parent && this.parent.getIndex()) || 0
|
|
);
|
|
}),
|
|
(d.prototype.fileInfo = function () {
|
|
return (
|
|
this._fileInfo || (this.parent && this.parent.fileInfo()) || {}
|
|
);
|
|
}),
|
|
(d.prototype.isRulesetLike = function () {
|
|
return !1;
|
|
}),
|
|
(d.prototype.toCSS = function (a) {
|
|
var b = [];
|
|
return (
|
|
this.genCSS(a, {
|
|
add: function (a, c, d) {
|
|
b.push(a);
|
|
},
|
|
isEmpty: function () {
|
|
return 0 === b.length;
|
|
},
|
|
}),
|
|
b.join('')
|
|
);
|
|
}),
|
|
(d.prototype.genCSS = function (a, b) {
|
|
b.add(this.value);
|
|
}),
|
|
(d.prototype.accept = function (a) {
|
|
this.value = a.visit(this.value);
|
|
}),
|
|
(d.prototype.eval = function () {
|
|
return this;
|
|
}),
|
|
(d.prototype._operate = function (a, b, c, d) {
|
|
switch (b) {
|
|
case '+':
|
|
return c + d;
|
|
case '-':
|
|
return c - d;
|
|
case '*':
|
|
return c * d;
|
|
case '/':
|
|
return c / d;
|
|
}
|
|
}),
|
|
(d.prototype.fround = function (a, b) {
|
|
var c = a && a.numPrecision;
|
|
return c ? Number((b + 2e-16).toFixed(c)) : b;
|
|
}),
|
|
(d.compare = function (a, b) {
|
|
if (a.compare && 'Quoted' !== b.type && 'Anonymous' !== b.type)
|
|
return a.compare(b);
|
|
if (b.compare) return -b.compare(a);
|
|
if (a.type === b.type) {
|
|
if (((a = a.value), (b = b.value), !Array.isArray(a)))
|
|
return a === b ? 0 : void 0;
|
|
if (a.length === b.length) {
|
|
for (var c = 0; c < a.length; c++)
|
|
if (0 !== d.compare(a[c], b[c])) return;
|
|
return 0;
|
|
}
|
|
}
|
|
}),
|
|
(d.numericCompare = function (a, b) {
|
|
return a < b ? -1 : a === b ? 0 : a > b ? 1 : void 0;
|
|
}),
|
|
(d.prototype.blocksVisibility = function () {
|
|
return (
|
|
null == this.visibilityBlocks && (this.visibilityBlocks = 0),
|
|
0 !== this.visibilityBlocks
|
|
);
|
|
}),
|
|
(d.prototype.addVisibilityBlock = function () {
|
|
null == this.visibilityBlocks && (this.visibilityBlocks = 0),
|
|
(this.visibilityBlocks = this.visibilityBlocks + 1);
|
|
}),
|
|
(d.prototype.removeVisibilityBlock = function () {
|
|
null == this.visibilityBlocks && (this.visibilityBlocks = 0),
|
|
(this.visibilityBlocks = this.visibilityBlocks - 1);
|
|
}),
|
|
(d.prototype.ensureVisibility = function () {
|
|
this.nodeVisible = !0;
|
|
}),
|
|
(d.prototype.ensureInvisibility = function () {
|
|
this.nodeVisible = !1;
|
|
}),
|
|
(d.prototype.isVisible = function () {
|
|
return this.nodeVisible;
|
|
}),
|
|
(d.prototype.visibilityInfo = function () {
|
|
return {
|
|
visibilityBlocks: this.visibilityBlocks,
|
|
nodeVisible: this.nodeVisible,
|
|
};
|
|
}),
|
|
(d.prototype.copyVisibilityInfo = function (a) {
|
|
a &&
|
|
((this.visibilityBlocks = a.visibilityBlocks),
|
|
(this.nodeVisible = a.nodeVisible));
|
|
}),
|
|
(b.exports = d);
|
|
},
|
|
{},
|
|
],
|
|
77: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./color'),
|
|
f = a('./dimension'),
|
|
g = a('../constants').Math,
|
|
h = function (a, b, c) {
|
|
(this.op = a.trim()), (this.operands = b), (this.isSpaced = c);
|
|
};
|
|
(h.prototype = new d()),
|
|
(h.prototype.type = 'Operation'),
|
|
(h.prototype.accept = function (a) {
|
|
this.operands = a.visit(this.operands);
|
|
}),
|
|
(h.prototype.eval = function (a) {
|
|
var b,
|
|
c = this.operands[0].eval(a),
|
|
d = this.operands[1].eval(a);
|
|
if (a.isMathOn(this.op)) {
|
|
if (
|
|
((b = './' === this.op ? '/' : this.op),
|
|
c instanceof f && d instanceof e && (c = c.toColor()),
|
|
d instanceof f && c instanceof e && (d = d.toColor()),
|
|
!c.operate)
|
|
) {
|
|
if (
|
|
c instanceof h &&
|
|
'/' === c.op &&
|
|
a.math === g.PARENS_DIVISION
|
|
)
|
|
return new h(this.op, [c, d], this.isSpaced);
|
|
throw {
|
|
type: 'Operation',
|
|
message: 'Operation on an invalid type',
|
|
};
|
|
}
|
|
return c.operate(a, b, d);
|
|
}
|
|
return new h(this.op, [c, d], this.isSpaced);
|
|
}),
|
|
(h.prototype.genCSS = function (a, b) {
|
|
this.operands[0].genCSS(a, b),
|
|
this.isSpaced && b.add(' '),
|
|
b.add(this.op),
|
|
this.isSpaced && b.add(' '),
|
|
this.operands[1].genCSS(a, b);
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{ '../constants': 12, './color': 55, './dimension': 62, './node': 76 },
|
|
],
|
|
78: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a) {
|
|
this.value = a;
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Paren'),
|
|
(e.prototype.genCSS = function (a, b) {
|
|
b.add('('), this.value.genCSS(a, b), b.add(')');
|
|
}),
|
|
(e.prototype.eval = function (a) {
|
|
return new e(this.value.eval(a));
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
79: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./declaration'),
|
|
f = function (a, b, c) {
|
|
(this.name = a), (this._index = b), (this._fileInfo = c);
|
|
};
|
|
(f.prototype = new d()),
|
|
(f.prototype.type = 'Property'),
|
|
(f.prototype.eval = function (a) {
|
|
var b,
|
|
c = this.name,
|
|
d =
|
|
a.pluginManager.less.visitors.ToCSSVisitor.prototype
|
|
._mergeRules;
|
|
if (this.evaluating)
|
|
throw {
|
|
type: 'Name',
|
|
message: 'Recursive property reference for ' + c,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
if (
|
|
((this.evaluating = !0),
|
|
(b = this.find(a.frames, function (b) {
|
|
var f,
|
|
g = b.property(c);
|
|
if (g) {
|
|
for (var h = 0; h < g.length; h++)
|
|
(f = g[h]),
|
|
(g[h] = new e(
|
|
f.name,
|
|
f.value,
|
|
f.important,
|
|
f.merge,
|
|
f.index,
|
|
f.currentFileInfo,
|
|
f.inline,
|
|
f.variable,
|
|
));
|
|
if ((d(g), (f = g[g.length - 1]), f.important)) {
|
|
var i = a.importantScope[a.importantScope.length - 1];
|
|
i.important = f.important;
|
|
}
|
|
return (f = f.value.eval(a));
|
|
}
|
|
})))
|
|
)
|
|
return (this.evaluating = !1), b;
|
|
throw {
|
|
type: 'Name',
|
|
message: "Property '" + c + "' is undefined",
|
|
filename: this.currentFileInfo.filename,
|
|
index: this.index,
|
|
};
|
|
}),
|
|
(f.prototype.find = function (a, b) {
|
|
for (var c, d = 0; d < a.length; d++)
|
|
if ((c = b.call(a, a[d]))) return c;
|
|
return null;
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ './declaration': 60, './node': 76 },
|
|
],
|
|
80: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./variable'),
|
|
f = a('./property'),
|
|
g = function (a, b, c, d, e) {
|
|
(this.escaped = null == c || c),
|
|
(this.value = b || ''),
|
|
(this.quote = a.charAt(0)),
|
|
(this._index = d),
|
|
(this._fileInfo = e),
|
|
(this.variableRegex = /@\{([\w-]+)\}/g),
|
|
(this.propRegex = /\$\{([\w-]+)\}/g);
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'Quoted'),
|
|
(g.prototype.genCSS = function (a, b) {
|
|
this.escaped ||
|
|
b.add(this.quote, this.fileInfo(), this.getIndex()),
|
|
b.add(this.value),
|
|
this.escaped || b.add(this.quote);
|
|
}),
|
|
(g.prototype.containsVariables = function () {
|
|
return this.value.match(this.variableRegex);
|
|
}),
|
|
(g.prototype.eval = function (a) {
|
|
function b(a, b, c) {
|
|
var d = a;
|
|
do (a = d), (d = a.replace(b, c));
|
|
while (a !== d);
|
|
return d;
|
|
}
|
|
var c = this,
|
|
d = this.value,
|
|
h = function (b, d) {
|
|
var f = new e('@' + d, c.getIndex(), c.fileInfo()).eval(
|
|
a,
|
|
!0,
|
|
);
|
|
return f instanceof g ? f.value : f.toCSS();
|
|
},
|
|
i = function (b, d) {
|
|
var e = new f('$' + d, c.getIndex(), c.fileInfo()).eval(
|
|
a,
|
|
!0,
|
|
);
|
|
return e instanceof g ? e.value : e.toCSS();
|
|
};
|
|
return (
|
|
(d = b(d, this.variableRegex, h)),
|
|
(d = b(d, this.propRegex, i)),
|
|
new g(
|
|
this.quote + d + this.quote,
|
|
d,
|
|
this.escaped,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
)
|
|
);
|
|
}),
|
|
(g.prototype.compare = function (a) {
|
|
return 'Quoted' !== a.type || this.escaped || a.escaped
|
|
? a.toCSS && this.toCSS() === a.toCSS()
|
|
? 0
|
|
: void 0
|
|
: d.numericCompare(this.value, a.value);
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ './node': 76, './property': 79, './variable': 88 },
|
|
],
|
|
81: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./declaration'),
|
|
f = a('./keyword'),
|
|
g = a('./comment'),
|
|
h = a('./paren'),
|
|
i = a('./selector'),
|
|
j = a('./element'),
|
|
k = a('./anonymous'),
|
|
l = a('../contexts'),
|
|
m = a('../functions/function-registry'),
|
|
n = a('../functions/default'),
|
|
o = a('./debug-info'),
|
|
p = a('../utils'),
|
|
q = function (a, b, c, d) {
|
|
(this.selectors = a),
|
|
(this.rules = b),
|
|
(this._lookups = {}),
|
|
(this._variables = null),
|
|
(this._properties = null),
|
|
(this.strictImports = c),
|
|
this.copyVisibilityInfo(d),
|
|
(this.allowRoot = !0),
|
|
this.setParent(this.selectors, this),
|
|
this.setParent(this.rules, this);
|
|
};
|
|
(q.prototype = new d()),
|
|
(q.prototype.type = 'Ruleset'),
|
|
(q.prototype.isRuleset = !0),
|
|
(q.prototype.isRulesetLike = function () {
|
|
return !0;
|
|
}),
|
|
(q.prototype.accept = function (a) {
|
|
this.paths
|
|
? (this.paths = a.visitArray(this.paths, !0))
|
|
: this.selectors &&
|
|
(this.selectors = a.visitArray(this.selectors)),
|
|
this.rules &&
|
|
this.rules.length &&
|
|
(this.rules = a.visitArray(this.rules));
|
|
}),
|
|
(q.prototype.eval = function (a) {
|
|
var b,
|
|
c,
|
|
f,
|
|
g,
|
|
h,
|
|
i = !1;
|
|
if (this.selectors && (c = this.selectors.length)) {
|
|
for (
|
|
b = new Array(c),
|
|
n.error({
|
|
type: 'Syntax',
|
|
message:
|
|
'it is currently only allowed in parametric mixin guards,',
|
|
}),
|
|
g = 0;
|
|
g < c;
|
|
g++
|
|
) {
|
|
f = this.selectors[g].eval(a);
|
|
for (var j = 0; j < f.elements.length; j++)
|
|
if (f.elements[j].isVariable) {
|
|
h = !0;
|
|
break;
|
|
}
|
|
(b[g] = f), f.evaldCondition && (i = !0);
|
|
}
|
|
if (h) {
|
|
var k = new Array(c);
|
|
for (g = 0; g < c; g++) (f = b[g]), (k[g] = f.toCSS(a));
|
|
this.parse.parseNode(
|
|
k.join(','),
|
|
['selectors'],
|
|
b[0].getIndex(),
|
|
b[0].fileInfo(),
|
|
function (a, c) {
|
|
c && (b = p.flattenArray(c));
|
|
},
|
|
);
|
|
}
|
|
n.reset();
|
|
} else i = !0;
|
|
var l,
|
|
o,
|
|
r = this.rules ? p.copyArray(this.rules) : null,
|
|
s = new q(b, r, this.strictImports, this.visibilityInfo());
|
|
(s.originalRuleset = this),
|
|
(s.root = this.root),
|
|
(s.firstRoot = this.firstRoot),
|
|
(s.allowImports = this.allowImports),
|
|
this.debugInfo && (s.debugInfo = this.debugInfo),
|
|
i || (r.length = 0),
|
|
(s.functionRegistry = (function (a) {
|
|
for (var b, c = 0, d = a.length; c !== d; ++c)
|
|
if ((b = a[c].functionRegistry)) return b;
|
|
return m;
|
|
})(a.frames).inherit());
|
|
var t = a.frames;
|
|
t.unshift(s);
|
|
var u = a.selectors;
|
|
u || (a.selectors = u = []),
|
|
u.unshift(this.selectors),
|
|
(s.root || s.allowImports || !s.strictImports) &&
|
|
s.evalImports(a);
|
|
var v = s.rules;
|
|
for (g = 0; (l = v[g]); g++) l.evalFirst && (v[g] = l.eval(a));
|
|
var w = (a.mediaBlocks && a.mediaBlocks.length) || 0;
|
|
for (g = 0; (l = v[g]); g++)
|
|
'MixinCall' === l.type
|
|
? ((r = l.eval(a).filter(function (a) {
|
|
return (
|
|
!(a instanceof e && a.variable) || !s.variable(a.name)
|
|
);
|
|
})),
|
|
v.splice.apply(v, [g, 1].concat(r)),
|
|
(g += r.length - 1),
|
|
s.resetCache())
|
|
: 'VariableCall' === l.type &&
|
|
((r = l.eval(a).rules.filter(function (a) {
|
|
return !(a instanceof e && a.variable);
|
|
})),
|
|
v.splice.apply(v, [g, 1].concat(r)),
|
|
(g += r.length - 1),
|
|
s.resetCache());
|
|
for (g = 0; (l = v[g]); g++)
|
|
l.evalFirst || (v[g] = l = l.eval ? l.eval(a) : l);
|
|
for (g = 0; (l = v[g]); g++)
|
|
if (
|
|
l instanceof q &&
|
|
l.selectors &&
|
|
1 === l.selectors.length &&
|
|
l.selectors[0] &&
|
|
l.selectors[0].isJustParentSelector()
|
|
) {
|
|
v.splice(g--, 1);
|
|
for (var j = 0; (o = l.rules[j]); j++)
|
|
o instanceof d &&
|
|
(o.copyVisibilityInfo(l.visibilityInfo()),
|
|
(o instanceof e && o.variable) || v.splice(++g, 0, o));
|
|
}
|
|
if ((t.shift(), u.shift(), a.mediaBlocks))
|
|
for (g = w; g < a.mediaBlocks.length; g++)
|
|
a.mediaBlocks[g].bubbleSelectors(b);
|
|
return s;
|
|
}),
|
|
(q.prototype.evalImports = function (a) {
|
|
var b,
|
|
c,
|
|
d = this.rules;
|
|
if (d)
|
|
for (b = 0; b < d.length; b++)
|
|
'Import' === d[b].type &&
|
|
((c = d[b].eval(a)),
|
|
c && (c.length || 0 === c.length)
|
|
? (d.splice.apply(d, [b, 1].concat(c)),
|
|
(b += c.length - 1))
|
|
: d.splice(b, 1, c),
|
|
this.resetCache());
|
|
}),
|
|
(q.prototype.makeImportant = function () {
|
|
var a = new q(
|
|
this.selectors,
|
|
this.rules.map(function (a) {
|
|
return a.makeImportant ? a.makeImportant() : a;
|
|
}),
|
|
this.strictImports,
|
|
this.visibilityInfo(),
|
|
);
|
|
return a;
|
|
}),
|
|
(q.prototype.matchArgs = function (a) {
|
|
return !a || 0 === a.length;
|
|
}),
|
|
(q.prototype.matchCondition = function (a, b) {
|
|
var c = this.selectors[this.selectors.length - 1];
|
|
return (
|
|
!!c.evaldCondition &&
|
|
!(c.condition && !c.condition.eval(new l.Eval(b, b.frames)))
|
|
);
|
|
}),
|
|
(q.prototype.resetCache = function () {
|
|
(this._rulesets = null),
|
|
(this._variables = null),
|
|
(this._properties = null),
|
|
(this._lookups = {});
|
|
}),
|
|
(q.prototype.variables = function () {
|
|
return (
|
|
this._variables ||
|
|
(this._variables = this.rules
|
|
? this.rules.reduce(function (a, b) {
|
|
if (
|
|
(b instanceof e &&
|
|
b.variable === !0 &&
|
|
(a[b.name] = b),
|
|
'Import' === b.type && b.root && b.root.variables)
|
|
) {
|
|
var c = b.root.variables();
|
|
for (var d in c)
|
|
c.hasOwnProperty(d) && (a[d] = b.root.variable(d));
|
|
}
|
|
return a;
|
|
}, {})
|
|
: {}),
|
|
this._variables
|
|
);
|
|
}),
|
|
(q.prototype.properties = function () {
|
|
return (
|
|
this._properties ||
|
|
(this._properties = this.rules
|
|
? this.rules.reduce(function (a, b) {
|
|
if (b instanceof e && b.variable !== !0) {
|
|
var c =
|
|
1 === b.name.length && b.name[0] instanceof f
|
|
? b.name[0].value
|
|
: b.name;
|
|
a['$' + c] ? a['$' + c].push(b) : (a['$' + c] = [b]);
|
|
}
|
|
return a;
|
|
}, {})
|
|
: {}),
|
|
this._properties
|
|
);
|
|
}),
|
|
(q.prototype.variable = function (a) {
|
|
var b = this.variables()[a];
|
|
if (b) return this.parseValue(b);
|
|
}),
|
|
(q.prototype.property = function (a) {
|
|
var b = this.properties()[a];
|
|
if (b) return this.parseValue(b);
|
|
}),
|
|
(q.prototype.lastDeclaration = function () {
|
|
for (var a = this.rules.length; a > 0; a--) {
|
|
var b = this.rules[a - 1];
|
|
if (b instanceof e) return this.parseValue(b);
|
|
}
|
|
}),
|
|
(q.prototype.parseValue = function (a) {
|
|
function b(a) {
|
|
return a.value instanceof k && !a.parsed
|
|
? ('string' == typeof a.value.value
|
|
? this.parse.parseNode(
|
|
a.value.value,
|
|
['value', 'important'],
|
|
a.value.getIndex(),
|
|
a.fileInfo(),
|
|
function (b, c) {
|
|
b && (a.parsed = !0),
|
|
c &&
|
|
((a.value = c[0]),
|
|
(a.important = c[1] || ''),
|
|
(a.parsed = !0));
|
|
},
|
|
)
|
|
: (a.parsed = !0),
|
|
a)
|
|
: a;
|
|
}
|
|
var c = this;
|
|
if (Array.isArray(a)) {
|
|
var d = [];
|
|
return (
|
|
a.forEach(function (a) {
|
|
d.push(b.call(c, a));
|
|
}),
|
|
d
|
|
);
|
|
}
|
|
return b.call(c, a);
|
|
}),
|
|
(q.prototype.rulesets = function () {
|
|
if (!this.rules) return [];
|
|
var a,
|
|
b,
|
|
c = [],
|
|
d = this.rules;
|
|
for (a = 0; (b = d[a]); a++) b.isRuleset && c.push(b);
|
|
return c;
|
|
}),
|
|
(q.prototype.prependRule = function (a) {
|
|
var b = this.rules;
|
|
b ? b.unshift(a) : (this.rules = [a]), this.setParent(a, this);
|
|
}),
|
|
(q.prototype.find = function (a, b, c) {
|
|
b = b || this;
|
|
var d,
|
|
e,
|
|
f = [],
|
|
g = a.toCSS();
|
|
return g in this._lookups
|
|
? this._lookups[g]
|
|
: (this.rulesets().forEach(function (g) {
|
|
if (g !== b)
|
|
for (var h = 0; h < g.selectors.length; h++)
|
|
if ((d = a.match(g.selectors[h]))) {
|
|
if (a.elements.length > d) {
|
|
if (!c || c(g)) {
|
|
e = g.find(new i(a.elements.slice(d)), b, c);
|
|
for (var j = 0; j < e.length; ++j)
|
|
e[j].path.push(g);
|
|
Array.prototype.push.apply(f, e);
|
|
}
|
|
} else f.push({ rule: g, path: [] });
|
|
break;
|
|
}
|
|
}),
|
|
(this._lookups[g] = f),
|
|
f);
|
|
}),
|
|
(q.prototype.genCSS = function (a, b) {
|
|
var c,
|
|
d,
|
|
e,
|
|
f,
|
|
h,
|
|
i = [],
|
|
j = [];
|
|
(a.tabLevel = a.tabLevel || 0), this.root || a.tabLevel++;
|
|
var k,
|
|
l = a.compress ? '' : Array(a.tabLevel + 1).join(' '),
|
|
m = a.compress ? '' : Array(a.tabLevel).join(' '),
|
|
n = 0,
|
|
p = 0;
|
|
for (c = 0; (f = this.rules[c]); c++)
|
|
f instanceof g
|
|
? (p === c && p++, j.push(f))
|
|
: f.isCharset && f.isCharset()
|
|
? (j.splice(n, 0, f), n++, p++)
|
|
: 'Import' === f.type
|
|
? (j.splice(p, 0, f), p++)
|
|
: j.push(f);
|
|
if (((j = i.concat(j)), !this.root)) {
|
|
(e = o(a, this, m)), e && (b.add(e), b.add(m));
|
|
var q,
|
|
r = this.paths,
|
|
s = r.length;
|
|
for (k = a.compress ? ',' : ',\n' + m, c = 0; c < s; c++)
|
|
if (((h = r[c]), (q = h.length)))
|
|
for (
|
|
c > 0 && b.add(k),
|
|
a.firstSelector = !0,
|
|
h[0].genCSS(a, b),
|
|
a.firstSelector = !1,
|
|
d = 1;
|
|
d < q;
|
|
d++
|
|
)
|
|
h[d].genCSS(a, b);
|
|
b.add((a.compress ? '{' : ' {\n') + l);
|
|
}
|
|
for (c = 0; (f = j[c]); c++) {
|
|
c + 1 === j.length && (a.lastRule = !0);
|
|
var t = a.lastRule;
|
|
f.isRulesetLike(f) && (a.lastRule = !1),
|
|
f.genCSS
|
|
? f.genCSS(a, b)
|
|
: f.value && b.add(f.value.toString()),
|
|
(a.lastRule = t),
|
|
!a.lastRule && f.isVisible()
|
|
? b.add(a.compress ? '' : '\n' + l)
|
|
: (a.lastRule = !1);
|
|
}
|
|
this.root ||
|
|
(b.add(a.compress ? '}' : '\n' + m + '}'), a.tabLevel--),
|
|
b.isEmpty() || a.compress || !this.firstRoot || b.add('\n');
|
|
}),
|
|
(q.prototype.joinSelectors = function (a, b, c) {
|
|
for (var d = 0; d < c.length; d++) this.joinSelector(a, b, c[d]);
|
|
}),
|
|
(q.prototype.joinSelector = function (a, b, c) {
|
|
function d(a, b) {
|
|
var c, d;
|
|
if (0 === a.length) c = new h(a[0]);
|
|
else {
|
|
var e = new Array(a.length);
|
|
for (d = 0; d < a.length; d++)
|
|
e[d] = new j(
|
|
null,
|
|
a[d],
|
|
b.isVariable,
|
|
b._index,
|
|
b._fileInfo,
|
|
);
|
|
c = new h(new i(e));
|
|
}
|
|
return c;
|
|
}
|
|
function e(a, b) {
|
|
var c, d;
|
|
return (
|
|
(c = new j(null, a, b.isVariable, b._index, b._fileInfo)),
|
|
(d = new i([c]))
|
|
);
|
|
}
|
|
function f(a, b, c, d) {
|
|
var e, f, g;
|
|
if (
|
|
((e = []),
|
|
a.length > 0
|
|
? ((e = p.copyArray(a)),
|
|
(f = e.pop()),
|
|
(g = d.createDerived(p.copyArray(f.elements))))
|
|
: (g = d.createDerived([])),
|
|
b.length > 0)
|
|
) {
|
|
var h = c.combinator,
|
|
i = b[0].elements[0];
|
|
h.emptyOrWhitespace &&
|
|
!i.combinator.emptyOrWhitespace &&
|
|
(h = i.combinator),
|
|
g.elements.push(
|
|
new j(h, i.value, c.isVariable, c._index, c._fileInfo),
|
|
),
|
|
(g.elements = g.elements.concat(b[0].elements.slice(1)));
|
|
}
|
|
if ((0 !== g.elements.length && e.push(g), b.length > 1)) {
|
|
var k = b.slice(1);
|
|
(k = k.map(function (a) {
|
|
return a.createDerived(a.elements, []);
|
|
})),
|
|
(e = e.concat(k));
|
|
}
|
|
return e;
|
|
}
|
|
function g(a, b, c, d, e) {
|
|
var g;
|
|
for (g = 0; g < a.length; g++) {
|
|
var h = f(a[g], b, c, d);
|
|
e.push(h);
|
|
}
|
|
return e;
|
|
}
|
|
function k(a, b) {
|
|
var c, d;
|
|
if (0 !== a.length) {
|
|
if (0 === b.length) return void b.push([new i(a)]);
|
|
for (c = 0; (d = b[c]); c++)
|
|
d.length > 0
|
|
? (d[d.length - 1] = d[d.length - 1].createDerived(
|
|
d[d.length - 1].elements.concat(a),
|
|
))
|
|
: d.push(new i(a));
|
|
}
|
|
}
|
|
function l(a, b, c) {
|
|
function m(a) {
|
|
var b;
|
|
return a.value instanceof h
|
|
? ((b = a.value.value), b instanceof i ? b : null)
|
|
: null;
|
|
}
|
|
var n,
|
|
o,
|
|
p,
|
|
q,
|
|
r,
|
|
s,
|
|
t,
|
|
u,
|
|
v,
|
|
w,
|
|
x = !1;
|
|
for (q = [], r = [[]], n = 0; (u = c.elements[n]); n++)
|
|
if ('&' !== u.value) {
|
|
var y = m(u);
|
|
if (null != y) {
|
|
k(q, r);
|
|
var z,
|
|
A = [],
|
|
B = [];
|
|
for (
|
|
z = l(A, b, y), x = x || z, p = 0;
|
|
p < A.length;
|
|
p++
|
|
) {
|
|
var C = e(d(A[p], u), u);
|
|
g(r, [C], u, c, B);
|
|
}
|
|
(r = B), (q = []);
|
|
} else q.push(u);
|
|
} else {
|
|
for (x = !0, s = [], k(q, r), o = 0; o < r.length; o++)
|
|
if (((t = r[o]), 0 === b.length))
|
|
t.length > 0 &&
|
|
t[0].elements.push(
|
|
new j(
|
|
u.combinator,
|
|
'',
|
|
u.isVariable,
|
|
u._index,
|
|
u._fileInfo,
|
|
),
|
|
),
|
|
s.push(t);
|
|
else
|
|
for (p = 0; p < b.length; p++) {
|
|
var D = f(t, b[p], u, c);
|
|
s.push(D);
|
|
}
|
|
(r = s), (q = []);
|
|
}
|
|
for (k(q, r), n = 0; n < r.length; n++)
|
|
(v = r[n].length),
|
|
v > 0 &&
|
|
(a.push(r[n]),
|
|
(w = r[n][v - 1]),
|
|
(r[n][v - 1] = w.createDerived(
|
|
w.elements,
|
|
c.extendList,
|
|
)));
|
|
return x;
|
|
}
|
|
function m(a, b) {
|
|
var c = b.createDerived(
|
|
b.elements,
|
|
b.extendList,
|
|
b.evaldCondition,
|
|
);
|
|
return c.copyVisibilityInfo(a), c;
|
|
}
|
|
var n, o, q;
|
|
if (((o = []), (q = l(o, b, c)), !q))
|
|
if (b.length > 0)
|
|
for (o = [], n = 0; n < b.length; n++) {
|
|
var r = b[n].map(m.bind(this, c.visibilityInfo()));
|
|
r.push(c), o.push(r);
|
|
}
|
|
else o = [[c]];
|
|
for (n = 0; n < o.length; n++) a.push(o[n]);
|
|
}),
|
|
(b.exports = q);
|
|
},
|
|
{
|
|
'../contexts': 13,
|
|
'../functions/default': 25,
|
|
'../functions/function-registry': 27,
|
|
'../utils': 89,
|
|
'./anonymous': 50,
|
|
'./comment': 57,
|
|
'./debug-info': 59,
|
|
'./declaration': 60,
|
|
'./element': 63,
|
|
'./keyword': 70,
|
|
'./node': 76,
|
|
'./paren': 78,
|
|
'./selector': 82,
|
|
},
|
|
],
|
|
82: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./element'),
|
|
f = a('../less-error'),
|
|
g = function (a, b, c, d, e, f) {
|
|
(this.extendList = b),
|
|
(this.condition = c),
|
|
(this.evaldCondition = !c),
|
|
(this._index = d),
|
|
(this._fileInfo = e),
|
|
(this.elements = this.getElements(a)),
|
|
(this.mixinElements_ = void 0),
|
|
this.copyVisibilityInfo(f),
|
|
this.setParent(this.elements, this);
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'Selector'),
|
|
(g.prototype.accept = function (a) {
|
|
this.elements && (this.elements = a.visitArray(this.elements)),
|
|
this.extendList &&
|
|
(this.extendList = a.visitArray(this.extendList)),
|
|
this.condition && (this.condition = a.visit(this.condition));
|
|
}),
|
|
(g.prototype.createDerived = function (a, b, c) {
|
|
a = this.getElements(a);
|
|
var d = new g(
|
|
a,
|
|
b || this.extendList,
|
|
null,
|
|
this.getIndex(),
|
|
this.fileInfo(),
|
|
this.visibilityInfo(),
|
|
);
|
|
return (
|
|
(d.evaldCondition = null != c ? c : this.evaldCondition),
|
|
(d.mediaEmpty = this.mediaEmpty),
|
|
d
|
|
);
|
|
}),
|
|
(g.prototype.getElements = function (a) {
|
|
return a
|
|
? ('string' == typeof a &&
|
|
this.parse.parseNode(
|
|
a,
|
|
['selector'],
|
|
this._index,
|
|
this._fileInfo,
|
|
function (b, c) {
|
|
if (b)
|
|
throw new f(
|
|
{ index: b.index, message: b.message },
|
|
this.parse.imports,
|
|
this._fileInfo.filename,
|
|
);
|
|
a = c[0].elements;
|
|
},
|
|
),
|
|
a)
|
|
: [new e('', '&', !1, this._index, this._fileInfo)];
|
|
}),
|
|
(g.prototype.createEmptySelectors = function () {
|
|
var a = new e('', '&', !1, this._index, this._fileInfo),
|
|
b = [new g([a], null, null, this._index, this._fileInfo)];
|
|
return (b[0].mediaEmpty = !0), b;
|
|
}),
|
|
(g.prototype.match = function (a) {
|
|
var b,
|
|
c,
|
|
d = this.elements,
|
|
e = d.length;
|
|
if (((a = a.mixinElements()), (b = a.length), 0 === b || e < b))
|
|
return 0;
|
|
for (c = 0; c < b; c++) if (d[c].value !== a[c]) return 0;
|
|
return b;
|
|
}),
|
|
(g.prototype.mixinElements = function () {
|
|
if (this.mixinElements_) return this.mixinElements_;
|
|
var a = this.elements
|
|
.map(function (a) {
|
|
return a.combinator.value + (a.value.value || a.value);
|
|
})
|
|
.join('')
|
|
.match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
|
|
return (
|
|
a ? '&' === a[0] && a.shift() : (a = []),
|
|
(this.mixinElements_ = a)
|
|
);
|
|
}),
|
|
(g.prototype.isJustParentSelector = function () {
|
|
return (
|
|
!this.mediaEmpty &&
|
|
1 === this.elements.length &&
|
|
'&' === this.elements[0].value &&
|
|
(' ' === this.elements[0].combinator.value ||
|
|
'' === this.elements[0].combinator.value)
|
|
);
|
|
}),
|
|
(g.prototype.eval = function (a) {
|
|
var b = this.condition && this.condition.eval(a),
|
|
c = this.elements,
|
|
d = this.extendList;
|
|
return (
|
|
(c =
|
|
c &&
|
|
c.map(function (b) {
|
|
return b.eval(a);
|
|
})),
|
|
(d =
|
|
d &&
|
|
d.map(function (b) {
|
|
return b.eval(a);
|
|
})),
|
|
this.createDerived(c, d, b)
|
|
);
|
|
}),
|
|
(g.prototype.genCSS = function (a, b) {
|
|
var c, d;
|
|
for (
|
|
(a && a.firstSelector) ||
|
|
'' !== this.elements[0].combinator.value ||
|
|
b.add(' ', this.fileInfo(), this.getIndex()),
|
|
c = 0;
|
|
c < this.elements.length;
|
|
c++
|
|
)
|
|
(d = this.elements[c]), d.genCSS(a, b);
|
|
}),
|
|
(g.prototype.getIsOutput = function () {
|
|
return this.evaldCondition;
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ '../less-error': 38, './element': 63, './node': 76 },
|
|
],
|
|
83: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a) {
|
|
this.value = a;
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'UnicodeDescriptor'),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
84: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('../data/unit-conversions'),
|
|
f = a('../utils'),
|
|
g = function (a, b, c) {
|
|
(this.numerator = a ? f.copyArray(a).sort() : []),
|
|
(this.denominator = b ? f.copyArray(b).sort() : []),
|
|
c
|
|
? (this.backupUnit = c)
|
|
: a && a.length && (this.backupUnit = a[0]);
|
|
};
|
|
(g.prototype = new d()),
|
|
(g.prototype.type = 'Unit'),
|
|
(g.prototype.clone = function () {
|
|
return new g(
|
|
f.copyArray(this.numerator),
|
|
f.copyArray(this.denominator),
|
|
this.backupUnit,
|
|
);
|
|
}),
|
|
(g.prototype.genCSS = function (a, b) {
|
|
var c = a && a.strictUnits;
|
|
1 === this.numerator.length
|
|
? b.add(this.numerator[0])
|
|
: !c && this.backupUnit
|
|
? b.add(this.backupUnit)
|
|
: !c && this.denominator.length && b.add(this.denominator[0]);
|
|
}),
|
|
(g.prototype.toString = function () {
|
|
var a,
|
|
b = this.numerator.join('*');
|
|
for (a = 0; a < this.denominator.length; a++)
|
|
b += '/' + this.denominator[a];
|
|
return b;
|
|
}),
|
|
(g.prototype.compare = function (a) {
|
|
return this.is(a.toString()) ? 0 : void 0;
|
|
}),
|
|
(g.prototype.is = function (a) {
|
|
return this.toString().toUpperCase() === a.toUpperCase();
|
|
}),
|
|
(g.prototype.isLength = function () {
|
|
return RegExp(
|
|
'^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$',
|
|
'gi',
|
|
).test(this.toCSS());
|
|
}),
|
|
(g.prototype.isEmpty = function () {
|
|
return (
|
|
0 === this.numerator.length && 0 === this.denominator.length
|
|
);
|
|
}),
|
|
(g.prototype.isSingular = function () {
|
|
return (
|
|
this.numerator.length <= 1 && 0 === this.denominator.length
|
|
);
|
|
}),
|
|
(g.prototype.map = function (a) {
|
|
var b;
|
|
for (b = 0; b < this.numerator.length; b++)
|
|
this.numerator[b] = a(this.numerator[b], !1);
|
|
for (b = 0; b < this.denominator.length; b++)
|
|
this.denominator[b] = a(this.denominator[b], !0);
|
|
}),
|
|
(g.prototype.usedUnits = function () {
|
|
var a,
|
|
b,
|
|
c,
|
|
d = {};
|
|
b = function (b) {
|
|
return a.hasOwnProperty(b) && !d[c] && (d[c] = b), b;
|
|
};
|
|
for (c in e) e.hasOwnProperty(c) && ((a = e[c]), this.map(b));
|
|
return d;
|
|
}),
|
|
(g.prototype.cancel = function () {
|
|
var a,
|
|
b,
|
|
c = {};
|
|
for (b = 0; b < this.numerator.length; b++)
|
|
(a = this.numerator[b]), (c[a] = (c[a] || 0) + 1);
|
|
for (b = 0; b < this.denominator.length; b++)
|
|
(a = this.denominator[b]), (c[a] = (c[a] || 0) - 1);
|
|
(this.numerator = []), (this.denominator = []);
|
|
for (a in c)
|
|
if (c.hasOwnProperty(a)) {
|
|
var d = c[a];
|
|
if (d > 0) for (b = 0; b < d; b++) this.numerator.push(a);
|
|
else if (d < 0)
|
|
for (b = 0; b < -d; b++) this.denominator.push(a);
|
|
}
|
|
this.numerator.sort(), this.denominator.sort();
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ '../data/unit-conversions': 16, '../utils': 89, './node': 76 },
|
|
],
|
|
85: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
return a.replace(/[\(\)'"\s]/g, function (a) {
|
|
return '\\' + a;
|
|
});
|
|
}
|
|
var e = a('./node'),
|
|
f = function (a, b, c, d) {
|
|
(this.value = a),
|
|
(this._index = b),
|
|
(this._fileInfo = c),
|
|
(this.isEvald = d);
|
|
};
|
|
(f.prototype = new e()),
|
|
(f.prototype.type = 'Url'),
|
|
(f.prototype.accept = function (a) {
|
|
this.value = a.visit(this.value);
|
|
}),
|
|
(f.prototype.genCSS = function (a, b) {
|
|
b.add('url('), this.value.genCSS(a, b), b.add(')');
|
|
}),
|
|
(f.prototype.eval = function (a) {
|
|
var b,
|
|
c = this.value.eval(a);
|
|
if (
|
|
!this.isEvald &&
|
|
((b = this.fileInfo() && this.fileInfo().rootpath),
|
|
'string' == typeof b &&
|
|
'string' == typeof c.value &&
|
|
a.pathRequiresRewrite(c.value)
|
|
? (c.quote || (b = d(b)),
|
|
(c.value = a.rewritePath(c.value, b)))
|
|
: (c.value = a.normalizePath(c.value)),
|
|
a.urlArgs && !c.value.match(/^\s*data:/))
|
|
) {
|
|
var e = c.value.indexOf('?') === -1 ? '?' : '&',
|
|
g = e + a.urlArgs;
|
|
c.value.indexOf('#') !== -1
|
|
? (c.value = c.value.replace('#', g + '#'))
|
|
: (c.value += g);
|
|
}
|
|
return new f(c, this.getIndex(), this.fileInfo(), !0);
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
86: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = function (a) {
|
|
if (!a) throw new Error('Value requires an array argument');
|
|
this.value = Array.isArray(a) ? a : [a];
|
|
};
|
|
(e.prototype = new d()),
|
|
(e.prototype.type = 'Value'),
|
|
(e.prototype.accept = function (a) {
|
|
this.value && (this.value = a.visitArray(this.value));
|
|
}),
|
|
(e.prototype.eval = function (a) {
|
|
return 1 === this.value.length
|
|
? this.value[0].eval(a)
|
|
: new e(
|
|
this.value.map(function (b) {
|
|
return b.eval(a);
|
|
}),
|
|
);
|
|
}),
|
|
(e.prototype.genCSS = function (a, b) {
|
|
var c;
|
|
for (c = 0; c < this.value.length; c++)
|
|
this.value[c].genCSS(a, b),
|
|
c + 1 < this.value.length &&
|
|
b.add(a && a.compress ? ',' : ', ');
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './node': 76 },
|
|
],
|
|
87: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./variable'),
|
|
f = a('./ruleset'),
|
|
g = a('./detached-ruleset'),
|
|
h = a('../less-error'),
|
|
i = function (a, b, c) {
|
|
(this.variable = a),
|
|
(this._index = b),
|
|
(this._fileInfo = c),
|
|
(this.allowRoot = !0);
|
|
};
|
|
(i.prototype = new d()),
|
|
(i.prototype.type = 'VariableCall'),
|
|
(i.prototype.eval = function (a) {
|
|
var b,
|
|
c = new e(this.variable, this.getIndex(), this.fileInfo()).eval(
|
|
a,
|
|
),
|
|
d = new h({
|
|
message: 'Could not evaluate variable call ' + this.variable,
|
|
});
|
|
if (!c.ruleset) {
|
|
if (Array.isArray(c)) b = c;
|
|
else {
|
|
if (!Array.isArray(c.value)) throw d;
|
|
b = c.value;
|
|
}
|
|
c = new g(new f('', b));
|
|
}
|
|
if (c.ruleset) return c.callEval(a);
|
|
throw d;
|
|
}),
|
|
(b.exports = i);
|
|
},
|
|
{
|
|
'../less-error': 38,
|
|
'./detached-ruleset': 61,
|
|
'./node': 76,
|
|
'./ruleset': 81,
|
|
'./variable': 88,
|
|
},
|
|
],
|
|
88: [
|
|
function (a, b, c) {
|
|
var d = a('./node'),
|
|
e = a('./call'),
|
|
f = function (a, b, c) {
|
|
(this.name = a), (this._index = b), (this._fileInfo = c);
|
|
};
|
|
(f.prototype = new d()),
|
|
(f.prototype.type = 'Variable'),
|
|
(f.prototype.eval = function (a) {
|
|
var b,
|
|
c = this.name;
|
|
if (
|
|
(0 === c.indexOf('@@') &&
|
|
(c =
|
|
'@' +
|
|
new f(c.slice(1), this.getIndex(), this.fileInfo()).eval(a)
|
|
.value),
|
|
this.evaluating)
|
|
)
|
|
throw {
|
|
type: 'Name',
|
|
message: 'Recursive variable definition for ' + c,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
if (
|
|
((this.evaluating = !0),
|
|
(b = this.find(a.frames, function (b) {
|
|
var d = b.variable(c);
|
|
if (d) {
|
|
if (d.important) {
|
|
var f = a.importantScope[a.importantScope.length - 1];
|
|
f.important = d.important;
|
|
}
|
|
return a.inCalc
|
|
? new e('_SELF', [d.value]).eval(a)
|
|
: d.value.eval(a);
|
|
}
|
|
})))
|
|
)
|
|
return (this.evaluating = !1), b;
|
|
throw {
|
|
type: 'Name',
|
|
message: 'variable ' + c + ' is undefined',
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex(),
|
|
};
|
|
}),
|
|
(f.prototype.find = function (a, b) {
|
|
for (var c, d = 0; d < a.length; d++)
|
|
if ((c = b.call(a, a[d]))) return c;
|
|
return null;
|
|
}),
|
|
(b.exports = f);
|
|
},
|
|
{ './call': 54, './node': 76 },
|
|
],
|
|
89: [
|
|
function (a, b, c) {
|
|
var d = a('./constants'),
|
|
e = a('clone'),
|
|
f = {
|
|
getLocation: function (a, b) {
|
|
for (
|
|
var c = a + 1, d = null, e = -1;
|
|
--c >= 0 && '\n' !== b.charAt(c);
|
|
|
|
)
|
|
e++;
|
|
return (
|
|
'number' == typeof a &&
|
|
(d = (b.slice(0, a).match(/\n/g) || '').length),
|
|
{ line: d, column: e }
|
|
);
|
|
},
|
|
copyArray: function (a) {
|
|
var b,
|
|
c = a.length,
|
|
d = new Array(c);
|
|
for (b = 0; b < c; b++) d[b] = a[b];
|
|
return d;
|
|
},
|
|
clone: function (a) {
|
|
var b = {};
|
|
for (var c in a) a.hasOwnProperty(c) && (b[c] = a[c]);
|
|
return b;
|
|
},
|
|
copyOptions: function (a, b) {
|
|
if (b && b._defaults) return b;
|
|
var c = f.defaults(a, b);
|
|
if (
|
|
(c.strictMath && (c.math = d.Math.STRICT_LEGACY),
|
|
c.relativeUrls && (c.rewriteUrls = d.RewriteUrls.ALL),
|
|
'string' == typeof c.math)
|
|
)
|
|
switch (c.math.toLowerCase()) {
|
|
case 'always':
|
|
c.math = d.Math.ALWAYS;
|
|
break;
|
|
case 'parens-division':
|
|
c.math = d.Math.PARENS_DIVISION;
|
|
break;
|
|
case 'strict':
|
|
case 'parens':
|
|
c.math = d.Math.PARENS;
|
|
break;
|
|
case 'strict-legacy':
|
|
c.math = d.Math.STRICT_LEGACY;
|
|
}
|
|
if ('string' == typeof c.rewriteUrls)
|
|
switch (c.rewriteUrls.toLowerCase()) {
|
|
case 'off':
|
|
c.rewriteUrls = d.RewriteUrls.OFF;
|
|
break;
|
|
case 'local':
|
|
c.rewriteUrls = d.RewriteUrls.LOCAL;
|
|
break;
|
|
case 'all':
|
|
c.rewriteUrls = d.RewriteUrls.ALL;
|
|
}
|
|
return c;
|
|
},
|
|
defaults: function (a, b) {
|
|
var c = b || {};
|
|
if (!b._defaults) {
|
|
c = {};
|
|
var d = e(a);
|
|
c._defaults = d;
|
|
var f = b ? e(b) : {};
|
|
Object.assign(c, d, f);
|
|
}
|
|
return c;
|
|
},
|
|
merge: function (a, b) {
|
|
for (var c in b) b.hasOwnProperty(c) && (a[c] = b[c]);
|
|
return a;
|
|
},
|
|
flattenArray: function (a, b) {
|
|
b = b || [];
|
|
for (var c = 0, d = a.length; c < d; c++) {
|
|
var e = a[c];
|
|
Array.isArray(e)
|
|
? f.flattenArray(e, b)
|
|
: void 0 !== e && b.push(e);
|
|
}
|
|
return b;
|
|
},
|
|
};
|
|
b.exports = f;
|
|
},
|
|
{ './constants': 12, clone: 102 },
|
|
],
|
|
90: [
|
|
function (a, b, c) {
|
|
var d = a('../tree'),
|
|
e = a('./visitor'),
|
|
f = a('../logger'),
|
|
g = a('../utils'),
|
|
h = function () {
|
|
(this._visitor = new e(this)),
|
|
(this.contexts = []),
|
|
(this.allExtendsStack = [[]]);
|
|
};
|
|
h.prototype = {
|
|
run: function (a) {
|
|
return (
|
|
(a = this._visitor.visit(a)),
|
|
(a.allExtends = this.allExtendsStack[0]),
|
|
a
|
|
);
|
|
},
|
|
visitDeclaration: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitMixinDefinition: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitRuleset: function (a, b) {
|
|
if (!a.root) {
|
|
var c,
|
|
e,
|
|
f,
|
|
h,
|
|
i = [],
|
|
j = a.rules,
|
|
k = j ? j.length : 0;
|
|
for (c = 0; c < k; c++)
|
|
a.rules[c] instanceof d.Extend &&
|
|
(i.push(j[c]), (a.extendOnEveryPath = !0));
|
|
var l = a.paths;
|
|
for (c = 0; c < l.length; c++) {
|
|
var m = l[c],
|
|
n = m[m.length - 1],
|
|
o = n.extendList;
|
|
for (
|
|
h = o ? g.copyArray(o).concat(i) : i,
|
|
h &&
|
|
(h = h.map(function (a) {
|
|
return a.clone();
|
|
})),
|
|
e = 0;
|
|
e < h.length;
|
|
e++
|
|
)
|
|
(this.foundExtends = !0),
|
|
(f = h[e]),
|
|
f.findSelfSelectors(m),
|
|
(f.ruleset = a),
|
|
0 === e && (f.firstExtendOnThisSelectorPath = !0),
|
|
this.allExtendsStack[
|
|
this.allExtendsStack.length - 1
|
|
].push(f);
|
|
}
|
|
this.contexts.push(a.selectors);
|
|
}
|
|
},
|
|
visitRulesetOut: function (a) {
|
|
a.root || (this.contexts.length = this.contexts.length - 1);
|
|
},
|
|
visitMedia: function (a, b) {
|
|
(a.allExtends = []), this.allExtendsStack.push(a.allExtends);
|
|
},
|
|
visitMediaOut: function (a) {
|
|
this.allExtendsStack.length = this.allExtendsStack.length - 1;
|
|
},
|
|
visitAtRule: function (a, b) {
|
|
(a.allExtends = []), this.allExtendsStack.push(a.allExtends);
|
|
},
|
|
visitAtRuleOut: function (a) {
|
|
this.allExtendsStack.length = this.allExtendsStack.length - 1;
|
|
},
|
|
};
|
|
var i = function () {
|
|
this._visitor = new e(this);
|
|
};
|
|
(i.prototype = {
|
|
run: function (a) {
|
|
var b = new h();
|
|
if (((this.extendIndices = {}), b.run(a), !b.foundExtends))
|
|
return a;
|
|
(a.allExtends = a.allExtends.concat(
|
|
this.doExtendChaining(a.allExtends, a.allExtends),
|
|
)),
|
|
(this.allExtendsStack = [a.allExtends]);
|
|
var c = this._visitor.visit(a);
|
|
return this.checkExtendsForNonMatched(a.allExtends), c;
|
|
},
|
|
checkExtendsForNonMatched: function (a) {
|
|
var b = this.extendIndices;
|
|
a.filter(function (a) {
|
|
return !a.hasFoundMatches && 1 == a.parent_ids.length;
|
|
}).forEach(function (a) {
|
|
var c = '_unknown_';
|
|
try {
|
|
c = a.selector.toCSS({});
|
|
} catch (d) {}
|
|
b[a.index + ' ' + c] ||
|
|
((b[a.index + ' ' + c] = !0),
|
|
f.warn("extend '" + c + "' has no matches"));
|
|
});
|
|
},
|
|
doExtendChaining: function (a, b, c) {
|
|
var e,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
j,
|
|
k,
|
|
l,
|
|
m = [],
|
|
n = this;
|
|
for (c = c || 0, e = 0; e < a.length; e++)
|
|
for (f = 0; f < b.length; f++)
|
|
(j = a[e]),
|
|
(k = b[f]),
|
|
j.parent_ids.indexOf(k.object_id) >= 0 ||
|
|
((i = [k.selfSelectors[0]]),
|
|
(g = n.findMatch(j, i)),
|
|
g.length &&
|
|
((j.hasFoundMatches = !0),
|
|
j.selfSelectors.forEach(function (a) {
|
|
var b = k.visibilityInfo();
|
|
(h = n.extendSelector(g, i, a, j.isVisible())),
|
|
(l = new d.Extend(
|
|
k.selector,
|
|
k.option,
|
|
0,
|
|
k.fileInfo(),
|
|
b,
|
|
)),
|
|
(l.selfSelectors = h),
|
|
(h[h.length - 1].extendList = [l]),
|
|
m.push(l),
|
|
(l.ruleset = k.ruleset),
|
|
(l.parent_ids = l.parent_ids.concat(
|
|
k.parent_ids,
|
|
j.parent_ids,
|
|
)),
|
|
k.firstExtendOnThisSelectorPath &&
|
|
((l.firstExtendOnThisSelectorPath = !0),
|
|
k.ruleset.paths.push(h));
|
|
})));
|
|
if (m.length) {
|
|
if ((this.extendChainCount++, c > 100)) {
|
|
var o = '{unable to calculate}',
|
|
p = '{unable to calculate}';
|
|
try {
|
|
(o = m[0].selfSelectors[0].toCSS()),
|
|
(p = m[0].selector.toCSS());
|
|
} catch (q) {}
|
|
throw {
|
|
message:
|
|
'extend circular reference detected. One of the circular extends is currently:' +
|
|
o +
|
|
':extend(' +
|
|
p +
|
|
')',
|
|
};
|
|
}
|
|
return m.concat(n.doExtendChaining(m, b, c + 1));
|
|
}
|
|
return m;
|
|
},
|
|
visitDeclaration: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitMixinDefinition: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitSelector: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitRuleset: function (a, b) {
|
|
if (!a.root) {
|
|
var c,
|
|
d,
|
|
e,
|
|
f,
|
|
g = this.allExtendsStack[this.allExtendsStack.length - 1],
|
|
h = [],
|
|
i = this;
|
|
for (e = 0; e < g.length; e++)
|
|
for (d = 0; d < a.paths.length; d++)
|
|
if (((f = a.paths[d]), !a.extendOnEveryPath)) {
|
|
var j = f[f.length - 1].extendList;
|
|
(j && j.length) ||
|
|
((c = this.findMatch(g[e], f)),
|
|
c.length &&
|
|
((g[e].hasFoundMatches = !0),
|
|
g[e].selfSelectors.forEach(function (a) {
|
|
var b;
|
|
(b = i.extendSelector(c, f, a, g[e].isVisible())),
|
|
h.push(b);
|
|
})));
|
|
}
|
|
a.paths = a.paths.concat(h);
|
|
}
|
|
},
|
|
findMatch: function (a, b) {
|
|
var c,
|
|
d,
|
|
e,
|
|
f,
|
|
g,
|
|
h,
|
|
i,
|
|
j = this,
|
|
k = a.selector.elements,
|
|
l = [],
|
|
m = [];
|
|
for (c = 0; c < b.length; c++)
|
|
for (d = b[c], e = 0; e < d.elements.length; e++)
|
|
for (
|
|
f = d.elements[e],
|
|
(a.allowBefore || (0 === c && 0 === e)) &&
|
|
l.push({
|
|
pathIndex: c,
|
|
index: e,
|
|
matched: 0,
|
|
initialCombinator: f.combinator,
|
|
}),
|
|
h = 0;
|
|
h < l.length;
|
|
h++
|
|
)
|
|
(i = l[h]),
|
|
(g = f.combinator.value),
|
|
'' === g && 0 === e && (g = ' '),
|
|
!j.isElementValuesEqual(k[i.matched].value, f.value) ||
|
|
(i.matched > 0 && k[i.matched].combinator.value !== g)
|
|
? (i = null)
|
|
: i.matched++,
|
|
i &&
|
|
((i.finished = i.matched === k.length),
|
|
i.finished &&
|
|
!a.allowAfter &&
|
|
(e + 1 < d.elements.length || c + 1 < b.length) &&
|
|
(i = null)),
|
|
i
|
|
? i.finished &&
|
|
((i.length = k.length),
|
|
(i.endPathIndex = c),
|
|
(i.endPathElementIndex = e + 1),
|
|
(l.length = 0),
|
|
m.push(i))
|
|
: (l.splice(h, 1), h--);
|
|
return m;
|
|
},
|
|
isElementValuesEqual: function (a, b) {
|
|
if ('string' == typeof a || 'string' == typeof b) return a === b;
|
|
if (a instanceof d.Attribute)
|
|
return (
|
|
a.op === b.op &&
|
|
a.key === b.key &&
|
|
(a.value && b.value
|
|
? ((a = a.value.value || a.value),
|
|
(b = b.value.value || b.value),
|
|
a === b)
|
|
: !a.value && !b.value)
|
|
);
|
|
if (((a = a.value), (b = b.value), a instanceof d.Selector)) {
|
|
if (
|
|
!(b instanceof d.Selector) ||
|
|
a.elements.length !== b.elements.length
|
|
)
|
|
return !1;
|
|
for (var c = 0; c < a.elements.length; c++) {
|
|
if (
|
|
a.elements[c].combinator.value !==
|
|
b.elements[c].combinator.value &&
|
|
(0 !== c ||
|
|
(a.elements[c].combinator.value || ' ') !==
|
|
(b.elements[c].combinator.value || ' '))
|
|
)
|
|
return !1;
|
|
if (
|
|
!this.isElementValuesEqual(
|
|
a.elements[c].value,
|
|
b.elements[c].value,
|
|
)
|
|
)
|
|
return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
return !1;
|
|
},
|
|
extendSelector: function (a, b, c, e) {
|
|
var f,
|
|
g,
|
|
h,
|
|
i,
|
|
j,
|
|
k = 0,
|
|
l = 0,
|
|
m = [];
|
|
for (f = 0; f < a.length; f++)
|
|
(i = a[f]),
|
|
(g = b[i.pathIndex]),
|
|
(h = new d.Element(
|
|
i.initialCombinator,
|
|
c.elements[0].value,
|
|
c.elements[0].isVariable,
|
|
c.elements[0].getIndex(),
|
|
c.elements[0].fileInfo(),
|
|
)),
|
|
i.pathIndex > k &&
|
|
l > 0 &&
|
|
((m[m.length - 1].elements = m[
|
|
m.length - 1
|
|
].elements.concat(b[k].elements.slice(l))),
|
|
(l = 0),
|
|
k++),
|
|
(j = g.elements
|
|
.slice(l, i.index)
|
|
.concat([h])
|
|
.concat(c.elements.slice(1))),
|
|
k === i.pathIndex && f > 0
|
|
? (m[m.length - 1].elements =
|
|
m[m.length - 1].elements.concat(j))
|
|
: ((m = m.concat(b.slice(k, i.pathIndex))),
|
|
m.push(new d.Selector(j))),
|
|
(k = i.endPathIndex),
|
|
(l = i.endPathElementIndex),
|
|
l >= b[k].elements.length && ((l = 0), k++);
|
|
return (
|
|
k < b.length &&
|
|
l > 0 &&
|
|
((m[m.length - 1].elements = m[m.length - 1].elements.concat(
|
|
b[k].elements.slice(l),
|
|
)),
|
|
k++),
|
|
(m = m.concat(b.slice(k, b.length))),
|
|
(m = m.map(function (a) {
|
|
var b = a.createDerived(a.elements);
|
|
return e ? b.ensureVisibility() : b.ensureInvisibility(), b;
|
|
}))
|
|
);
|
|
},
|
|
visitMedia: function (a, b) {
|
|
var c = a.allExtends.concat(
|
|
this.allExtendsStack[this.allExtendsStack.length - 1],
|
|
);
|
|
(c = c.concat(this.doExtendChaining(c, a.allExtends))),
|
|
this.allExtendsStack.push(c);
|
|
},
|
|
visitMediaOut: function (a) {
|
|
var b = this.allExtendsStack.length - 1;
|
|
this.allExtendsStack.length = b;
|
|
},
|
|
visitAtRule: function (a, b) {
|
|
var c = a.allExtends.concat(
|
|
this.allExtendsStack[this.allExtendsStack.length - 1],
|
|
);
|
|
(c = c.concat(this.doExtendChaining(c, a.allExtends))),
|
|
this.allExtendsStack.push(c);
|
|
},
|
|
visitAtRuleOut: function (a) {
|
|
var b = this.allExtendsStack.length - 1;
|
|
this.allExtendsStack.length = b;
|
|
},
|
|
}),
|
|
(b.exports = i);
|
|
},
|
|
{ '../logger': 39, '../tree': 67, '../utils': 89, './visitor': 97 },
|
|
],
|
|
91: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
(this.imports = []),
|
|
(this.variableImports = []),
|
|
(this._onSequencerEmpty = a),
|
|
(this._currentDepth = 0);
|
|
}
|
|
(d.prototype.addImport = function (a) {
|
|
var b = this,
|
|
c = { callback: a, args: null, isReady: !1 };
|
|
return (
|
|
this.imports.push(c),
|
|
function () {
|
|
(c.args = Array.prototype.slice.call(arguments, 0)),
|
|
(c.isReady = !0),
|
|
b.tryRun();
|
|
}
|
|
);
|
|
}),
|
|
(d.prototype.addVariableImport = function (a) {
|
|
this.variableImports.push(a);
|
|
}),
|
|
(d.prototype.tryRun = function () {
|
|
this._currentDepth++;
|
|
try {
|
|
for (;;) {
|
|
for (; this.imports.length > 0; ) {
|
|
var a = this.imports[0];
|
|
if (!a.isReady) return;
|
|
(this.imports = this.imports.slice(1)),
|
|
a.callback.apply(null, a.args);
|
|
}
|
|
if (0 === this.variableImports.length) break;
|
|
var b = this.variableImports[0];
|
|
(this.variableImports = this.variableImports.slice(1)), b();
|
|
}
|
|
} finally {
|
|
this._currentDepth--;
|
|
}
|
|
0 === this._currentDepth &&
|
|
this._onSequencerEmpty &&
|
|
this._onSequencerEmpty();
|
|
}),
|
|
(b.exports = d);
|
|
},
|
|
{},
|
|
],
|
|
92: [
|
|
function (a, b, c) {
|
|
var d = a('../contexts'),
|
|
e = a('./visitor'),
|
|
f = a('./import-sequencer'),
|
|
g = a('../utils'),
|
|
h = function (a, b) {
|
|
(this._visitor = new e(this)),
|
|
(this._importer = a),
|
|
(this._finish = b),
|
|
(this.context = new d.Eval()),
|
|
(this.importCount = 0),
|
|
(this.onceFileDetectionMap = {}),
|
|
(this.recursionDetector = {}),
|
|
(this._sequencer = new f(this._onSequencerEmpty.bind(this)));
|
|
};
|
|
(h.prototype = {
|
|
isReplacing: !1,
|
|
run: function (a) {
|
|
try {
|
|
this._visitor.visit(a);
|
|
} catch (b) {
|
|
this.error = b;
|
|
}
|
|
(this.isFinished = !0), this._sequencer.tryRun();
|
|
},
|
|
_onSequencerEmpty: function () {
|
|
this.isFinished && this._finish(this.error);
|
|
},
|
|
visitImport: function (a, b) {
|
|
var c = a.options.inline;
|
|
if (!a.css || c) {
|
|
var e = new d.Eval(
|
|
this.context,
|
|
g.copyArray(this.context.frames),
|
|
),
|
|
f = e.frames[0];
|
|
this.importCount++,
|
|
a.isVariableImport()
|
|
? this._sequencer.addVariableImport(
|
|
this.processImportNode.bind(this, a, e, f),
|
|
)
|
|
: this.processImportNode(a, e, f);
|
|
}
|
|
b.visitDeeper = !1;
|
|
},
|
|
processImportNode: function (a, b, c) {
|
|
var d,
|
|
e = a.options.inline;
|
|
try {
|
|
d = a.evalForImport(b);
|
|
} catch (f) {
|
|
f.filename ||
|
|
((f.index = a.getIndex()),
|
|
(f.filename = a.fileInfo().filename)),
|
|
(a.css = !0),
|
|
(a.error = f);
|
|
}
|
|
if (!d || (d.css && !e))
|
|
this.importCount--, this.isFinished && this._sequencer.tryRun();
|
|
else {
|
|
d.options.multiple && (b.importMultiple = !0);
|
|
for (var g = void 0 === d.css, h = 0; h < c.rules.length; h++)
|
|
if (c.rules[h] === a) {
|
|
c.rules[h] = d;
|
|
break;
|
|
}
|
|
var i = this.onImported.bind(this, d, b),
|
|
j = this._sequencer.addImport(i);
|
|
this._importer.push(d.getPath(), g, d.fileInfo(), d.options, j);
|
|
}
|
|
},
|
|
onImported: function (a, b, c, d, e, f) {
|
|
c &&
|
|
(c.filename ||
|
|
((c.index = a.getIndex()),
|
|
(c.filename = a.fileInfo().filename)),
|
|
(this.error = c));
|
|
var g = this,
|
|
h = a.options.inline,
|
|
i = a.options.isPlugin,
|
|
j = a.options.optional,
|
|
k = e || f in g.recursionDetector;
|
|
if (
|
|
(b.importMultiple ||
|
|
(a.skip =
|
|
!!k ||
|
|
function () {
|
|
return (
|
|
f in g.onceFileDetectionMap ||
|
|
((g.onceFileDetectionMap[f] = !0), !1)
|
|
);
|
|
}),
|
|
!f && j && (a.skip = !0),
|
|
d &&
|
|
((a.root = d),
|
|
(a.importedFilename = f),
|
|
!h && !i && (b.importMultiple || !k)))
|
|
) {
|
|
g.recursionDetector[f] = !0;
|
|
var l = this.context;
|
|
this.context = b;
|
|
try {
|
|
this._visitor.visit(d);
|
|
} catch (c) {
|
|
this.error = c;
|
|
}
|
|
this.context = l;
|
|
}
|
|
g.importCount--, g.isFinished && g._sequencer.tryRun();
|
|
},
|
|
visitDeclaration: function (a, b) {
|
|
'DetachedRuleset' === a.value.type
|
|
? this.context.frames.unshift(a)
|
|
: (b.visitDeeper = !1);
|
|
},
|
|
visitDeclarationOut: function (a) {
|
|
'DetachedRuleset' === a.value.type && this.context.frames.shift();
|
|
},
|
|
visitAtRule: function (a, b) {
|
|
this.context.frames.unshift(a);
|
|
},
|
|
visitAtRuleOut: function (a) {
|
|
this.context.frames.shift();
|
|
},
|
|
visitMixinDefinition: function (a, b) {
|
|
this.context.frames.unshift(a);
|
|
},
|
|
visitMixinDefinitionOut: function (a) {
|
|
this.context.frames.shift();
|
|
},
|
|
visitRuleset: function (a, b) {
|
|
this.context.frames.unshift(a);
|
|
},
|
|
visitRulesetOut: function (a) {
|
|
this.context.frames.shift();
|
|
},
|
|
visitMedia: function (a, b) {
|
|
this.context.frames.unshift(a.rules[0]);
|
|
},
|
|
visitMediaOut: function (a) {
|
|
this.context.frames.shift();
|
|
},
|
|
}),
|
|
(b.exports = h);
|
|
},
|
|
{
|
|
'../contexts': 13,
|
|
'../utils': 89,
|
|
'./import-sequencer': 91,
|
|
'./visitor': 97,
|
|
},
|
|
],
|
|
93: [
|
|
function (a, b, c) {
|
|
var d = {
|
|
Visitor: a('./visitor'),
|
|
ImportVisitor: a('./import-visitor'),
|
|
MarkVisibleSelectorsVisitor: a('./set-tree-visibility-visitor'),
|
|
ExtendVisitor: a('./extend-visitor'),
|
|
JoinSelectorVisitor: a('./join-selector-visitor'),
|
|
ToCSSVisitor: a('./to-css-visitor'),
|
|
};
|
|
b.exports = d;
|
|
},
|
|
{
|
|
'./extend-visitor': 90,
|
|
'./import-visitor': 92,
|
|
'./join-selector-visitor': 94,
|
|
'./set-tree-visibility-visitor': 95,
|
|
'./to-css-visitor': 96,
|
|
'./visitor': 97,
|
|
},
|
|
],
|
|
94: [
|
|
function (a, b, c) {
|
|
var d = a('./visitor'),
|
|
e = function () {
|
|
(this.contexts = [[]]), (this._visitor = new d(this));
|
|
};
|
|
(e.prototype = {
|
|
run: function (a) {
|
|
return this._visitor.visit(a);
|
|
},
|
|
visitDeclaration: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitMixinDefinition: function (a, b) {
|
|
b.visitDeeper = !1;
|
|
},
|
|
visitRuleset: function (a, b) {
|
|
var c,
|
|
d = this.contexts[this.contexts.length - 1],
|
|
e = [];
|
|
this.contexts.push(e),
|
|
a.root ||
|
|
((c = a.selectors),
|
|
c &&
|
|
((c = c.filter(function (a) {
|
|
return a.getIsOutput();
|
|
})),
|
|
(a.selectors = c.length ? c : (c = null)),
|
|
c && a.joinSelectors(e, d, c)),
|
|
c || (a.rules = null),
|
|
(a.paths = e));
|
|
},
|
|
visitRulesetOut: function (a) {
|
|
this.contexts.length = this.contexts.length - 1;
|
|
},
|
|
visitMedia: function (a, b) {
|
|
var c = this.contexts[this.contexts.length - 1];
|
|
a.rules[0].root = 0 === c.length || c[0].multiMedia;
|
|
},
|
|
visitAtRule: function (a, b) {
|
|
var c = this.contexts[this.contexts.length - 1];
|
|
a.rules &&
|
|
a.rules.length &&
|
|
(a.rules[0].root = a.isRooted || 0 === c.length || null);
|
|
},
|
|
}),
|
|
(b.exports = e);
|
|
},
|
|
{ './visitor': 97 },
|
|
],
|
|
95: [
|
|
function (a, b, c) {
|
|
var d = function (a) {
|
|
this.visible = a;
|
|
};
|
|
(d.prototype.run = function (a) {
|
|
this.visit(a);
|
|
}),
|
|
(d.prototype.visitArray = function (a) {
|
|
if (!a) return a;
|
|
var b,
|
|
c = a.length;
|
|
for (b = 0; b < c; b++) this.visit(a[b]);
|
|
return a;
|
|
}),
|
|
(d.prototype.visit = function (a) {
|
|
return a
|
|
? a.constructor === Array
|
|
? this.visitArray(a)
|
|
: !a.blocksVisibility || a.blocksVisibility()
|
|
? a
|
|
: (this.visible
|
|
? a.ensureVisibility()
|
|
: a.ensureInvisibility(),
|
|
a.accept(this),
|
|
a)
|
|
: a;
|
|
}),
|
|
(b.exports = d);
|
|
},
|
|
{},
|
|
],
|
|
96: [
|
|
function (a, b, c) {
|
|
var d = a('../tree'),
|
|
e = a('./visitor'),
|
|
f = function (a) {
|
|
(this._visitor = new e(this)), (this._context = a);
|
|
};
|
|
f.prototype = {
|
|
containsSilentNonBlockedChild: function (a) {
|
|
var b;
|
|
if (!a) return !1;
|
|
for (var c = 0; c < a.length; c++)
|
|
if (
|
|
((b = a[c]),
|
|
b.isSilent &&
|
|
b.isSilent(this._context) &&
|
|
!b.blocksVisibility())
|
|
)
|
|
return !0;
|
|
return !1;
|
|
},
|
|
keepOnlyVisibleChilds: function (a) {
|
|
a &&
|
|
a.rules &&
|
|
(a.rules = a.rules.filter(function (a) {
|
|
return a.isVisible();
|
|
}));
|
|
},
|
|
isEmpty: function (a) {
|
|
return !a || !a.rules || 0 === a.rules.length;
|
|
},
|
|
hasVisibleSelector: function (a) {
|
|
return !(!a || !a.paths) && a.paths.length > 0;
|
|
},
|
|
resolveVisibility: function (a, b) {
|
|
if (!a.blocksVisibility()) {
|
|
if (this.isEmpty(a) && !this.containsSilentNonBlockedChild(b))
|
|
return;
|
|
return a;
|
|
}
|
|
var c = a.rules[0];
|
|
if ((this.keepOnlyVisibleChilds(c), !this.isEmpty(c)))
|
|
return a.ensureVisibility(), a.removeVisibilityBlock(), a;
|
|
},
|
|
isVisibleRuleset: function (a) {
|
|
return (
|
|
!!a.firstRoot ||
|
|
(!this.isEmpty(a) && !(!a.root && !this.hasVisibleSelector(a)))
|
|
);
|
|
},
|
|
};
|
|
var g = function (a) {
|
|
(this._visitor = new e(this)),
|
|
(this._context = a),
|
|
(this.utils = new f(a));
|
|
};
|
|
(g.prototype = {
|
|
isReplacing: !0,
|
|
run: function (a) {
|
|
return this._visitor.visit(a);
|
|
},
|
|
visitDeclaration: function (a, b) {
|
|
if (!a.blocksVisibility() && !a.variable) return a;
|
|
},
|
|
visitMixinDefinition: function (a, b) {
|
|
a.frames = [];
|
|
},
|
|
visitExtend: function (a, b) {},
|
|
visitComment: function (a, b) {
|
|
if (!a.blocksVisibility() && !a.isSilent(this._context)) return a;
|
|
},
|
|
visitMedia: function (a, b) {
|
|
var c = a.rules[0].rules;
|
|
return (
|
|
a.accept(this._visitor),
|
|
(b.visitDeeper = !1),
|
|
this.utils.resolveVisibility(a, c)
|
|
);
|
|
},
|
|
visitImport: function (a, b) {
|
|
if (!a.blocksVisibility()) return a;
|
|
},
|
|
visitAtRule: function (a, b) {
|
|
return a.rules && a.rules.length
|
|
? this.visitAtRuleWithBody(a, b)
|
|
: this.visitAtRuleWithoutBody(a, b);
|
|
},
|
|
visitAnonymous: function (a, b) {
|
|
if (!a.blocksVisibility()) return a.accept(this._visitor), a;
|
|
},
|
|
visitAtRuleWithBody: function (a, b) {
|
|
function c(a) {
|
|
var b = a.rules;
|
|
return (
|
|
1 === b.length && (!b[0].paths || 0 === b[0].paths.length)
|
|
);
|
|
}
|
|
function d(a) {
|
|
var b = a.rules;
|
|
return c(a) ? b[0].rules : b;
|
|
}
|
|
var e = d(a);
|
|
return (
|
|
a.accept(this._visitor),
|
|
(b.visitDeeper = !1),
|
|
this.utils.isEmpty(a) || this._mergeRules(a.rules[0].rules),
|
|
this.utils.resolveVisibility(a, e)
|
|
);
|
|
},
|
|
visitAtRuleWithoutBody: function (a, b) {
|
|
if (!a.blocksVisibility()) {
|
|
if ('@charset' === a.name) {
|
|
if (this.charset) {
|
|
if (a.debugInfo) {
|
|
var c = new d.Comment(
|
|
'/* ' +
|
|
a.toCSS(this._context).replace(/\n/g, '') +
|
|
' */\n',
|
|
);
|
|
return (
|
|
(c.debugInfo = a.debugInfo), this._visitor.visit(c)
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
this.charset = !0;
|
|
}
|
|
return a;
|
|
}
|
|
},
|
|
checkValidNodes: function (a, b) {
|
|
if (a)
|
|
for (var c = 0; c < a.length; c++) {
|
|
var e = a[c];
|
|
if (b && e instanceof d.Declaration && !e.variable)
|
|
throw {
|
|
message:
|
|
'Properties must be inside selector blocks. They cannot be in the root',
|
|
index: e.getIndex(),
|
|
filename: e.fileInfo() && e.fileInfo().filename,
|
|
};
|
|
if (e instanceof d.Call)
|
|
throw {
|
|
message: "Function '" + e.name + "' is undefined",
|
|
index: e.getIndex(),
|
|
filename: e.fileInfo() && e.fileInfo().filename,
|
|
};
|
|
if (e.type && !e.allowRoot)
|
|
throw {
|
|
message:
|
|
e.type +
|
|
' node returned by a function is not valid here',
|
|
index: e.getIndex(),
|
|
filename: e.fileInfo() && e.fileInfo().filename,
|
|
};
|
|
}
|
|
},
|
|
visitRuleset: function (a, b) {
|
|
var c,
|
|
d = [];
|
|
if ((this.checkValidNodes(a.rules, a.firstRoot), a.root))
|
|
a.accept(this._visitor), (b.visitDeeper = !1);
|
|
else {
|
|
this._compileRulesetPaths(a);
|
|
for (var e = a.rules, f = e ? e.length : 0, g = 0; g < f; )
|
|
(c = e[g]),
|
|
c && c.rules
|
|
? (d.push(this._visitor.visit(c)), e.splice(g, 1), f--)
|
|
: g++;
|
|
f > 0 ? a.accept(this._visitor) : (a.rules = null),
|
|
(b.visitDeeper = !1);
|
|
}
|
|
return (
|
|
a.rules &&
|
|
(this._mergeRules(a.rules),
|
|
this._removeDuplicateRules(a.rules)),
|
|
this.utils.isVisibleRuleset(a) &&
|
|
(a.ensureVisibility(), d.splice(0, 0, a)),
|
|
1 === d.length ? d[0] : d
|
|
);
|
|
},
|
|
_compileRulesetPaths: function (a) {
|
|
a.paths &&
|
|
(a.paths = a.paths.filter(function (a) {
|
|
var b;
|
|
for (
|
|
' ' === a[0].elements[0].combinator.value &&
|
|
(a[0].elements[0].combinator = new d.Combinator('')),
|
|
b = 0;
|
|
b < a.length;
|
|
b++
|
|
)
|
|
if (a[b].isVisible() && a[b].getIsOutput()) return !0;
|
|
return !1;
|
|
}));
|
|
},
|
|
_removeDuplicateRules: function (a) {
|
|
if (a) {
|
|
var b,
|
|
c,
|
|
e,
|
|
f = {};
|
|
for (e = a.length - 1; e >= 0; e--)
|
|
if (((c = a[e]), c instanceof d.Declaration))
|
|
if (f[c.name]) {
|
|
(b = f[c.name]),
|
|
b instanceof d.Declaration &&
|
|
(b = f[c.name] = [f[c.name].toCSS(this._context)]);
|
|
var g = c.toCSS(this._context);
|
|
b.indexOf(g) !== -1 ? a.splice(e, 1) : b.push(g);
|
|
} else f[c.name] = c;
|
|
}
|
|
},
|
|
_mergeRules: function (a) {
|
|
if (a) {
|
|
for (var b = {}, c = [], e = 0; e < a.length; e++) {
|
|
var f = a[e];
|
|
if (f.merge) {
|
|
var g = f.name;
|
|
b[g] ? a.splice(e--, 1) : c.push((b[g] = [])), b[g].push(f);
|
|
}
|
|
}
|
|
c.forEach(function (a) {
|
|
if (a.length > 0) {
|
|
var b = a[0],
|
|
c = [],
|
|
e = [new d.Expression(c)];
|
|
a.forEach(function (a) {
|
|
'+' === a.merge &&
|
|
c.length > 0 &&
|
|
e.push(new d.Expression((c = []))),
|
|
c.push(a.value),
|
|
(b.important = b.important || a.important);
|
|
}),
|
|
(b.value = new d.Value(e));
|
|
}
|
|
});
|
|
}
|
|
},
|
|
}),
|
|
(b.exports = g);
|
|
},
|
|
{ '../tree': 67, './visitor': 97 },
|
|
],
|
|
97: [
|
|
function (a, b, c) {
|
|
function d(a) {
|
|
return a;
|
|
}
|
|
function e(a, b) {
|
|
var c, d;
|
|
for (c in a)
|
|
switch (((d = a[c]), typeof d)) {
|
|
case 'function':
|
|
d.prototype &&
|
|
d.prototype.type &&
|
|
(d.prototype.typeIndex = b++);
|
|
break;
|
|
case 'object':
|
|
b = e(d, b);
|
|
}
|
|
return b;
|
|
}
|
|
var f = a('../tree'),
|
|
g = { visitDeeper: !0 },
|
|
h = !1,
|
|
i = function (a) {
|
|
(this._implementation = a),
|
|
(this._visitInCache = {}),
|
|
(this._visitOutCache = {}),
|
|
h || (e(f, 1), (h = !0));
|
|
};
|
|
(i.prototype = {
|
|
visit: function (a) {
|
|
if (!a) return a;
|
|
var b = a.typeIndex;
|
|
if (!b)
|
|
return a.value && a.value.typeIndex && this.visit(a.value), a;
|
|
var c,
|
|
e = this._implementation,
|
|
f = this._visitInCache[b],
|
|
h = this._visitOutCache[b],
|
|
i = g;
|
|
if (
|
|
((i.visitDeeper = !0),
|
|
f ||
|
|
((c = 'visit' + a.type),
|
|
(f = e[c] || d),
|
|
(h = e[c + 'Out'] || d),
|
|
(this._visitInCache[b] = f),
|
|
(this._visitOutCache[b] = h)),
|
|
f !== d)
|
|
) {
|
|
var j = f.call(e, a, i);
|
|
a && e.isReplacing && (a = j);
|
|
}
|
|
return (
|
|
i.visitDeeper && a && a.accept && a.accept(this),
|
|
h != d && h.call(e, a),
|
|
a
|
|
);
|
|
},
|
|
visitArray: function (a, b) {
|
|
if (!a) return a;
|
|
var c,
|
|
d = a.length;
|
|
if (b || !this._implementation.isReplacing) {
|
|
for (c = 0; c < d; c++) this.visit(a[c]);
|
|
return a;
|
|
}
|
|
var e = [];
|
|
for (c = 0; c < d; c++) {
|
|
var f = this.visit(a[c]);
|
|
void 0 !== f &&
|
|
(f.splice ? f.length && this.flatten(f, e) : e.push(f));
|
|
}
|
|
return e;
|
|
},
|
|
flatten: function (a, b) {
|
|
b || (b = []);
|
|
var c, d, e, f, g, h;
|
|
for (d = 0, c = a.length; d < c; d++)
|
|
if (((e = a[d]), void 0 !== e))
|
|
if (e.splice)
|
|
for (g = 0, f = e.length; g < f; g++)
|
|
(h = e[g]),
|
|
void 0 !== h &&
|
|
(h.splice
|
|
? h.length && this.flatten(h, b)
|
|
: b.push(h));
|
|
else b.push(e);
|
|
return b;
|
|
},
|
|
}),
|
|
(b.exports = i);
|
|
},
|
|
{ '../tree': 67 },
|
|
],
|
|
98: [
|
|
function (a, b, c) {
|
|
'use strict';
|
|
function d() {
|
|
if (i.length) throw i.shift();
|
|
}
|
|
function e(a) {
|
|
var b;
|
|
(b = h.length ? h.pop() : new f()), (b.task = a), g(b);
|
|
}
|
|
function f() {
|
|
this.task = null;
|
|
}
|
|
var g = a('./raw'),
|
|
h = [],
|
|
i = [],
|
|
j = g.makeRequestCallFromTimer(d);
|
|
(b.exports = e),
|
|
(f.prototype.call = function () {
|
|
try {
|
|
this.task.call();
|
|
} catch (a) {
|
|
e.onerror ? e.onerror(a) : (i.push(a), j());
|
|
} finally {
|
|
(this.task = null), (h[h.length] = this);
|
|
}
|
|
});
|
|
},
|
|
{ './raw': 99 },
|
|
],
|
|
99: [
|
|
function (a, b, c) {
|
|
(function (a) {
|
|
'use strict';
|
|
function c(a) {
|
|
h.length || (g(), (i = !0)), (h[h.length] = a);
|
|
}
|
|
function d() {
|
|
for (; j < h.length; ) {
|
|
var a = j;
|
|
if (((j += 1), h[a].call(), j > k)) {
|
|
for (var b = 0, c = h.length - j; b < c; b++) h[b] = h[b + j];
|
|
(h.length -= j), (j = 0);
|
|
}
|
|
}
|
|
(h.length = 0), (j = 0), (i = !1);
|
|
}
|
|
function e(a) {
|
|
var b = 1,
|
|
c = new m(a),
|
|
d = document.createTextNode('');
|
|
return (
|
|
c.observe(d, { characterData: !0 }),
|
|
function () {
|
|
(b = -b), (d.data = b);
|
|
}
|
|
);
|
|
}
|
|
function f(a) {
|
|
return function () {
|
|
function b() {
|
|
clearTimeout(c), clearInterval(d), a();
|
|
}
|
|
var c = setTimeout(b, 0),
|
|
d = setInterval(b, 50);
|
|
};
|
|
}
|
|
b.exports = c;
|
|
var g,
|
|
h = [],
|
|
i = !1,
|
|
j = 0,
|
|
k = 1024,
|
|
l = 'undefined' != typeof a ? a : self,
|
|
m = l.MutationObserver || l.WebKitMutationObserver;
|
|
(g = 'function' == typeof m ? e(d) : f(d)),
|
|
(c.requestFlush = g),
|
|
(c.makeRequestCallFromTimer = f);
|
|
}.call(
|
|
this,
|
|
'undefined' != typeof global
|
|
? global
|
|
: 'undefined' != typeof self
|
|
? self
|
|
: 'undefined' != typeof window
|
|
? window
|
|
: {},
|
|
));
|
|
},
|
|
{},
|
|
],
|
|
100: [
|
|
function (a, b, c) {
|
|
'use strict';
|
|
function d(a) {
|
|
var b = a.length;
|
|
if (b % 4 > 0)
|
|
throw new Error('Invalid string. Length must be a multiple of 4');
|
|
return '=' === a[b - 2] ? 2 : '=' === a[b - 1] ? 1 : 0;
|
|
}
|
|
function e(a) {
|
|
return (3 * a.length) / 4 - d(a);
|
|
}
|
|
function f(a) {
|
|
var b,
|
|
c,
|
|
e,
|
|
f,
|
|
g,
|
|
h = a.length;
|
|
(f = d(a)), (g = new l((3 * h) / 4 - f)), (c = f > 0 ? h - 4 : h);
|
|
var i = 0;
|
|
for (b = 0; b < c; b += 4)
|
|
(e =
|
|
(k[a.charCodeAt(b)] << 18) |
|
|
(k[a.charCodeAt(b + 1)] << 12) |
|
|
(k[a.charCodeAt(b + 2)] << 6) |
|
|
k[a.charCodeAt(b + 3)]),
|
|
(g[i++] = (e >> 16) & 255),
|
|
(g[i++] = (e >> 8) & 255),
|
|
(g[i++] = 255 & e);
|
|
return (
|
|
2 === f
|
|
? ((e =
|
|
(k[a.charCodeAt(b)] << 2) | (k[a.charCodeAt(b + 1)] >> 4)),
|
|
(g[i++] = 255 & e))
|
|
: 1 === f &&
|
|
((e =
|
|
(k[a.charCodeAt(b)] << 10) |
|
|
(k[a.charCodeAt(b + 1)] << 4) |
|
|
(k[a.charCodeAt(b + 2)] >> 2)),
|
|
(g[i++] = (e >> 8) & 255),
|
|
(g[i++] = 255 & e)),
|
|
g
|
|
);
|
|
}
|
|
function g(a) {
|
|
return (
|
|
j[(a >> 18) & 63] +
|
|
j[(a >> 12) & 63] +
|
|
j[(a >> 6) & 63] +
|
|
j[63 & a]
|
|
);
|
|
}
|
|
function h(a, b, c) {
|
|
for (var d, e = [], f = b; f < c; f += 3)
|
|
(d = (a[f] << 16) + (a[f + 1] << 8) + a[f + 2]), e.push(g(d));
|
|
return e.join('');
|
|
}
|
|
function i(a) {
|
|
for (
|
|
var b,
|
|
c = a.length,
|
|
d = c % 3,
|
|
e = '',
|
|
f = [],
|
|
g = 16383,
|
|
i = 0,
|
|
k = c - d;
|
|
i < k;
|
|
i += g
|
|
)
|
|
f.push(h(a, i, i + g > k ? k : i + g));
|
|
return (
|
|
1 === d
|
|
? ((b = a[c - 1]),
|
|
(e += j[b >> 2]),
|
|
(e += j[(b << 4) & 63]),
|
|
(e += '=='))
|
|
: 2 === d &&
|
|
((b = (a[c - 2] << 8) + a[c - 1]),
|
|
(e += j[b >> 10]),
|
|
(e += j[(b >> 4) & 63]),
|
|
(e += j[(b << 2) & 63]),
|
|
(e += '=')),
|
|
f.push(e),
|
|
f.join('')
|
|
);
|
|
}
|
|
(c.byteLength = e), (c.toByteArray = f), (c.fromByteArray = i);
|
|
for (
|
|
var j = [],
|
|
k = [],
|
|
l = 'undefined' != typeof Uint8Array ? Uint8Array : Array,
|
|
m =
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
|
|
n = 0,
|
|
o = m.length;
|
|
n < o;
|
|
++n
|
|
)
|
|
(j[n] = m[n]), (k[m.charCodeAt(n)] = n);
|
|
(k['-'.charCodeAt(0)] = 62), (k['_'.charCodeAt(0)] = 63);
|
|
},
|
|
{},
|
|
],
|
|
101: [
|
|
function (a, b, c) {
|
|
'use strict';
|
|
function d() {
|
|
try {
|
|
var a = new Uint8Array(1);
|
|
return (
|
|
(a.__proto__ = {
|
|
__proto__: Uint8Array.prototype,
|
|
foo: function () {
|
|
return 42;
|
|
},
|
|
}),
|
|
42 === a.foo()
|
|
);
|
|
} catch (b) {
|
|
return !1;
|
|
}
|
|
}
|
|
function e(a) {
|
|
if (a > Z) throw new RangeError('Invalid typed array length');
|
|
var b = new Uint8Array(a);
|
|
return (b.__proto__ = f.prototype), b;
|
|
}
|
|
function f(a, b, c) {
|
|
if ('number' == typeof a) {
|
|
if ('string' == typeof b)
|
|
throw new Error(
|
|
'If encoding is specified then the first argument must be a string',
|
|
);
|
|
return j(a);
|
|
}
|
|
return g(a, b, c);
|
|
}
|
|
function g(a, b, c) {
|
|
if ('number' == typeof a)
|
|
throw new TypeError('"value" argument must not be a number');
|
|
return U(a) ? m(a, b, c) : 'string' == typeof a ? k(a, b) : n(a);
|
|
}
|
|
function h(a) {
|
|
if ('number' != typeof a)
|
|
throw new TypeError('"size" argument must be a number');
|
|
if (a < 0)
|
|
throw new RangeError('"size" argument must not be negative');
|
|
}
|
|
function i(a, b, c) {
|
|
return (
|
|
h(a),
|
|
a <= 0
|
|
? e(a)
|
|
: void 0 !== b
|
|
? 'string' == typeof c
|
|
? e(a).fill(b, c)
|
|
: e(a).fill(b)
|
|
: e(a)
|
|
);
|
|
}
|
|
function j(a) {
|
|
return h(a), e(a < 0 ? 0 : 0 | o(a));
|
|
}
|
|
function k(a, b) {
|
|
if (
|
|
(('string' == typeof b && '' !== b) || (b = 'utf8'),
|
|
!f.isEncoding(b))
|
|
)
|
|
throw new TypeError('"encoding" must be a valid string encoding');
|
|
var c = 0 | q(a, b),
|
|
d = e(c),
|
|
g = d.write(a, b);
|
|
return g !== c && (d = d.slice(0, g)), d;
|
|
}
|
|
function l(a) {
|
|
for (
|
|
var b = a.length < 0 ? 0 : 0 | o(a.length), c = e(b), d = 0;
|
|
d < b;
|
|
d += 1
|
|
)
|
|
c[d] = 255 & a[d];
|
|
return c;
|
|
}
|
|
function m(a, b, c) {
|
|
if (b < 0 || a.byteLength < b)
|
|
throw new RangeError("'offset' is out of bounds");
|
|
if (a.byteLength < b + (c || 0))
|
|
throw new RangeError("'length' is out of bounds");
|
|
var d;
|
|
return (
|
|
(d =
|
|
void 0 === b && void 0 === c
|
|
? new Uint8Array(a)
|
|
: void 0 === c
|
|
? new Uint8Array(a, b)
|
|
: new Uint8Array(a, b, c)),
|
|
(d.__proto__ = f.prototype),
|
|
d
|
|
);
|
|
}
|
|
function n(a) {
|
|
if (f.isBuffer(a)) {
|
|
var b = 0 | o(a.length),
|
|
c = e(b);
|
|
return 0 === c.length ? c : (a.copy(c, 0, 0, b), c);
|
|
}
|
|
if (a) {
|
|
if (V(a) || 'length' in a)
|
|
return 'number' != typeof a.length || W(a.length) ? e(0) : l(a);
|
|
if ('Buffer' === a.type && Array.isArray(a.data))
|
|
return l(a.data);
|
|
}
|
|
throw new TypeError(
|
|
'First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.',
|
|
);
|
|
}
|
|
function o(a) {
|
|
if (a >= Z)
|
|
throw new RangeError(
|
|
'Attempt to allocate Buffer larger than maximum size: 0x' +
|
|
Z.toString(16) +
|
|
' bytes',
|
|
);
|
|
return 0 | a;
|
|
}
|
|
function p(a) {
|
|
return +a != a && (a = 0), f.alloc(+a);
|
|
}
|
|
function q(a, b) {
|
|
if (f.isBuffer(a)) return a.length;
|
|
if (V(a) || U(a)) return a.byteLength;
|
|
'string' != typeof a && (a = '' + a);
|
|
var c = a.length;
|
|
if (0 === c) return 0;
|
|
for (var d = !1; ; )
|
|
switch (b) {
|
|
case 'ascii':
|
|
case 'latin1':
|
|
case 'binary':
|
|
return c;
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case void 0:
|
|
return P(a).length;
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return 2 * c;
|
|
case 'hex':
|
|
return c >>> 1;
|
|
case 'base64':
|
|
return S(a).length;
|
|
default:
|
|
if (d) return P(a).length;
|
|
(b = ('' + b).toLowerCase()), (d = !0);
|
|
}
|
|
}
|
|
function r(a, b, c) {
|
|
var d = !1;
|
|
if (((void 0 === b || b < 0) && (b = 0), b > this.length))
|
|
return '';
|
|
if (
|
|
((void 0 === c || c > this.length) && (c = this.length), c <= 0)
|
|
)
|
|
return '';
|
|
if (((c >>>= 0), (b >>>= 0), c <= b)) return '';
|
|
for (a || (a = 'utf8'); ; )
|
|
switch (a) {
|
|
case 'hex':
|
|
return G(this, b, c);
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return C(this, b, c);
|
|
case 'ascii':
|
|
return E(this, b, c);
|
|
case 'latin1':
|
|
case 'binary':
|
|
return F(this, b, c);
|
|
case 'base64':
|
|
return B(this, b, c);
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return H(this, b, c);
|
|
default:
|
|
if (d) throw new TypeError('Unknown encoding: ' + a);
|
|
(a = (a + '').toLowerCase()), (d = !0);
|
|
}
|
|
}
|
|
function s(a, b, c) {
|
|
var d = a[b];
|
|
(a[b] = a[c]), (a[c] = d);
|
|
}
|
|
function t(a, b, c, d, e) {
|
|
if (0 === a.length) return -1;
|
|
if (
|
|
('string' == typeof c
|
|
? ((d = c), (c = 0))
|
|
: c > 2147483647
|
|
? (c = 2147483647)
|
|
: c < -2147483648 && (c = -2147483648),
|
|
(c = +c),
|
|
W(c) && (c = e ? 0 : a.length - 1),
|
|
c < 0 && (c = a.length + c),
|
|
c >= a.length)
|
|
) {
|
|
if (e) return -1;
|
|
c = a.length - 1;
|
|
} else if (c < 0) {
|
|
if (!e) return -1;
|
|
c = 0;
|
|
}
|
|
if (('string' == typeof b && (b = f.from(b, d)), f.isBuffer(b)))
|
|
return 0 === b.length ? -1 : u(a, b, c, d, e);
|
|
if ('number' == typeof b)
|
|
return (
|
|
(b = 255 & b),
|
|
'function' == typeof Uint8Array.prototype.indexOf
|
|
? e
|
|
? Uint8Array.prototype.indexOf.call(a, b, c)
|
|
: Uint8Array.prototype.lastIndexOf.call(a, b, c)
|
|
: u(a, [b], c, d, e)
|
|
);
|
|
throw new TypeError('val must be string, number or Buffer');
|
|
}
|
|
function u(a, b, c, d, e) {
|
|
function f(a, b) {
|
|
return 1 === g ? a[b] : a.readUInt16BE(b * g);
|
|
}
|
|
var g = 1,
|
|
h = a.length,
|
|
i = b.length;
|
|
if (
|
|
void 0 !== d &&
|
|
((d = String(d).toLowerCase()),
|
|
'ucs2' === d ||
|
|
'ucs-2' === d ||
|
|
'utf16le' === d ||
|
|
'utf-16le' === d)
|
|
) {
|
|
if (a.length < 2 || b.length < 2) return -1;
|
|
(g = 2), (h /= 2), (i /= 2), (c /= 2);
|
|
}
|
|
var j;
|
|
if (e) {
|
|
var k = -1;
|
|
for (j = c; j < h; j++)
|
|
if (f(a, j) === f(b, k === -1 ? 0 : j - k)) {
|
|
if ((k === -1 && (k = j), j - k + 1 === i)) return k * g;
|
|
} else k !== -1 && (j -= j - k), (k = -1);
|
|
} else
|
|
for (c + i > h && (c = h - i), j = c; j >= 0; j--) {
|
|
for (var l = !0, m = 0; m < i; m++)
|
|
if (f(a, j + m) !== f(b, m)) {
|
|
l = !1;
|
|
break;
|
|
}
|
|
if (l) return j;
|
|
}
|
|
return -1;
|
|
}
|
|
function v(a, b, c, d) {
|
|
c = Number(c) || 0;
|
|
var e = a.length - c;
|
|
d ? ((d = Number(d)), d > e && (d = e)) : (d = e);
|
|
var f = b.length;
|
|
if (f % 2 !== 0) throw new TypeError('Invalid hex string');
|
|
d > f / 2 && (d = f / 2);
|
|
for (var g = 0; g < d; ++g) {
|
|
var h = parseInt(b.substr(2 * g, 2), 16);
|
|
if (W(h)) return g;
|
|
a[c + g] = h;
|
|
}
|
|
return g;
|
|
}
|
|
function w(a, b, c, d) {
|
|
return T(P(b, a.length - c), a, c, d);
|
|
}
|
|
function x(a, b, c, d) {
|
|
return T(Q(b), a, c, d);
|
|
}
|
|
function y(a, b, c, d) {
|
|
return x(a, b, c, d);
|
|
}
|
|
function z(a, b, c, d) {
|
|
return T(S(b), a, c, d);
|
|
}
|
|
function A(a, b, c, d) {
|
|
return T(R(b, a.length - c), a, c, d);
|
|
}
|
|
function B(a, b, c) {
|
|
return X.fromByteArray(
|
|
0 === b && c === a.length ? a : a.slice(b, c),
|
|
);
|
|
}
|
|
function C(a, b, c) {
|
|
c = Math.min(a.length, c);
|
|
for (var d = [], e = b; e < c; ) {
|
|
var f = a[e],
|
|
g = null,
|
|
h = f > 239 ? 4 : f > 223 ? 3 : f > 191 ? 2 : 1;
|
|
if (e + h <= c) {
|
|
var i, j, k, l;
|
|
switch (h) {
|
|
case 1:
|
|
f < 128 && (g = f);
|
|
break;
|
|
case 2:
|
|
(i = a[e + 1]),
|
|
128 === (192 & i) &&
|
|
((l = ((31 & f) << 6) | (63 & i)), l > 127 && (g = l));
|
|
break;
|
|
case 3:
|
|
(i = a[e + 1]),
|
|
(j = a[e + 2]),
|
|
128 === (192 & i) &&
|
|
128 === (192 & j) &&
|
|
((l = ((15 & f) << 12) | ((63 & i) << 6) | (63 & j)),
|
|
l > 2047 && (l < 55296 || l > 57343) && (g = l));
|
|
break;
|
|
case 4:
|
|
(i = a[e + 1]),
|
|
(j = a[e + 2]),
|
|
(k = a[e + 3]),
|
|
128 === (192 & i) &&
|
|
128 === (192 & j) &&
|
|
128 === (192 & k) &&
|
|
((l =
|
|
((15 & f) << 18) |
|
|
((63 & i) << 12) |
|
|
((63 & j) << 6) |
|
|
(63 & k)),
|
|
l > 65535 && l < 1114112 && (g = l));
|
|
}
|
|
}
|
|
null === g
|
|
? ((g = 65533), (h = 1))
|
|
: g > 65535 &&
|
|
((g -= 65536),
|
|
d.push(((g >>> 10) & 1023) | 55296),
|
|
(g = 56320 | (1023 & g))),
|
|
d.push(g),
|
|
(e += h);
|
|
}
|
|
return D(d);
|
|
}
|
|
function D(a) {
|
|
var b = a.length;
|
|
if (b <= $) return String.fromCharCode.apply(String, a);
|
|
for (var c = '', d = 0; d < b; )
|
|
c += String.fromCharCode.apply(String, a.slice(d, (d += $)));
|
|
return c;
|
|
}
|
|
function E(a, b, c) {
|
|
var d = '';
|
|
c = Math.min(a.length, c);
|
|
for (var e = b; e < c; ++e) d += String.fromCharCode(127 & a[e]);
|
|
return d;
|
|
}
|
|
function F(a, b, c) {
|
|
var d = '';
|
|
c = Math.min(a.length, c);
|
|
for (var e = b; e < c; ++e) d += String.fromCharCode(a[e]);
|
|
return d;
|
|
}
|
|
function G(a, b, c) {
|
|
var d = a.length;
|
|
(!b || b < 0) && (b = 0), (!c || c < 0 || c > d) && (c = d);
|
|
for (var e = '', f = b; f < c; ++f) e += O(a[f]);
|
|
return e;
|
|
}
|
|
function H(a, b, c) {
|
|
for (var d = a.slice(b, c), e = '', f = 0; f < d.length; f += 2)
|
|
e += String.fromCharCode(d[f] + 256 * d[f + 1]);
|
|
return e;
|
|
}
|
|
function I(a, b, c) {
|
|
if (a % 1 !== 0 || a < 0)
|
|
throw new RangeError('offset is not uint');
|
|
if (a + b > c)
|
|
throw new RangeError('Trying to access beyond buffer length');
|
|
}
|
|
function J(a, b, c, d, e, g) {
|
|
if (!f.isBuffer(a))
|
|
throw new TypeError(
|
|
'"buffer" argument must be a Buffer instance',
|
|
);
|
|
if (b > e || b < g)
|
|
throw new RangeError('"value" argument is out of bounds');
|
|
if (c + d > a.length) throw new RangeError('Index out of range');
|
|
}
|
|
function K(a, b, c, d, e, f) {
|
|
if (c + d > a.length) throw new RangeError('Index out of range');
|
|
if (c < 0) throw new RangeError('Index out of range');
|
|
}
|
|
function L(a, b, c, d, e) {
|
|
return (
|
|
(b = +b),
|
|
(c >>>= 0),
|
|
e || K(a, b, c, 4, 3.4028234663852886e38, -3.4028234663852886e38),
|
|
Y.write(a, b, c, d, 23, 4),
|
|
c + 4
|
|
);
|
|
}
|
|
function M(a, b, c, d, e) {
|
|
return (
|
|
(b = +b),
|
|
(c >>>= 0),
|
|
e ||
|
|
K(a, b, c, 8, 1.7976931348623157e308, -1.7976931348623157e308),
|
|
Y.write(a, b, c, d, 52, 8),
|
|
c + 8
|
|
);
|
|
}
|
|
function N(a) {
|
|
if (((a = a.trim().replace(_, '')), a.length < 2)) return '';
|
|
for (; a.length % 4 !== 0; ) a += '=';
|
|
return a;
|
|
}
|
|
function O(a) {
|
|
return a < 16 ? '0' + a.toString(16) : a.toString(16);
|
|
}
|
|
function P(a, b) {
|
|
b = b || 1 / 0;
|
|
for (var c, d = a.length, e = null, f = [], g = 0; g < d; ++g) {
|
|
if (((c = a.charCodeAt(g)), c > 55295 && c < 57344)) {
|
|
if (!e) {
|
|
if (c > 56319) {
|
|
(b -= 3) > -1 && f.push(239, 191, 189);
|
|
continue;
|
|
}
|
|
if (g + 1 === d) {
|
|
(b -= 3) > -1 && f.push(239, 191, 189);
|
|
continue;
|
|
}
|
|
e = c;
|
|
continue;
|
|
}
|
|
if (c < 56320) {
|
|
(b -= 3) > -1 && f.push(239, 191, 189), (e = c);
|
|
continue;
|
|
}
|
|
c = (((e - 55296) << 10) | (c - 56320)) + 65536;
|
|
} else e && (b -= 3) > -1 && f.push(239, 191, 189);
|
|
if (((e = null), c < 128)) {
|
|
if ((b -= 1) < 0) break;
|
|
f.push(c);
|
|
} else if (c < 2048) {
|
|
if ((b -= 2) < 0) break;
|
|
f.push((c >> 6) | 192, (63 & c) | 128);
|
|
} else if (c < 65536) {
|
|
if ((b -= 3) < 0) break;
|
|
f.push((c >> 12) | 224, ((c >> 6) & 63) | 128, (63 & c) | 128);
|
|
} else {
|
|
if (!(c < 1114112)) throw new Error('Invalid code point');
|
|
if ((b -= 4) < 0) break;
|
|
f.push(
|
|
(c >> 18) | 240,
|
|
((c >> 12) & 63) | 128,
|
|
((c >> 6) & 63) | 128,
|
|
(63 & c) | 128,
|
|
);
|
|
}
|
|
}
|
|
return f;
|
|
}
|
|
function Q(a) {
|
|
for (var b = [], c = 0; c < a.length; ++c)
|
|
b.push(255 & a.charCodeAt(c));
|
|
return b;
|
|
}
|
|
function R(a, b) {
|
|
for (
|
|
var c, d, e, f = [], g = 0;
|
|
g < a.length && !((b -= 2) < 0);
|
|
++g
|
|
)
|
|
(c = a.charCodeAt(g)),
|
|
(d = c >> 8),
|
|
(e = c % 256),
|
|
f.push(e),
|
|
f.push(d);
|
|
return f;
|
|
}
|
|
function S(a) {
|
|
return X.toByteArray(N(a));
|
|
}
|
|
function T(a, b, c, d) {
|
|
for (var e = 0; e < d && !(e + c >= b.length || e >= a.length); ++e)
|
|
b[e + c] = a[e];
|
|
return e;
|
|
}
|
|
function U(a) {
|
|
return (
|
|
a instanceof ArrayBuffer ||
|
|
(null != a &&
|
|
null != a.constructor &&
|
|
'ArrayBuffer' === a.constructor.name &&
|
|
'number' == typeof a.byteLength)
|
|
);
|
|
}
|
|
function V(a) {
|
|
return (
|
|
'function' == typeof ArrayBuffer.isView && ArrayBuffer.isView(a)
|
|
);
|
|
}
|
|
function W(a) {
|
|
return a !== a;
|
|
}
|
|
var X = a('base64-js'),
|
|
Y = a('ieee754');
|
|
(c.Buffer = f), (c.SlowBuffer = p), (c.INSPECT_MAX_BYTES = 50);
|
|
var Z = 2147483647;
|
|
(c.kMaxLength = Z),
|
|
(f.TYPED_ARRAY_SUPPORT = d()),
|
|
f.TYPED_ARRAY_SUPPORT ||
|
|
'undefined' == typeof console ||
|
|
'function' != typeof console.error ||
|
|
console.error(
|
|
'This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.',
|
|
),
|
|
'undefined' != typeof Symbol &&
|
|
Symbol.species &&
|
|
f[Symbol.species] === f &&
|
|
Object.defineProperty(f, Symbol.species, {
|
|
value: null,
|
|
configurable: !0,
|
|
enumerable: !1,
|
|
writable: !1,
|
|
}),
|
|
(f.poolSize = 8192),
|
|
(f.from = function (a, b, c) {
|
|
return g(a, b, c);
|
|
}),
|
|
(f.prototype.__proto__ = Uint8Array.prototype),
|
|
(f.__proto__ = Uint8Array),
|
|
(f.alloc = function (a, b, c) {
|
|
return i(a, b, c);
|
|
}),
|
|
(f.allocUnsafe = function (a) {
|
|
return j(a);
|
|
}),
|
|
(f.allocUnsafeSlow = function (a) {
|
|
return j(a);
|
|
}),
|
|
(f.isBuffer = function (a) {
|
|
return null != a && a._isBuffer === !0;
|
|
}),
|
|
(f.compare = function (a, b) {
|
|
if (!f.isBuffer(a) || !f.isBuffer(b))
|
|
throw new TypeError('Arguments must be Buffers');
|
|
if (a === b) return 0;
|
|
for (
|
|
var c = a.length, d = b.length, e = 0, g = Math.min(c, d);
|
|
e < g;
|
|
++e
|
|
)
|
|
if (a[e] !== b[e]) {
|
|
(c = a[e]), (d = b[e]);
|
|
break;
|
|
}
|
|
return c < d ? -1 : d < c ? 1 : 0;
|
|
}),
|
|
(f.isEncoding = function (a) {
|
|
switch (String(a).toLowerCase()) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'latin1':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
}),
|
|
(f.concat = function (a, b) {
|
|
if (!Array.isArray(a))
|
|
throw new TypeError(
|
|
'"list" argument must be an Array of Buffers',
|
|
);
|
|
if (0 === a.length) return f.alloc(0);
|
|
var c;
|
|
if (void 0 === b)
|
|
for (b = 0, c = 0; c < a.length; ++c) b += a[c].length;
|
|
var d = f.allocUnsafe(b),
|
|
e = 0;
|
|
for (c = 0; c < a.length; ++c) {
|
|
var g = a[c];
|
|
if (!f.isBuffer(g))
|
|
throw new TypeError(
|
|
'"list" argument must be an Array of Buffers',
|
|
);
|
|
g.copy(d, e), (e += g.length);
|
|
}
|
|
return d;
|
|
}),
|
|
(f.byteLength = q),
|
|
(f.prototype._isBuffer = !0),
|
|
(f.prototype.swap16 = function () {
|
|
var a = this.length;
|
|
if (a % 2 !== 0)
|
|
throw new RangeError(
|
|
'Buffer size must be a multiple of 16-bits',
|
|
);
|
|
for (var b = 0; b < a; b += 2) s(this, b, b + 1);
|
|
return this;
|
|
}),
|
|
(f.prototype.swap32 = function () {
|
|
var a = this.length;
|
|
if (a % 4 !== 0)
|
|
throw new RangeError(
|
|
'Buffer size must be a multiple of 32-bits',
|
|
);
|
|
for (var b = 0; b < a; b += 4)
|
|
s(this, b, b + 3), s(this, b + 1, b + 2);
|
|
return this;
|
|
}),
|
|
(f.prototype.swap64 = function () {
|
|
var a = this.length;
|
|
if (a % 8 !== 0)
|
|
throw new RangeError(
|
|
'Buffer size must be a multiple of 64-bits',
|
|
);
|
|
for (var b = 0; b < a; b += 8)
|
|
s(this, b, b + 7),
|
|
s(this, b + 1, b + 6),
|
|
s(this, b + 2, b + 5),
|
|
s(this, b + 3, b + 4);
|
|
return this;
|
|
}),
|
|
(f.prototype.toString = function () {
|
|
var a = this.length;
|
|
return 0 === a
|
|
? ''
|
|
: 0 === arguments.length
|
|
? C(this, 0, a)
|
|
: r.apply(this, arguments);
|
|
}),
|
|
(f.prototype.equals = function (a) {
|
|
if (!f.isBuffer(a))
|
|
throw new TypeError('Argument must be a Buffer');
|
|
return this === a || 0 === f.compare(this, a);
|
|
}),
|
|
(f.prototype.inspect = function () {
|
|
var a = '',
|
|
b = c.INSPECT_MAX_BYTES;
|
|
return (
|
|
this.length > 0 &&
|
|
((a = this.toString('hex', 0, b).match(/.{2}/g).join(' ')),
|
|
this.length > b && (a += ' ... ')),
|
|
'<Buffer ' + a + '>'
|
|
);
|
|
}),
|
|
(f.prototype.compare = function (a, b, c, d, e) {
|
|
if (!f.isBuffer(a))
|
|
throw new TypeError('Argument must be a Buffer');
|
|
if (
|
|
(void 0 === b && (b = 0),
|
|
void 0 === c && (c = a ? a.length : 0),
|
|
void 0 === d && (d = 0),
|
|
void 0 === e && (e = this.length),
|
|
b < 0 || c > a.length || d < 0 || e > this.length)
|
|
)
|
|
throw new RangeError('out of range index');
|
|
if (d >= e && b >= c) return 0;
|
|
if (d >= e) return -1;
|
|
if (b >= c) return 1;
|
|
if (((b >>>= 0), (c >>>= 0), (d >>>= 0), (e >>>= 0), this === a))
|
|
return 0;
|
|
for (
|
|
var g = e - d,
|
|
h = c - b,
|
|
i = Math.min(g, h),
|
|
j = this.slice(d, e),
|
|
k = a.slice(b, c),
|
|
l = 0;
|
|
l < i;
|
|
++l
|
|
)
|
|
if (j[l] !== k[l]) {
|
|
(g = j[l]), (h = k[l]);
|
|
break;
|
|
}
|
|
return g < h ? -1 : h < g ? 1 : 0;
|
|
}),
|
|
(f.prototype.includes = function (a, b, c) {
|
|
return this.indexOf(a, b, c) !== -1;
|
|
}),
|
|
(f.prototype.indexOf = function (a, b, c) {
|
|
return t(this, a, b, c, !0);
|
|
}),
|
|
(f.prototype.lastIndexOf = function (a, b, c) {
|
|
return t(this, a, b, c, !1);
|
|
}),
|
|
(f.prototype.write = function (a, b, c, d) {
|
|
if (void 0 === b) (d = 'utf8'), (c = this.length), (b = 0);
|
|
else if (void 0 === c && 'string' == typeof b)
|
|
(d = b), (c = this.length), (b = 0);
|
|
else {
|
|
if (!isFinite(b))
|
|
throw new Error(
|
|
'Buffer.write(string, encoding, offset[, length]) is no longer supported',
|
|
);
|
|
(b >>>= 0),
|
|
isFinite(c)
|
|
? ((c >>>= 0), void 0 === d && (d = 'utf8'))
|
|
: ((d = c), (c = void 0));
|
|
}
|
|
var e = this.length - b;
|
|
if (
|
|
((void 0 === c || c > e) && (c = e),
|
|
(a.length > 0 && (c < 0 || b < 0)) || b > this.length)
|
|
)
|
|
throw new RangeError('Attempt to write outside buffer bounds');
|
|
d || (d = 'utf8');
|
|
for (var f = !1; ; )
|
|
switch (d) {
|
|
case 'hex':
|
|
return v(this, a, b, c);
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return w(this, a, b, c);
|
|
case 'ascii':
|
|
return x(this, a, b, c);
|
|
case 'latin1':
|
|
case 'binary':
|
|
return y(this, a, b, c);
|
|
case 'base64':
|
|
return z(this, a, b, c);
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return A(this, a, b, c);
|
|
default:
|
|
if (f) throw new TypeError('Unknown encoding: ' + d);
|
|
(d = ('' + d).toLowerCase()), (f = !0);
|
|
}
|
|
}),
|
|
(f.prototype.toJSON = function () {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this._arr || this, 0),
|
|
};
|
|
});
|
|
var $ = 4096;
|
|
(f.prototype.slice = function (a, b) {
|
|
var c = this.length;
|
|
(a = ~~a),
|
|
(b = void 0 === b ? c : ~~b),
|
|
a < 0 ? ((a += c), a < 0 && (a = 0)) : a > c && (a = c),
|
|
b < 0 ? ((b += c), b < 0 && (b = 0)) : b > c && (b = c),
|
|
b < a && (b = a);
|
|
var d = this.subarray(a, b);
|
|
return (d.__proto__ = f.prototype), d;
|
|
}),
|
|
(f.prototype.readUIntLE = function (a, b, c) {
|
|
(a >>>= 0), (b >>>= 0), c || I(a, b, this.length);
|
|
for (var d = this[a], e = 1, f = 0; ++f < b && (e *= 256); )
|
|
d += this[a + f] * e;
|
|
return d;
|
|
}),
|
|
(f.prototype.readUIntBE = function (a, b, c) {
|
|
(a >>>= 0), (b >>>= 0), c || I(a, b, this.length);
|
|
for (var d = this[a + --b], e = 1; b > 0 && (e *= 256); )
|
|
d += this[a + --b] * e;
|
|
return d;
|
|
}),
|
|
(f.prototype.readUInt8 = function (a, b) {
|
|
return (a >>>= 0), b || I(a, 1, this.length), this[a];
|
|
}),
|
|
(f.prototype.readUInt16LE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 2, this.length),
|
|
this[a] | (this[a + 1] << 8)
|
|
);
|
|
}),
|
|
(f.prototype.readUInt16BE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 2, this.length),
|
|
(this[a] << 8) | this[a + 1]
|
|
);
|
|
}),
|
|
(f.prototype.readUInt32LE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 4, this.length),
|
|
(this[a] | (this[a + 1] << 8) | (this[a + 2] << 16)) +
|
|
16777216 * this[a + 3]
|
|
);
|
|
}),
|
|
(f.prototype.readUInt32BE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 4, this.length),
|
|
16777216 * this[a] +
|
|
((this[a + 1] << 16) | (this[a + 2] << 8) | this[a + 3])
|
|
);
|
|
}),
|
|
(f.prototype.readIntLE = function (a, b, c) {
|
|
(a >>>= 0), (b >>>= 0), c || I(a, b, this.length);
|
|
for (var d = this[a], e = 1, f = 0; ++f < b && (e *= 256); )
|
|
d += this[a + f] * e;
|
|
return (e *= 128), d >= e && (d -= Math.pow(2, 8 * b)), d;
|
|
}),
|
|
(f.prototype.readIntBE = function (a, b, c) {
|
|
(a >>>= 0), (b >>>= 0), c || I(a, b, this.length);
|
|
for (var d = b, e = 1, f = this[a + --d]; d > 0 && (e *= 256); )
|
|
f += this[a + --d] * e;
|
|
return (e *= 128), f >= e && (f -= Math.pow(2, 8 * b)), f;
|
|
}),
|
|
(f.prototype.readInt8 = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 1, this.length),
|
|
128 & this[a] ? (255 - this[a] + 1) * -1 : this[a]
|
|
);
|
|
}),
|
|
(f.prototype.readInt16LE = function (a, b) {
|
|
(a >>>= 0), b || I(a, 2, this.length);
|
|
var c = this[a] | (this[a + 1] << 8);
|
|
return 32768 & c ? 4294901760 | c : c;
|
|
}),
|
|
(f.prototype.readInt16BE = function (a, b) {
|
|
(a >>>= 0), b || I(a, 2, this.length);
|
|
var c = this[a + 1] | (this[a] << 8);
|
|
return 32768 & c ? 4294901760 | c : c;
|
|
}),
|
|
(f.prototype.readInt32LE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 4, this.length),
|
|
this[a] |
|
|
(this[a + 1] << 8) |
|
|
(this[a + 2] << 16) |
|
|
(this[a + 3] << 24)
|
|
);
|
|
}),
|
|
(f.prototype.readInt32BE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 4, this.length),
|
|
(this[a] << 24) |
|
|
(this[a + 1] << 16) |
|
|
(this[a + 2] << 8) |
|
|
this[a + 3]
|
|
);
|
|
}),
|
|
(f.prototype.readFloatLE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 4, this.length),
|
|
Y.read(this, a, !0, 23, 4)
|
|
);
|
|
}),
|
|
(f.prototype.readFloatBE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 4, this.length),
|
|
Y.read(this, a, !1, 23, 4)
|
|
);
|
|
}),
|
|
(f.prototype.readDoubleLE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 8, this.length),
|
|
Y.read(this, a, !0, 52, 8)
|
|
);
|
|
}),
|
|
(f.prototype.readDoubleBE = function (a, b) {
|
|
return (
|
|
(a >>>= 0),
|
|
b || I(a, 8, this.length),
|
|
Y.read(this, a, !1, 52, 8)
|
|
);
|
|
}),
|
|
(f.prototype.writeUIntLE = function (a, b, c, d) {
|
|
if (((a = +a), (b >>>= 0), (c >>>= 0), !d)) {
|
|
var e = Math.pow(2, 8 * c) - 1;
|
|
J(this, a, b, c, e, 0);
|
|
}
|
|
var f = 1,
|
|
g = 0;
|
|
for (this[b] = 255 & a; ++g < c && (f *= 256); )
|
|
this[b + g] = (a / f) & 255;
|
|
return b + c;
|
|
}),
|
|
(f.prototype.writeUIntBE = function (a, b, c, d) {
|
|
if (((a = +a), (b >>>= 0), (c >>>= 0), !d)) {
|
|
var e = Math.pow(2, 8 * c) - 1;
|
|
J(this, a, b, c, e, 0);
|
|
}
|
|
var f = c - 1,
|
|
g = 1;
|
|
for (this[b + f] = 255 & a; --f >= 0 && (g *= 256); )
|
|
this[b + f] = (a / g) & 255;
|
|
return b + c;
|
|
}),
|
|
(f.prototype.writeUInt8 = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 1, 255, 0),
|
|
(this[b] = 255 & a),
|
|
b + 1
|
|
);
|
|
}),
|
|
(f.prototype.writeUInt16LE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 2, 65535, 0),
|
|
(this[b] = 255 & a),
|
|
(this[b + 1] = a >>> 8),
|
|
b + 2
|
|
);
|
|
}),
|
|
(f.prototype.writeUInt16BE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 2, 65535, 0),
|
|
(this[b] = a >>> 8),
|
|
(this[b + 1] = 255 & a),
|
|
b + 2
|
|
);
|
|
}),
|
|
(f.prototype.writeUInt32LE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 4, 4294967295, 0),
|
|
(this[b + 3] = a >>> 24),
|
|
(this[b + 2] = a >>> 16),
|
|
(this[b + 1] = a >>> 8),
|
|
(this[b] = 255 & a),
|
|
b + 4
|
|
);
|
|
}),
|
|
(f.prototype.writeUInt32BE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 4, 4294967295, 0),
|
|
(this[b] = a >>> 24),
|
|
(this[b + 1] = a >>> 16),
|
|
(this[b + 2] = a >>> 8),
|
|
(this[b + 3] = 255 & a),
|
|
b + 4
|
|
);
|
|
}),
|
|
(f.prototype.writeIntLE = function (a, b, c, d) {
|
|
if (((a = +a), (b >>>= 0), !d)) {
|
|
var e = Math.pow(2, 8 * c - 1);
|
|
J(this, a, b, c, e - 1, -e);
|
|
}
|
|
var f = 0,
|
|
g = 1,
|
|
h = 0;
|
|
for (this[b] = 255 & a; ++f < c && (g *= 256); )
|
|
a < 0 && 0 === h && 0 !== this[b + f - 1] && (h = 1),
|
|
(this[b + f] = (((a / g) >> 0) - h) & 255);
|
|
return b + c;
|
|
}),
|
|
(f.prototype.writeIntBE = function (a, b, c, d) {
|
|
if (((a = +a), (b >>>= 0), !d)) {
|
|
var e = Math.pow(2, 8 * c - 1);
|
|
J(this, a, b, c, e - 1, -e);
|
|
}
|
|
var f = c - 1,
|
|
g = 1,
|
|
h = 0;
|
|
for (this[b + f] = 255 & a; --f >= 0 && (g *= 256); )
|
|
a < 0 && 0 === h && 0 !== this[b + f + 1] && (h = 1),
|
|
(this[b + f] = (((a / g) >> 0) - h) & 255);
|
|
return b + c;
|
|
}),
|
|
(f.prototype.writeInt8 = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 1, 127, -128),
|
|
a < 0 && (a = 255 + a + 1),
|
|
(this[b] = 255 & a),
|
|
b + 1
|
|
);
|
|
}),
|
|
(f.prototype.writeInt16LE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 2, 32767, -32768),
|
|
(this[b] = 255 & a),
|
|
(this[b + 1] = a >>> 8),
|
|
b + 2
|
|
);
|
|
}),
|
|
(f.prototype.writeInt16BE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 2, 32767, -32768),
|
|
(this[b] = a >>> 8),
|
|
(this[b + 1] = 255 & a),
|
|
b + 2
|
|
);
|
|
}),
|
|
(f.prototype.writeInt32LE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 4, 2147483647, -2147483648),
|
|
(this[b] = 255 & a),
|
|
(this[b + 1] = a >>> 8),
|
|
(this[b + 2] = a >>> 16),
|
|
(this[b + 3] = a >>> 24),
|
|
b + 4
|
|
);
|
|
}),
|
|
(f.prototype.writeInt32BE = function (a, b, c) {
|
|
return (
|
|
(a = +a),
|
|
(b >>>= 0),
|
|
c || J(this, a, b, 4, 2147483647, -2147483648),
|
|
a < 0 && (a = 4294967295 + a + 1),
|
|
(this[b] = a >>> 24),
|
|
(this[b + 1] = a >>> 16),
|
|
(this[b + 2] = a >>> 8),
|
|
(this[b + 3] = 255 & a),
|
|
b + 4
|
|
);
|
|
}),
|
|
(f.prototype.writeFloatLE = function (a, b, c) {
|
|
return L(this, a, b, !0, c);
|
|
}),
|
|
(f.prototype.writeFloatBE = function (a, b, c) {
|
|
return L(this, a, b, !1, c);
|
|
}),
|
|
(f.prototype.writeDoubleLE = function (a, b, c) {
|
|
return M(this, a, b, !0, c);
|
|
}),
|
|
(f.prototype.writeDoubleBE = function (a, b, c) {
|
|
return M(this, a, b, !1, c);
|
|
}),
|
|
(f.prototype.copy = function (a, b, c, d) {
|
|
if (
|
|
(c || (c = 0),
|
|
d || 0 === d || (d = this.length),
|
|
b >= a.length && (b = a.length),
|
|
b || (b = 0),
|
|
d > 0 && d < c && (d = c),
|
|
d === c)
|
|
)
|
|
return 0;
|
|
if (0 === a.length || 0 === this.length) return 0;
|
|
if (b < 0) throw new RangeError('targetStart out of bounds');
|
|
if (c < 0 || c >= this.length)
|
|
throw new RangeError('sourceStart out of bounds');
|
|
if (d < 0) throw new RangeError('sourceEnd out of bounds');
|
|
d > this.length && (d = this.length),
|
|
a.length - b < d - c && (d = a.length - b + c);
|
|
var e,
|
|
f = d - c;
|
|
if (this === a && c < b && b < d)
|
|
for (e = f - 1; e >= 0; --e) a[e + b] = this[e + c];
|
|
else if (f < 1e3) for (e = 0; e < f; ++e) a[e + b] = this[e + c];
|
|
else Uint8Array.prototype.set.call(a, this.subarray(c, c + f), b);
|
|
return f;
|
|
}),
|
|
(f.prototype.fill = function (a, b, c, d) {
|
|
if ('string' == typeof a) {
|
|
if (
|
|
('string' == typeof b
|
|
? ((d = b), (b = 0), (c = this.length))
|
|
: 'string' == typeof c && ((d = c), (c = this.length)),
|
|
1 === a.length)
|
|
) {
|
|
var e = a.charCodeAt(0);
|
|
e < 256 && (a = e);
|
|
}
|
|
if (void 0 !== d && 'string' != typeof d)
|
|
throw new TypeError('encoding must be a string');
|
|
if ('string' == typeof d && !f.isEncoding(d))
|
|
throw new TypeError('Unknown encoding: ' + d);
|
|
} else 'number' == typeof a && (a = 255 & a);
|
|
if (b < 0 || this.length < b || this.length < c)
|
|
throw new RangeError('Out of range index');
|
|
if (c <= b) return this;
|
|
(b >>>= 0),
|
|
(c = void 0 === c ? this.length : c >>> 0),
|
|
a || (a = 0);
|
|
var g;
|
|
if ('number' == typeof a) for (g = b; g < c; ++g) this[g] = a;
|
|
else {
|
|
var h = f.isBuffer(a) ? a : new f(a, d),
|
|
i = h.length;
|
|
for (g = 0; g < c - b; ++g) this[g + b] = h[g % i];
|
|
}
|
|
return this;
|
|
});
|
|
var _ = /[^+\/0-9A-Za-z-_]/g;
|
|
},
|
|
{ 'base64-js': 100, ieee754: 103 },
|
|
],
|
|
102: [
|
|
function (a, b, c) {
|
|
(function (a) {
|
|
var c = (function () {
|
|
'use strict';
|
|
function b(a, b) {
|
|
return null != b && a instanceof b;
|
|
}
|
|
function c(d, e, f, g, j) {
|
|
function m(d, f) {
|
|
if (null === d) return null;
|
|
if (0 === f) return d;
|
|
var q, r;
|
|
if ('object' != typeof d) return d;
|
|
if (b(d, i)) q = new i();
|
|
else if (b(d, k)) q = new k();
|
|
else if (b(d, l))
|
|
q = new l(function (a, b) {
|
|
d.then(
|
|
function (b) {
|
|
a(m(b, f - 1));
|
|
},
|
|
function (a) {
|
|
b(m(a, f - 1));
|
|
},
|
|
);
|
|
});
|
|
else if (c.__isArray(d)) q = [];
|
|
else if (c.__isRegExp(d))
|
|
(q = new RegExp(d.source, h(d))),
|
|
d.lastIndex && (q.lastIndex = d.lastIndex);
|
|
else if (c.__isDate(d)) q = new Date(d.getTime());
|
|
else {
|
|
if (p && a.isBuffer(d))
|
|
return (
|
|
(q = a.allocUnsafe
|
|
? a.allocUnsafe(d.length)
|
|
: new a(d.length)),
|
|
d.copy(q),
|
|
q
|
|
);
|
|
b(d, Error)
|
|
? (q = Object.create(d))
|
|
: 'undefined' == typeof g
|
|
? ((r = Object.getPrototypeOf(d)), (q = Object.create(r)))
|
|
: ((q = Object.create(g)), (r = g));
|
|
}
|
|
if (e) {
|
|
var s = n.indexOf(d);
|
|
if (s != -1) return o[s];
|
|
n.push(d), o.push(q);
|
|
}
|
|
b(d, i) &&
|
|
d.forEach(function (a, b) {
|
|
var c = m(b, f - 1),
|
|
d = m(a, f - 1);
|
|
q.set(c, d);
|
|
}),
|
|
b(d, k) &&
|
|
d.forEach(function (a) {
|
|
var b = m(a, f - 1);
|
|
q.add(b);
|
|
});
|
|
for (var t in d) {
|
|
var u;
|
|
r && (u = Object.getOwnPropertyDescriptor(r, t)),
|
|
(u && null == u.set) || (q[t] = m(d[t], f - 1));
|
|
}
|
|
if (Object.getOwnPropertySymbols)
|
|
for (
|
|
var v = Object.getOwnPropertySymbols(d), t = 0;
|
|
t < v.length;
|
|
t++
|
|
) {
|
|
var w = v[t],
|
|
x = Object.getOwnPropertyDescriptor(d, w);
|
|
(!x || x.enumerable || j) &&
|
|
((q[w] = m(d[w], f - 1)),
|
|
x.enumerable ||
|
|
Object.defineProperty(q, w, { enumerable: !1 }));
|
|
}
|
|
if (j)
|
|
for (
|
|
var y = Object.getOwnPropertyNames(d), t = 0;
|
|
t < y.length;
|
|
t++
|
|
) {
|
|
var z = y[t],
|
|
x = Object.getOwnPropertyDescriptor(d, z);
|
|
(x && x.enumerable) ||
|
|
((q[z] = m(d[z], f - 1)),
|
|
Object.defineProperty(q, z, { enumerable: !1 }));
|
|
}
|
|
return q;
|
|
}
|
|
'object' == typeof e &&
|
|
((f = e.depth),
|
|
(g = e.prototype),
|
|
(j = e.includeNonEnumerable),
|
|
(e = e.circular));
|
|
var n = [],
|
|
o = [],
|
|
p = 'undefined' != typeof a;
|
|
return (
|
|
'undefined' == typeof e && (e = !0),
|
|
'undefined' == typeof f && (f = 1 / 0),
|
|
m(d, f)
|
|
);
|
|
}
|
|
function d(a) {
|
|
return Object.prototype.toString.call(a);
|
|
}
|
|
function e(a) {
|
|
return 'object' == typeof a && '[object Date]' === d(a);
|
|
}
|
|
function f(a) {
|
|
return 'object' == typeof a && '[object Array]' === d(a);
|
|
}
|
|
function g(a) {
|
|
return 'object' == typeof a && '[object RegExp]' === d(a);
|
|
}
|
|
function h(a) {
|
|
var b = '';
|
|
return (
|
|
a.global && (b += 'g'),
|
|
a.ignoreCase && (b += 'i'),
|
|
a.multiline && (b += 'm'),
|
|
b
|
|
);
|
|
}
|
|
var i;
|
|
try {
|
|
i = Map;
|
|
} catch (j) {
|
|
i = function () {};
|
|
}
|
|
var k;
|
|
try {
|
|
k = Set;
|
|
} catch (j) {
|
|
k = function () {};
|
|
}
|
|
var l;
|
|
try {
|
|
l = Promise;
|
|
} catch (j) {
|
|
l = function () {};
|
|
}
|
|
return (
|
|
(c.clonePrototype = function (a) {
|
|
if (null === a) return null;
|
|
var b = function () {};
|
|
return (b.prototype = a), new b();
|
|
}),
|
|
(c.__objToStr = d),
|
|
(c.__isDate = e),
|
|
(c.__isArray = f),
|
|
(c.__isRegExp = g),
|
|
(c.__getRegExpFlags = h),
|
|
c
|
|
);
|
|
})();
|
|
'object' == typeof b && b.exports && (b.exports = c);
|
|
}.call(this, a('buffer').Buffer));
|
|
},
|
|
{ buffer: 101 },
|
|
],
|
|
103: [
|
|
function (a, b, c) {
|
|
(c.read = function (a, b, c, d, e) {
|
|
var f,
|
|
g,
|
|
h = 8 * e - d - 1,
|
|
i = (1 << h) - 1,
|
|
j = i >> 1,
|
|
k = -7,
|
|
l = c ? e - 1 : 0,
|
|
m = c ? -1 : 1,
|
|
n = a[b + l];
|
|
for (
|
|
l += m, f = n & ((1 << -k) - 1), n >>= -k, k += h;
|
|
k > 0;
|
|
f = 256 * f + a[b + l], l += m, k -= 8
|
|
);
|
|
for (
|
|
g = f & ((1 << -k) - 1), f >>= -k, k += d;
|
|
k > 0;
|
|
g = 256 * g + a[b + l], l += m, k -= 8
|
|
);
|
|
if (0 === f) f = 1 - j;
|
|
else {
|
|
if (f === i) return g ? NaN : (n ? -1 : 1) * (1 / 0);
|
|
(g += Math.pow(2, d)), (f -= j);
|
|
}
|
|
return (n ? -1 : 1) * g * Math.pow(2, f - d);
|
|
}),
|
|
(c.write = function (a, b, c, d, e, f) {
|
|
var g,
|
|
h,
|
|
i,
|
|
j = 8 * f - e - 1,
|
|
k = (1 << j) - 1,
|
|
l = k >> 1,
|
|
m = 23 === e ? Math.pow(2, -24) - Math.pow(2, -77) : 0,
|
|
n = d ? 0 : f - 1,
|
|
o = d ? 1 : -1,
|
|
p = b < 0 || (0 === b && 1 / b < 0) ? 1 : 0;
|
|
for (
|
|
b = Math.abs(b),
|
|
isNaN(b) || b === 1 / 0
|
|
? ((h = isNaN(b) ? 1 : 0), (g = k))
|
|
: ((g = Math.floor(Math.log(b) / Math.LN2)),
|
|
b * (i = Math.pow(2, -g)) < 1 && (g--, (i *= 2)),
|
|
(b += g + l >= 1 ? m / i : m * Math.pow(2, 1 - l)),
|
|
b * i >= 2 && (g++, (i /= 2)),
|
|
g + l >= k
|
|
? ((h = 0), (g = k))
|
|
: g + l >= 1
|
|
? ((h = (b * i - 1) * Math.pow(2, e)), (g += l))
|
|
: ((h = b * Math.pow(2, l - 1) * Math.pow(2, e)),
|
|
(g = 0)));
|
|
e >= 8;
|
|
a[c + n] = 255 & h, n += o, h /= 256, e -= 8
|
|
);
|
|
for (
|
|
g = (g << e) | h, j += e;
|
|
j > 0;
|
|
a[c + n] = 255 & g, n += o, g /= 256, j -= 8
|
|
);
|
|
a[c + n - o] |= 128 * p;
|
|
});
|
|
},
|
|
{},
|
|
],
|
|
104: [
|
|
function (a, b, c) {
|
|
'use strict';
|
|
function d() {}
|
|
function e(a) {
|
|
try {
|
|
return a.then;
|
|
} catch (b) {
|
|
return (r = b), s;
|
|
}
|
|
}
|
|
function f(a, b) {
|
|
try {
|
|
return a(b);
|
|
} catch (c) {
|
|
return (r = c), s;
|
|
}
|
|
}
|
|
function g(a, b, c) {
|
|
try {
|
|
a(b, c);
|
|
} catch (d) {
|
|
return (r = d), s;
|
|
}
|
|
}
|
|
function h(a) {
|
|
if ('object' != typeof this)
|
|
throw new TypeError('Promises must be constructed via new');
|
|
if ('function' != typeof a)
|
|
throw new TypeError(
|
|
"Promise constructor's argument is not a function",
|
|
);
|
|
(this._40 = 0),
|
|
(this._65 = 0),
|
|
(this._55 = null),
|
|
(this._72 = null),
|
|
a !== d && p(a, this);
|
|
}
|
|
function i(a, b, c) {
|
|
return new a.constructor(function (e, f) {
|
|
var g = new h(d);
|
|
g.then(e, f), j(a, new o(b, c, g));
|
|
});
|
|
}
|
|
function j(a, b) {
|
|
for (; 3 === a._65; ) a = a._55;
|
|
return (
|
|
h._37 && h._37(a),
|
|
0 === a._65
|
|
? 0 === a._40
|
|
? ((a._40 = 1), void (a._72 = b))
|
|
: 1 === a._40
|
|
? ((a._40 = 2), void (a._72 = [a._72, b]))
|
|
: void a._72.push(b)
|
|
: void k(a, b)
|
|
);
|
|
}
|
|
function k(a, b) {
|
|
q(function () {
|
|
var c = 1 === a._65 ? b.onFulfilled : b.onRejected;
|
|
if (null === c)
|
|
return void (1 === a._65
|
|
? l(b.promise, a._55)
|
|
: m(b.promise, a._55));
|
|
var d = f(c, a._55);
|
|
d === s ? m(b.promise, r) : l(b.promise, d);
|
|
});
|
|
}
|
|
function l(a, b) {
|
|
if (b === a)
|
|
return m(
|
|
a,
|
|
new TypeError('A promise cannot be resolved with itself.'),
|
|
);
|
|
if (b && ('object' == typeof b || 'function' == typeof b)) {
|
|
var c = e(b);
|
|
if (c === s) return m(a, r);
|
|
if (c === a.then && b instanceof h)
|
|
return (a._65 = 3), (a._55 = b), void n(a);
|
|
if ('function' == typeof c) return void p(c.bind(b), a);
|
|
}
|
|
(a._65 = 1), (a._55 = b), n(a);
|
|
}
|
|
function m(a, b) {
|
|
(a._65 = 2), (a._55 = b), h._87 && h._87(a, b), n(a);
|
|
}
|
|
function n(a) {
|
|
if ((1 === a._40 && (j(a, a._72), (a._72 = null)), 2 === a._40)) {
|
|
for (var b = 0; b < a._72.length; b++) j(a, a._72[b]);
|
|
a._72 = null;
|
|
}
|
|
}
|
|
function o(a, b, c) {
|
|
(this.onFulfilled = 'function' == typeof a ? a : null),
|
|
(this.onRejected = 'function' == typeof b ? b : null),
|
|
(this.promise = c);
|
|
}
|
|
function p(a, b) {
|
|
var c = !1,
|
|
d = g(
|
|
a,
|
|
function (a) {
|
|
c || ((c = !0), l(b, a));
|
|
},
|
|
function (a) {
|
|
c || ((c = !0), m(b, a));
|
|
},
|
|
);
|
|
c || d !== s || ((c = !0), m(b, r));
|
|
}
|
|
var q = a('asap/raw'),
|
|
r = null,
|
|
s = {};
|
|
(b.exports = h),
|
|
(h._37 = null),
|
|
(h._87 = null),
|
|
(h._61 = d),
|
|
(h.prototype.then = function (a, b) {
|
|
if (this.constructor !== h) return i(this, a, b);
|
|
var c = new h(d);
|
|
return j(this, new o(a, b, c)), c;
|
|
});
|
|
},
|
|
{ 'asap/raw': 99 },
|
|
],
|
|
105: [
|
|
function (a, b, c) {
|
|
'use strict';
|
|
function d(a) {
|
|
var b = new e(e._61);
|
|
return (b._65 = 1), (b._55 = a), b;
|
|
}
|
|
var e = a('./core.js');
|
|
b.exports = e;
|
|
var f = d(!0),
|
|
g = d(!1),
|
|
h = d(null),
|
|
i = d(void 0),
|
|
j = d(0),
|
|
k = d('');
|
|
(e.resolve = function (a) {
|
|
if (a instanceof e) return a;
|
|
if (null === a) return h;
|
|
if (void 0 === a) return i;
|
|
if (a === !0) return f;
|
|
if (a === !1) return g;
|
|
if (0 === a) return j;
|
|
if ('' === a) return k;
|
|
if ('object' == typeof a || 'function' == typeof a)
|
|
try {
|
|
var b = a.then;
|
|
if ('function' == typeof b) return new e(b.bind(a));
|
|
} catch (c) {
|
|
return new e(function (a, b) {
|
|
b(c);
|
|
});
|
|
}
|
|
return d(a);
|
|
}),
|
|
(e.all = function (a) {
|
|
var b = Array.prototype.slice.call(a);
|
|
return new e(function (a, c) {
|
|
function d(g, h) {
|
|
if (h && ('object' == typeof h || 'function' == typeof h)) {
|
|
if (h instanceof e && h.then === e.prototype.then) {
|
|
for (; 3 === h._65; ) h = h._55;
|
|
return 1 === h._65
|
|
? d(g, h._55)
|
|
: (2 === h._65 && c(h._55),
|
|
void h.then(function (a) {
|
|
d(g, a);
|
|
}, c));
|
|
}
|
|
var i = h.then;
|
|
if ('function' == typeof i) {
|
|
var j = new e(i.bind(h));
|
|
return void j.then(function (a) {
|
|
d(g, a);
|
|
}, c);
|
|
}
|
|
}
|
|
(b[g] = h), 0 === --f && a(b);
|
|
}
|
|
if (0 === b.length) return a([]);
|
|
for (var f = b.length, g = 0; g < b.length; g++) d(g, b[g]);
|
|
});
|
|
}),
|
|
(e.reject = function (a) {
|
|
return new e(function (b, c) {
|
|
c(a);
|
|
});
|
|
}),
|
|
(e.race = function (a) {
|
|
return new e(function (b, c) {
|
|
a.forEach(function (a) {
|
|
e.resolve(a).then(b, c);
|
|
});
|
|
});
|
|
}),
|
|
(e.prototype['catch'] = function (a) {
|
|
return this.then(null, a);
|
|
});
|
|
},
|
|
{ './core.js': 104 },
|
|
],
|
|
106: [
|
|
function (a, b, c) {
|
|
'function' != typeof Promise.prototype.done &&
|
|
(Promise.prototype.done = function (a, b) {
|
|
var c = arguments.length
|
|
? this.then.apply(this, arguments)
|
|
: this;
|
|
c.then(null, function (a) {
|
|
setTimeout(function () {
|
|
throw a;
|
|
}, 0);
|
|
});
|
|
});
|
|
},
|
|
{},
|
|
],
|
|
107: [
|
|
function (a, b, c) {
|
|
a('asap');
|
|
'undefined' == typeof Promise &&
|
|
((Promise = a('./lib/core.js')), a('./lib/es6-extensions.js')),
|
|
a('./polyfill-done.js');
|
|
},
|
|
{
|
|
'./lib/core.js': 104,
|
|
'./lib/es6-extensions.js': 105,
|
|
'./polyfill-done.js': 106,
|
|
asap: 98,
|
|
},
|
|
],
|
|
},
|
|
{},
|
|
[2],
|
|
)(2);
|
|
});
|