File Manager

Edit File: parse.js

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.
 */

/*
	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
};

/*
	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;
}

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;
}

export default parse;

Back