359 lines
6.8 KiB
JavaScript
359 lines
6.8 KiB
JavaScript
|
|
import { parsers, colorProfiles, getMode } from './modes.js';
|
||
|
|
|
||
|
|
/* eslint-disable-next-line no-control-regex */
|
||
|
|
const IdentStartCodePoint = /[^\x00-\x7F]|[a-zA-Z_]/;
|
||
|
|
|
||
|
|
/* eslint-disable-next-line no-control-regex */
|
||
|
|
const IdentCodePoint = /[^\x00-\x7F]|[-\w]/;
|
||
|
|
|
||
|
|
export const Tok = {
|
||
|
|
Function: 'function',
|
||
|
|
Ident: 'ident',
|
||
|
|
Number: 'number',
|
||
|
|
Percentage: 'percentage',
|
||
|
|
ParenClose: ')',
|
||
|
|
None: 'none',
|
||
|
|
Hue: 'hue',
|
||
|
|
Alpha: 'alpha'
|
||
|
|
};
|
||
|
|
|
||
|
|
let _i = 0;
|
||
|
|
|
||
|
|
/*
|
||
|
|
4.3.10. Check if three code points would start a number
|
||
|
|
https://drafts.csswg.org/css-syntax/#starts-with-a-number
|
||
|
|
*/
|
||
|
|
function is_num(chars) {
|
||
|
|
let ch = chars[_i];
|
||
|
|
let ch1 = chars[_i + 1];
|
||
|
|
if (ch === '-' || ch === '+') {
|
||
|
|
return /\d/.test(ch1) || (ch1 === '.' && /\d/.test(chars[_i + 2]));
|
||
|
|
}
|
||
|
|
if (ch === '.') {
|
||
|
|
return /\d/.test(ch1);
|
||
|
|
}
|
||
|
|
return /\d/.test(ch);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Check if the stream starts with an identifier.
|
||
|
|
*/
|
||
|
|
|
||
|
|
function is_ident(chars) {
|
||
|
|
if (_i >= chars.length) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
let ch = chars[_i];
|
||
|
|
if (IdentStartCodePoint.test(ch)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (ch === '-') {
|
||
|
|
if (chars.length - _i < 2) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
let ch1 = chars[_i + 1];
|
||
|
|
if (ch1 === '-' || IdentStartCodePoint.test(ch1)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
4.3.3. Consume a numeric token
|
||
|
|
https://drafts.csswg.org/css-syntax/#consume-numeric-token
|
||
|
|
*/
|
||
|
|
|
||
|
|
const huenits = {
|
||
|
|
deg: 1,
|
||
|
|
rad: 180 / Math.PI,
|
||
|
|
grad: 9 / 10,
|
||
|
|
turn: 360
|
||
|
|
};
|
||
|
|
|
||
|
|
function num(chars) {
|
||
|
|
let value = '';
|
||
|
|
if (chars[_i] === '-' || chars[_i] === '+') {
|
||
|
|
value += chars[_i++];
|
||
|
|
}
|
||
|
|
value += digits(chars);
|
||
|
|
if (chars[_i] === '.' && /\d/.test(chars[_i + 1])) {
|
||
|
|
value += chars[_i++] + digits(chars);
|
||
|
|
}
|
||
|
|
if (chars[_i] === 'e' || chars[_i] === 'E') {
|
||
|
|
if (
|
||
|
|
(chars[_i + 1] === '-' || chars[_i + 1] === '+') &&
|
||
|
|
/\d/.test(chars[_i + 2])
|
||
|
|
) {
|
||
|
|
value += chars[_i++] + chars[_i++] + digits(chars);
|
||
|
|
} else if (/\d/.test(chars[_i + 1])) {
|
||
|
|
value += chars[_i++] + digits(chars);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (is_ident(chars)) {
|
||
|
|
let id = ident(chars);
|
||
|
|
if (id === 'deg' || id === 'rad' || id === 'turn' || id === 'grad') {
|
||
|
|
return { type: Tok.Hue, value: value * huenits[id] };
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
if (chars[_i] === '%') {
|
||
|
|
_i++;
|
||
|
|
return { type: Tok.Percentage, value: +value };
|
||
|
|
}
|
||
|
|
return { type: Tok.Number, value: +value };
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Consume digits.
|
||
|
|
*/
|
||
|
|
function digits(chars) {
|
||
|
|
let v = '';
|
||
|
|
while (/\d/.test(chars[_i])) {
|
||
|
|
v += chars[_i++];
|
||
|
|
}
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Consume an identifier.
|
||
|
|
*/
|
||
|
|
function ident(chars) {
|
||
|
|
let v = '';
|
||
|
|
while (_i < chars.length && IdentCodePoint.test(chars[_i])) {
|
||
|
|
v += chars[_i++];
|
||
|
|
}
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Consume an ident-like token.
|
||
|
|
*/
|
||
|
|
function identlike(chars) {
|
||
|
|
let v = ident(chars);
|
||
|
|
if (chars[_i] === '(') {
|
||
|
|
_i++;
|
||
|
|
return { type: Tok.Function, value: v };
|
||
|
|
}
|
||
|
|
if (v === 'none') {
|
||
|
|
return { type: Tok.None, value: undefined };
|
||
|
|
}
|
||
|
|
return { type: Tok.Ident, value: v };
|
||
|
|
}
|
||
|
|
|
||
|
|
export function tokenize(str = '') {
|
||
|
|
let chars = str.trim();
|
||
|
|
let tokens = [];
|
||
|
|
let ch;
|
||
|
|
|
||
|
|
/* reset counter */
|
||
|
|
_i = 0;
|
||
|
|
|
||
|
|
while (_i < chars.length) {
|
||
|
|
ch = chars[_i++];
|
||
|
|
|
||
|
|
/*
|
||
|
|
Consume whitespace without emitting it
|
||
|
|
*/
|
||
|
|
if (ch === '\n' || ch === '\t' || ch === ' ') {
|
||
|
|
while (
|
||
|
|
_i < chars.length &&
|
||
|
|
(chars[_i] === '\n' || chars[_i] === '\t' || chars[_i] === ' ')
|
||
|
|
) {
|
||
|
|
_i++;
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ch === ',') {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ch === ')') {
|
||
|
|
tokens.push({ type: Tok.ParenClose });
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ch === '+') {
|
||
|
|
_i--;
|
||
|
|
if (is_num(chars)) {
|
||
|
|
tokens.push(num(chars));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ch === '-') {
|
||
|
|
_i--;
|
||
|
|
if (is_num(chars)) {
|
||
|
|
tokens.push(num(chars));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (is_ident(chars)) {
|
||
|
|
tokens.push({ type: Tok.Ident, value: ident(chars) });
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ch === '.') {
|
||
|
|
_i--;
|
||
|
|
if (is_num(chars)) {
|
||
|
|
tokens.push(num(chars));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ch === '/') {
|
||
|
|
while (
|
||
|
|
_i < chars.length &&
|
||
|
|
(chars[_i] === '\n' || chars[_i] === '\t' || chars[_i] === ' ')
|
||
|
|
) {
|
||
|
|
_i++;
|
||
|
|
}
|
||
|
|
let alpha;
|
||
|
|
if (is_num(chars)) {
|
||
|
|
alpha = num(chars);
|
||
|
|
if (alpha.type !== Tok.Hue) {
|
||
|
|
tokens.push({ type: Tok.Alpha, value: alpha });
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (is_ident(chars)) {
|
||
|
|
if (ident(chars) === 'none') {
|
||
|
|
tokens.push({
|
||
|
|
type: Tok.Alpha,
|
||
|
|
value: { type: Tok.None, value: undefined }
|
||
|
|
});
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (/\d/.test(ch)) {
|
||
|
|
_i--;
|
||
|
|
tokens.push(num(chars));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (IdentStartCodePoint.test(ch)) {
|
||
|
|
_i--;
|
||
|
|
tokens.push(identlike(chars));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Treat everything not already handled as an error.
|
||
|
|
*/
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
return tokens;
|
||
|
|
}
|
||
|
|
|
||
|
|
export function parseColorSyntax(tokens) {
|
||
|
|
tokens._i = 0;
|
||
|
|
let token = tokens[tokens._i++];
|
||
|
|
if (!token || token.type !== Tok.Function || token.value !== 'color') {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
token = tokens[tokens._i++];
|
||
|
|
if (token.type !== Tok.Ident) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const mode = colorProfiles[token.value];
|
||
|
|
if (!mode) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const res = { mode };
|
||
|
|
const coords = consumeCoords(tokens, false);
|
||
|
|
if (!coords) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const channels = getMode(mode).channels;
|
||
|
|
for (let ii = 0, c; ii < channels.length; ii++) {
|
||
|
|
c = coords[ii];
|
||
|
|
if (c.type !== Tok.None) {
|
||
|
|
res[channels[ii]] = c.type === Tok.Number ? c.value : c.value / 100;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
|
||
|
|
function consumeCoords(tokens, includeHue) {
|
||
|
|
const coords = [];
|
||
|
|
let token;
|
||
|
|
while (tokens._i < tokens.length) {
|
||
|
|
token = tokens[tokens._i++];
|
||
|
|
if (
|
||
|
|
token.type === Tok.None ||
|
||
|
|
token.type === Tok.Number ||
|
||
|
|
token.type === Tok.Alpha ||
|
||
|
|
token.type === Tok.Percentage ||
|
||
|
|
(includeHue && token.type === Tok.Hue)
|
||
|
|
) {
|
||
|
|
coords.push(token);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (token.type === Tok.ParenClose) {
|
||
|
|
if (tokens._i < tokens.length) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (coords.length < 3 || coords.length > 4) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (coords.length === 4) {
|
||
|
|
if (coords[3].type !== Tok.Alpha) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
coords[3] = coords[3].value;
|
||
|
|
}
|
||
|
|
if (coords.length === 3) {
|
||
|
|
coords.push({ type: Tok.None, value: undefined });
|
||
|
|
}
|
||
|
|
|
||
|
|
return coords.every(c => c.type !== Tok.Alpha) ? coords : undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
export function parseModernSyntax(tokens, includeHue) {
|
||
|
|
tokens._i = 0;
|
||
|
|
let token = tokens[tokens._i++];
|
||
|
|
if (!token || token.type !== Tok.Function) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
let coords = consumeCoords(tokens, includeHue);
|
||
|
|
if (!coords) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
coords.unshift(token.value);
|
||
|
|
return coords;
|
||
|
|
}
|
||
|
|
|
||
|
|
const parse = color => {
|
||
|
|
if (typeof color !== 'string') {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const tokens = tokenize(color);
|
||
|
|
const parsed = tokens ? parseModernSyntax(tokens, true) : undefined;
|
||
|
|
let result = undefined;
|
||
|
|
let i = 0;
|
||
|
|
let len = parsers.length;
|
||
|
|
while (i < len) {
|
||
|
|
if ((result = parsers[i++](color, parsed)) !== undefined) {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return tokens ? parseColorSyntax(tokens) : undefined;
|
||
|
|
};
|
||
|
|
|
||
|
|
export default parse;
|