Commit 5cd65ec

function consumeAnIdentLikeToken(input, pos, out) {

const start = pos;

pos = _consumeAnIdentSequence(input, pos);

if (

_identNamesUrl(input, start, pos)

) {

pos++;

}

return consumeAUrlToken(input, pos, start, out);

}

pos++;

return fill(out, TT_FUNCTION, start, pos);

}

/** @type {Node[]} */ (consumeAListOfComponentValues(ts, TT_COMMA))

);

// 3.2 Discard a token from input.

}

// 4. Return groups — wrap each group's refs against the retained snapshot.

const store = _finishStore();

// <whitespace-token> / <CDO-token> / <CDC-token>

// Discard a token from input.

if (t.type === TT_WHITESPACE || t.type === TT_CDO || t.type === TT_CDC) {

}

// <EOF-token>

// Return rules.

const consumeAnAtRule = (ts, nested = false) => {

// Assert (spec): the next token is an <at-keyword-token>.

// Consume a token from input, and let rule be a new at-rule with its name set to the returned token’s value, its prelude initially set to an empty list, and no declarations or child rules.

const rule = /** @type {AtRule} */ (

_makeContainer(T_AT_RULE, head.start, head.end)

);

// <EOF-token>

// Discard a token from input. If rule is valid in the current context, return it; otherwise return nothing.

if (t.type === TT_SEMICOLON || t.type === TT_EOF) {

_setPrelude(rule, prelude);

_setBlock(rule, -1);

_setEnd(rule, t.start);

_setEnd(rule, t.start);

return rule;

}

if (!skip) prelude.push(node);

continue;

}

* §5.4.2 / §5.4.3), distinct from `consumeAComponentValue` which would recurse

* into a simple block / function.

* @param {TokenStream} ts token stream

* @returns {Token} the consumed token as a leaf node

*/

};

/**

}

ts.advance();

} else {

}

continue;

}

const blockStart = ts.next().start;

// Assert (spec): the next token is <{-token>.

// Discard a token from input. Consume a block's contents from input and let result be the result. Discard a token from input.

consumeABlocksContentsInto(ts);

// Read before anything else runs: a nested block would overwrite these.

const decls = _bcDecls;

const rules = _bcRules;

const close = ts.next();

const end = close.type === TT_RIGHT_CURLY_BRACKET ? close.end : close.start;

_blockDecls = decls;

_blockRules = rules;

_blockStart = blockStart;

// <eof-token> / <semicolon-token>

// Discard a token from input, and return.

if (t.type === TT_EOF || t.type === TT_SEMICOLON) {

return;

}

// <}-token>

// If nested is true, return. Otherwise, discard a token.

if (t.type === TT_RIGHT_CURLY_BRACKET) {

if (nested) return;

continue;

}

// anything else

const consumeADeclaration = (ts, nested = false) => {

const { input } = ts;

// Let decl be a new declaration, with an initially empty name and a value set to an empty list.

// nameEnd (= start) / important (unset) keep their container defaults;

// `value` is set unconditionally at step 5 below.

const decl = /** @type {Declaration} */ (

// 1. If the next token is an <ident-token>, consume a token from input and set decl's name to the returned token's value.

// Otherwise, consume the remnants of a bad declaration from input, with nested, and return nothing.

_setName(decl, head.start, head.end);

} else {

consumeTheRemnantsOfABadDeclaration(ts, nested);

// Otherwise, this is a parse error. Consume a token from input and append the result to values.

if (t.type === TT_RIGHT_CURLY_BRACKET) {

if (nested) return values;

// Keep unless the type is explicitly marked skip (1); an out-of-range

// lookup on a short `skip.types` yields `undefined`, which must not drop.

if (!_skipActive || _skipTypes[_nodeTypeOf(closer)] !== 1) {

const val = _takeList();

// Discard a token from input.

// Process input

for (;;) {

// ending token

// Discard a token from input. Return block.

if (t.type === TT_EOF || t.type === ending) {

_setValue(block, val);

_setEnd(block, t.end);

return block;

const consumeAFunction = (ts) => {

// Assert (spec): the next token is a <function-token>.

// Consume a token from input, and let function be a new function with its name equal the returned token’s value, and a value set to an empty list.

const fn = /** @type {FunctionNode} */ (

_makeContainer(T_FUNCTION, tFn.start, tFn.end)

);

// <eof-token>

// <)-token>

// Discard a token from input. Return function.

_setValue(fn, val);

_setEnd(fn, t.end);

return fn;

const _streamConsumeBlock = (ts, rule) => {

const d = _depth;

const blockStart = ts.next().start;

if (d >= _STREAM_MAX_DEPTH) {

// Deeper than the frame table: fall back to the materializing path.

consumeABlocksContentsInto(ts);

const decls = _bcDecls;

const rules = _bcRules;

const c = ts.next();

_setBody(rule, decls, rules);

_setBlock(rule, blockStart);

_setEnd(rule, c.type === TT_RIGHT_CURLY_BRACKET ? c.end : c.start);

const rules = _bcRules;

const close = ts.next();

const end = close.type === TT_RIGHT_CURLY_BRACKET ? close.end : close.start;

_setBlock(rule, blockStart);

_setEnd(rule, end);

if (!streamed) {

// tens of MB at module level for the process lifetime (~46 bytes/node,

// ~17 bytes/attribute of capacity across the columns).

const _COLUMN_SHRINK_CAPACITY = 65536;

// Release the side arrays' heap references (strings, attribute names/values)

// once a walk has consumed the tree, so the retained columns don't pin the

// parsed source until the next parse.

const _releaseAstColumns = () => {

// Kept regime: overwrite the used prefix in place (see `_resetAstColumns`);

// oversized arrays are dropped entirely, mirroring the typed columns below.

_nodeStrings.length = 0;

} else {

const written = _nodeCount > _nodeHighWater ? _nodeCount : _nodeHighWater;

const usedNodes = Math.min(written, _nodeStrings.length - 1);

for (let i = 0; i <= usedNodes; i++) _nodeStrings[i] = "";

}

_attrNames.length = 0;

_attrValues.length = 0;

} else {

_htmlSource = "";

_doctypePublicId = null;

_doctypeSystemId = null;

_nodeCapacity = 0;

_nodeTypes = new Uint8Array(0);

_nodeFlags = new Uint8Array(0);

_nodeAttrStarts = new Int32Array(0);

_nodeAttrCounts = new Int32Array(0);

}

_attrCapacity = 0;

_attrNameStarts = new Int32Array(0);

_attrNameEnds = new Int32Array(0);

// its node estimate uses `len/24`; attributes are unaffected by the skip and

// keep `len/48`.

let nodeEstimate = (input.length / (skipText ? 24 : 12)) | 0;

if (_streamEligible) {

// Node ids are recycled once streaming starts, so a document past the

// threshold never needs the whole estimate — one allocation covering the

expect(small[0].attributes[0].value).toBe("c");

});

it("merges texts left adjacent by a skipped comment", () => {

const nodes = bodyOf("a<!--c-->b", { comments: true });

expect(nodes).toEqual([