File: /var/www/api-management/node_modules/parseley/lib/parseley.cjs
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var leac = require('leac');
var p = require('peberminta');
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var p__namespace = /*#__PURE__*/_interopNamespace(p);
var ast = /*#__PURE__*/Object.freeze({
__proto__: null
});
const ws = `(?:[ \\t\\r\\n\\f]*)`;
const nl = `(?:\\n|\\r\\n|\\r|\\f)`;
const nonascii = `[^\\x00-\\x7F]`;
const unicode = `(?:\\\\[0-9a-f]{1,6}(?:\\r\\n|[ \\n\\r\\t\\f])?)`;
const escape = `(?:\\\\[^\\n\\r\\f0-9a-f])`;
const nmstart = `(?:[_a-z]|${nonascii}|${unicode}|${escape})`;
const nmchar = `(?:[_a-z0-9-]|${nonascii}|${unicode}|${escape})`;
const name = `(?:${nmchar}+)`;
const ident = `(?:[-]?${nmstart}${nmchar}*)`;
const string1 = `'([^\\n\\r\\f\\\\']|\\\\${nl}|${nonascii}|${unicode}|${escape})*'`;
const string2 = `"([^\\n\\r\\f\\\\"]|\\\\${nl}|${nonascii}|${unicode}|${escape})*"`;
const lexSelector = leac.createLexer([
{ name: 'ws', regex: new RegExp(ws) },
{ name: 'hash', regex: new RegExp(`#${name}`, 'i') },
{ name: 'ident', regex: new RegExp(ident, 'i') },
{ name: 'str1', regex: new RegExp(string1, 'i') },
{ name: 'str2', regex: new RegExp(string2, 'i') },
{ name: '*' },
{ name: '.' },
{ name: ',' },
{ name: '[' },
{ name: ']' },
{ name: '=' },
{ name: '>' },
{ name: '|' },
{ name: '+' },
{ name: '~' },
{ name: '^' },
{ name: '$' },
]);
const lexEscapedString = leac.createLexer([
{ name: 'unicode', regex: new RegExp(unicode, 'i') },
{ name: 'escape', regex: new RegExp(escape, 'i') },
{ name: 'any', regex: new RegExp('[\\s\\S]', 'i') }
]);
function sumSpec([a0, a1, a2], [b0, b1, b2]) {
return [a0 + b0, a1 + b1, a2 + b2];
}
function sumAllSpec(ss) {
return ss.reduce(sumSpec, [0, 0, 0]);
}
const unicodeEscapedSequence_ = p__namespace.token((t) => t.name === 'unicode' ? String.fromCodePoint(parseInt(t.text.slice(1), 16)) : undefined);
const escapedSequence_ = p__namespace.token((t) => t.name === 'escape' ? t.text.slice(1) : undefined);
const anyChar_ = p__namespace.token((t) => t.name === 'any' ? t.text : undefined);
const escapedString_ = p__namespace.map(p__namespace.many(p__namespace.or(unicodeEscapedSequence_, escapedSequence_, anyChar_)), (cs) => cs.join(''));
function unescape(escapedString) {
const lexerResult = lexEscapedString(escapedString);
const result = escapedString_({ tokens: lexerResult.tokens, options: undefined }, 0);
return result.value;
}
function literal(name) {
return p__namespace.token((t) => t.name === name ? true : undefined);
}
const whitespace_ = p__namespace.token((t) => t.name === 'ws' ? null : undefined);
const optionalWhitespace_ = p__namespace.option(whitespace_, null);
function optionallySpaced(parser) {
return p__namespace.middle(optionalWhitespace_, parser, optionalWhitespace_);
}
const identifier_ = p__namespace.token((t) => t.name === 'ident' ? unescape(t.text) : undefined);
const hashId_ = p__namespace.token((t) => t.name === 'hash' ? unescape(t.text.slice(1)) : undefined);
const string_ = p__namespace.token((t) => t.name.startsWith('str') ? unescape(t.text.slice(1, -1)) : undefined);
const namespace_ = p__namespace.left(p__namespace.option(identifier_, ''), literal('|'));
const qualifiedName_ = p__namespace.eitherOr(p__namespace.ab(namespace_, identifier_, (ns, name) => ({ name: name, namespace: ns })), p__namespace.map(identifier_, (name) => ({ name: name, namespace: null })));
const uniSelector_ = p__namespace.eitherOr(p__namespace.ab(namespace_, literal('*'), (ns) => ({ type: 'universal', namespace: ns, specificity: [0, 0, 0] })), p__namespace.map(literal('*'), () => ({ type: 'universal', namespace: null, specificity: [0, 0, 0] })));
const tagSelector_ = p__namespace.map(qualifiedName_, ({ name, namespace }) => ({
type: 'tag',
name: name,
namespace: namespace,
specificity: [0, 0, 1]
}));
const classSelector_ = p__namespace.ab(literal('.'), identifier_, (fullstop, name) => ({
type: 'class',
name: name,
specificity: [0, 1, 0]
}));
const idSelector_ = p__namespace.map(hashId_, (name) => ({
type: 'id',
name: name,
specificity: [1, 0, 0]
}));
const attrModifier_ = p__namespace.token((t) => {
if (t.name === 'ident') {
if (t.text === 'i' || t.text === 'I') {
return 'i';
}
if (t.text === 's' || t.text === 'S') {
return 's';
}
}
return undefined;
});
const attrValue_ = p__namespace.eitherOr(p__namespace.ab(string_, p__namespace.option(p__namespace.right(optionalWhitespace_, attrModifier_), null), (v, mod) => ({ value: v, modifier: mod })), p__namespace.ab(identifier_, p__namespace.option(p__namespace.right(whitespace_, attrModifier_), null), (v, mod) => ({ value: v, modifier: mod })));
const attrMatcher_ = p__namespace.choice(p__namespace.map(literal('='), () => '='), p__namespace.ab(literal('~'), literal('='), () => '~='), p__namespace.ab(literal('|'), literal('='), () => '|='), p__namespace.ab(literal('^'), literal('='), () => '^='), p__namespace.ab(literal('$'), literal('='), () => '$='), p__namespace.ab(literal('*'), literal('='), () => '*='));
const attrPresenceSelector_ = p__namespace.abc(literal('['), optionallySpaced(qualifiedName_), literal(']'), (lbr, { name, namespace }) => ({
type: 'attrPresence',
name: name,
namespace: namespace,
specificity: [0, 1, 0]
}));
const attrValueSelector_ = p__namespace.middle(literal('['), p__namespace.abc(optionallySpaced(qualifiedName_), attrMatcher_, optionallySpaced(attrValue_), ({ name, namespace }, matcher, { value, modifier }) => ({
type: 'attrValue',
name: name,
namespace: namespace,
matcher: matcher,
value: value,
modifier: modifier,
specificity: [0, 1, 0]
})), literal(']'));
const attrSelector_ = p__namespace.eitherOr(attrPresenceSelector_, attrValueSelector_);
const typeSelector_ = p__namespace.eitherOr(uniSelector_, tagSelector_);
const subclassSelector_ = p__namespace.choice(idSelector_, classSelector_, attrSelector_);
const compoundSelector_ = p__namespace.map(p__namespace.eitherOr(p__namespace.flatten(typeSelector_, p__namespace.many(subclassSelector_)), p__namespace.many1(subclassSelector_)), (ss) => {
return {
type: 'compound',
list: ss,
specificity: sumAllSpec(ss.map(s => s.specificity))
};
});
const combinator_ = p__namespace.choice(p__namespace.map(literal('>'), () => '>'), p__namespace.map(literal('+'), () => '+'), p__namespace.map(literal('~'), () => '~'), p__namespace.ab(literal('|'), literal('|'), () => '||'));
const combinatorSeparator_ = p__namespace.eitherOr(optionallySpaced(combinator_), p__namespace.map(whitespace_, () => ' '));
const complexSelector_ = p__namespace.leftAssoc2(compoundSelector_, p__namespace.map(combinatorSeparator_, (c) => (left, right) => ({
type: 'compound',
list: [...right.list, { type: 'combinator', combinator: c, left: left, specificity: left.specificity }],
specificity: sumSpec(left.specificity, right.specificity)
})), compoundSelector_);
const listSelector_ = p__namespace.leftAssoc2(p__namespace.map(complexSelector_, (s) => ({ type: 'list', list: [s] })), p__namespace.map(optionallySpaced(literal(',')), () => (acc, next) => ({ type: 'list', list: [...acc.list, next] })), complexSelector_);
function parse_(parser, str) {
if (!(typeof str === 'string' || str instanceof String)) {
throw new Error('Expected a selector string. Actual input is not a string!');
}
const lexerResult = lexSelector(str);
if (!lexerResult.complete) {
throw new Error(`The input "${str}" was only partially tokenized, stopped at offset ${lexerResult.offset}!\n` +
prettyPrintPosition(str, lexerResult.offset));
}
const result = optionallySpaced(parser)({ tokens: lexerResult.tokens, options: undefined }, 0);
if (!result.matched) {
throw new Error(`No match for "${str}" input!`);
}
if (result.position < lexerResult.tokens.length) {
const token = lexerResult.tokens[result.position];
throw new Error(`The input "${str}" was only partially parsed, stopped at offset ${token.offset}!\n` +
prettyPrintPosition(str, token.offset, token.len));
}
return result.value;
}
function prettyPrintPosition(str, offset, len = 1) {
return `${str.replace(/(\t)|(\r)|(\n)/g, (m, t, r) => t ? '\u2409' : r ? '\u240d' : '\u240a')}\n${''.padEnd(offset)}${'^'.repeat(len)}`;
}
function parse(str) {
return parse_(listSelector_, str);
}
function parse1(str) {
return parse_(complexSelector_, str);
}
function serialize(selector) {
if (!selector.type) {
throw new Error('This is not an AST node.');
}
switch (selector.type) {
case 'universal':
return _serNs(selector.namespace) + '*';
case 'tag':
return _serNs(selector.namespace) + _serIdent(selector.name);
case 'class':
return '.' + _serIdent(selector.name);
case 'id':
return '#' + _serIdent(selector.name);
case 'attrPresence':
return `[${_serNs(selector.namespace)}${_serIdent(selector.name)}]`;
case 'attrValue':
return `[${_serNs(selector.namespace)}${_serIdent(selector.name)}${selector.matcher}"${_serStr(selector.value)}"${(selector.modifier ? selector.modifier : '')}]`;
case 'combinator':
return serialize(selector.left) + selector.combinator;
case 'compound':
return selector.list.reduce((acc, node) => {
if (node.type === 'combinator') {
return serialize(node) + acc;
}
else {
return acc + serialize(node);
}
}, '');
case 'list':
return selector.list.map(serialize).join(',');
}
}
function _serNs(ns) {
return (ns || ns === '')
? _serIdent(ns) + '|'
: '';
}
function _codePoint(char) {
return `\\${char.codePointAt(0).toString(16)} `;
}
function _serIdent(str) {
return str.replace(
/(^[0-9])|(^-[0-9])|(^-$)|([-0-9a-zA-Z_]|[^\x00-\x7F])|(\x00)|([\x01-\x1f]|\x7f)|([\s\S])/g, (m, d1, d2, hy, safe, nl, ctrl, other) => d1 ? _codePoint(d1) :
d2 ? '-' + _codePoint(d2.slice(1)) :
hy ? '\\-' :
safe ? safe :
nl ? '\ufffd' :
ctrl ? _codePoint(ctrl) :
'\\' + other);
}
function _serStr(str) {
return str.replace(
/(")|(\\)|(\x00)|([\x01-\x1f]|\x7f)/g, (m, dq, bs, nl, ctrl) => dq ? '\\"' :
bs ? '\\\\' :
nl ? '\ufffd' :
_codePoint(ctrl));
}
function normalize(selector) {
if (!selector.type) {
throw new Error('This is not an AST node.');
}
switch (selector.type) {
case 'compound': {
selector.list.forEach(normalize);
selector.list.sort((a, b) => _compareArrays(_getSelectorPriority(a), _getSelectorPriority(b)));
break;
}
case 'combinator': {
normalize(selector.left);
break;
}
case 'list': {
selector.list.forEach(normalize);
selector.list.sort((a, b) => (serialize(a) < serialize(b)) ? -1 : 1);
break;
}
}
return selector;
}
function _getSelectorPriority(selector) {
switch (selector.type) {
case 'universal':
return [1];
case 'tag':
return [1];
case 'id':
return [2];
case 'class':
return [3, selector.name];
case 'attrPresence':
return [4, serialize(selector)];
case 'attrValue':
return [5, serialize(selector)];
case 'combinator':
return [15, serialize(selector)];
}
}
function compareSelectors(a, b) {
return _compareArrays(a.specificity, b.specificity);
}
function compareSpecificity(a, b) {
return _compareArrays(a, b);
}
function _compareArrays(a, b) {
if (!Array.isArray(a) || !Array.isArray(b)) {
throw new Error('Arguments must be arrays.');
}
const shorter = (a.length < b.length) ? a.length : b.length;
for (let i = 0; i < shorter; i++) {
if (a[i] === b[i]) {
continue;
}
return (a[i] < b[i]) ? -1 : 1;
}
return a.length - b.length;
}
exports.Ast = ast;
exports.compareSelectors = compareSelectors;
exports.compareSpecificity = compareSpecificity;
exports.normalize = normalize;
exports.parse = parse;
exports.parse1 = parse1;
exports.serialize = serialize;