@tbela99/css-parser 0.0.1-rc6 → 0.0.1

package/dist/index.cjs

@@ -770,7 +770,8 @@ function renderToken(token, options = {}, reducer, errors) {
             }
             return val + unit;
         case 'Perc':
-            return token.val + '%';
+            const perc = reduceNumber(token.val);
+            return options.minify && perc == '0' ? '0' : perc + '%';
         case 'Number':
             return reduceNumber(token.val);
         case 'Comment':
@@ -827,7 +828,7 @@ function isColor(token) {
     if (token.typ == 'Func' && token.chi.length > 0 && colorsFunc.includes(token.val)) {
         // @ts-ignore
         for (const v of token.chi) {
-            if (!['Number', 'Perc', 'Comma', 'Whitespace'].includes(v.typ)) {
+            if (!['Number', 'Angle', 'Perc', 'Comma', 'Whitespace', 'Literal'].includes(v.typ)) {
                 return false;
             }
         }
@@ -1947,7 +1948,7 @@ function eq(a, b) {
     }
     let key;
     for (key of k1) {
-        if (!eq(a[key], b[key])) {
+        if (!(key in b) || !eq(a[key], b[key])) {
             return false;
         }
     }
@@ -2242,12 +2243,16 @@ function* tokenize(iterator) {
     }
     function next(count = 1) {
         let char = '';
-        while (count-- > 0 && ind < iterator.length) {
+        let chr = '';
+        if (count < 0) {
+            return '';
+        }
+        while (count-- && (chr = iterator.charAt(ind + 1))) {
+            char += chr;
             const codepoint = iterator.charCodeAt(++ind);
             if (isNaN(codepoint)) {
                 return char;
             }
-            char += iterator.charAt(ind);
             if (isNewLine(codepoint)) {
                 lin++;
                 col = 0;
@@ -2814,7 +2819,7 @@ async function parse$1(iterator, opt = {}) {
             if (delim.typ == 'Block-start') {
                 const position = map.get(tokens[0]);
                 const uniq = new Map;
-                parseTokens(tokens, { minify: options.minify }).reduce((acc, curr, index, array) => {
+                parseTokens(tokens, { minify: true }).reduce((acc, curr, index, array) => {
                     if (curr.typ == 'Whitespace') {
                         if (trimWhiteSpace.includes(array[index - 1]?.typ) ||
                             trimWhiteSpace.includes(array[index + 1]?.typ) ||
@@ -2823,7 +2828,7 @@ async function parse$1(iterator, opt = {}) {
                             return acc;
                         }
                     }
-                    let t = renderToken(curr, { minify: true });
+                    let t = renderToken(curr, { minify: false });
                     if (t == ',') {
                         acc.push([]);
                     }
@@ -3824,10 +3829,174 @@ class PropertyList {
     }
 }
 
+function* walk(node, parent, root) {
+    yield { node, parent, root };
+    if ('chi' in node) {
+        for (const child of node.chi) {
+            yield* walk(child, node, (root ?? node));
+        }
+    }
+}
+function* walkValues(values, parent) {
+    for (const value of values) {
+        // @ts-ignore
+        yield { value, parent };
+        if ('chi' in value) {
+            yield* walkValues(value.chi, value);
+        }
+    }
+}
+
+function expand(ast) {
+    //
+    if (!['Rule', 'StyleSheet', 'AtRule'].includes(ast.typ)) {
+        return ast;
+    }
+    if ('Rule' == ast.typ) {
+        return {
+            typ: 'StyleSheet',
+            chi: expandRule(ast)
+        };
+    }
+    if (!('chi' in ast)) {
+        return { ...ast };
+    }
+    const result = { ...ast, chi: [] };
+    // @ts-ignore
+    for (let i = 0; i < ast.chi.length; i++) {
+        // @ts-ignore
+        const node = ast.chi[i];
+        if (node.typ == 'Rule') {
+            // @ts-ignore
+            result.chi.push(...expandRule(node));
+            // i += expanded.length - 1;
+        }
+        else if (node.typ == 'AtRule' && 'chi' in node) {
+            let hasRule = false;
+            let j = node.chi.length;
+            while (j--) {
+                if (node.chi[j].typ == 'Rule' || node.chi[j].typ == 'AtRule') {
+                    hasRule = true;
+                    break;
+                }
+            }
+            // @ts-ignore
+            result.chi.push({ ...(hasRule ? expand(node) : node) });
+        }
+        else {
+            // @ts-ignore
+            result.chi.push(node);
+        }
+    }
+    return result;
+}
+function expandRule(node) {
+    const ast = { ...node, chi: node.chi.slice() };
+    const result = [];
+    if (ast.typ == 'Rule') {
+        let i = 0;
+        for (; i < ast.chi.length; i++) {
+            if (ast.chi[i].typ == 'Rule') {
+                const rule = ast.chi[i];
+                if (!rule.sel.includes('&')) {
+                    const selRule = splitRule(rule.sel);
+                    selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(ast.sel) : arr.unshift(ast.sel, ' '));
+                    rule.sel = selRule.reduce((acc, curr) => {
+                        acc.push(curr.join(''));
+                        return acc;
+                    }, []).join(',');
+                }
+                else {
+                    rule.sel = replaceCompound(rule.sel, ast.sel);
+                }
+                ast.chi.splice(i--, 1);
+                result.push(...expandRule(rule));
+            }
+            else if (ast.chi[i].typ == 'AtRule') {
+                let astAtRule = ast.chi[i];
+                const values = [];
+                if (astAtRule.nam == 'scope') {
+                    if (astAtRule.val.includes('&')) {
+                        astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
+                    }
+                    // @ts-ignore
+                    astAtRule = expand(astAtRule);
+                }
+                else {
+                    // @ts-ignore
+                    const clone = { ...ast, chi: astAtRule.chi.slice() };
+                    // @ts-ignore
+                    astAtRule.chi.length = 0;
+                    for (const r of expandRule(clone)) {
+                        if (r.typ == 'AtRule' && 'chi' in r) {
+                            if (astAtRule.val !== '' && r.val !== '') {
+                                if (astAtRule.nam == 'media' && r.nam == 'media') {
+                                    r.val = astAtRule.val + ' and ' + r.val;
+                                }
+                                else if (astAtRule.nam == 'layer' && r.nam == 'layer') {
+                                    r.val = astAtRule.val + '.' + r.val;
+                                }
+                            }
+                            // @ts-ignore
+                            values.push(r);
+                        }
+                        else if (r.typ == 'Rule') {
+                            // @ts-ignore
+                            astAtRule.chi.push(...expandRule(r));
+                        }
+                        else {
+                            // @ts-ignore
+                            astAtRule.chi.push(r);
+                        }
+                    }
+                }
+                // @ts-ignore
+                result.push(...(astAtRule.chi.length > 0 ? [astAtRule].concat(values) : values));
+                ast.chi.splice(i--, 1);
+            }
+        }
+    }
+    // @ts-ignore
+    return ast.chi.length > 0 ? [ast].concat(result) : result;
+}
+function replaceCompound(input, replace) {
+    const tokens = parseString(input);
+    for (const t of walkValues(tokens)) {
+        if (t.value.typ == 'Literal') {
+            if (t.value.val == '&') {
+                t.value.val = replace;
+            }
+            else if (t.value.val.length > 1 && t.value.val.charAt(0) == '&') {
+                t.value.val = replaceCompoundLiteral(t.value.val, replace);
+            }
+        }
+    }
+    return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
+}
+function replaceCompoundLiteral(selector, replace) {
+    const tokens = [''];
+    let i = 0;
+    for (; i < selector.length; i++) {
+        if (selector.charAt(i) == '&') {
+            tokens.push('&');
+            tokens.push('');
+        }
+        else {
+            tokens[tokens.length - 1] += selector.charAt(i);
+        }
+    }
+    return tokens.sort((a, b) => {
+        if (a == '&') {
+            return 1;
+        }
+        return b == '&' ? -1 : 0;
+    }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
+}
+
 const combinators = ['+', '>', '~'];
 const notEndingWith = ['(', '['].concat(combinators);
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
-function minify(ast, options = {}, recursive = false, errors) {
+function minify(ast, options = {}, recursive = false, errors, nestingContent) {
     function wrapNodes(previous, node, match, ast, i, nodeIndex) {
         // @ts-ignore
         let pSel = match.selector1.reduce(reducer, []).join(',');
@@ -4116,8 +4285,28 @@ function minify(ast, options = {}, recursive = false, errors) {
             selector2
         };
     }
+    function fixSelector(node) {
+        // @ts-ignore
+        if (node.sel.includes('&')) {
+            const attributes = parseString(node.sel);
+            for (const attr of walkValues(attributes)) {
+                if (attr.value.typ == 'Pseudo-class-func' && attr.value.val == ':is') {
+                    let i = attr.value.chi.length;
+                    while (i--) {
+                        if (attr.value.chi[i].typ == 'Literal' && attr.value.chi[i].val == '&') {
+                            attr.value.chi.splice(i, 1);
+                        }
+                    }
+                }
+            }
+            node.sel = attributes.reduce((acc, curr) => acc + renderToken(curr), '');
+        }
+    }
     // @ts-ignore
     if (('chi' in ast) && ast.chi?.length > 0) {
+        if (!nestingContent) {
+            nestingContent = options.nestingRules && ast.typ == 'Rule';
+        }
         let i = 0;
         let previous;
         let node;
@@ -4132,7 +4321,6 @@ function minify(ast, options = {}, recursive = false, errors) {
             node = ast.chi[i];
             // @ts-ignore
             if (previous == node) {
-                // console.error('idem!');
                 // @ts-ignore
                 ast.chi.splice(i, 1);
                 i--;
@@ -4148,7 +4336,6 @@ function minify(ast, options = {}, recursive = false, errors) {
                     i--;
                     continue;
                 }
-                // console.debug({previous, node});
                 // @ts-ignore
                 if (previous?.typ == 'AtRule' &&
                     previous.nam == node.nam &&
@@ -4168,7 +4355,7 @@ function minify(ast, options = {}, recursive = false, errors) {
                     minifyRule(node);
                 }
                 else {
-                    minify(node, options, recursive, errors);
+                    minify(node, options, recursive, errors, nestingContent);
                 }
                 previous = node;
                 nodeIndex = i;
@@ -4222,7 +4409,7 @@ function minify(ast, options = {}, recursive = false, errors) {
                         nodeIndex = --i;
                         // @ts-ignore
                         previous = ast.chi[nodeIndex];
-                        minify(wrapper, options, recursive, errors);
+                        minify(wrapper, options, recursive, errors, nestingContent);
                         continue;
                     }
                     // @ts-ignore
@@ -4255,7 +4442,7 @@ function minify(ast, options = {}, recursive = false, errors) {
                     let wrap = true;
                     // @ts-ignore
                     const selector = node.optimized.selector.reduce((acc, curr) => {
-                        if (curr[0] == '&') {
+                        if (curr[0] == '&' && curr.length > 1) {
                             if (curr[1] == ' ') {
                                 curr.splice(0, 2);
                             }
@@ -4279,7 +4466,7 @@ function minify(ast, options = {}, recursive = false, errors) {
                     if (!wrap) {
                         wrap = selector.some(s => s[0] != '&');
                     }
-                    const rule = selector.map(s => {
+                    let rule = selector.map(s => {
                         if (s[0] == '&') {
                             // @ts-ignore
                             s[0] = node.optimized.optimized[0];
@@ -4287,7 +4474,14 @@ function minify(ast, options = {}, recursive = false, errors) {
                         return s.join('');
                     }).join(',');
                     // @ts-ignore
-                    node.sel = wrap ? node.optimized.optimized[0] + `:is(${rule})` : rule;
+                    let sel = wrap ? node.optimized.optimized[0] + `:is(${rule})` : rule;
+                    if (rule.includes('&')) {
+                        // @ts-ignore
+                        rule = replaceCompound(rule, node.optimized.optimized[0]);
+                    }
+                    if (sel.length < node.sel.length) {
+                        node.sel = sel;
+                    }
                 }
             }
             // @ts-ignore
@@ -4323,7 +4517,7 @@ function minify(ast, options = {}, recursive = false, errors) {
                                     minifyRule(node);
                                 }
                                 else {
-                                    minify(node, options, recursive, errors);
+                                    minify(node, options, recursive, errors, nestingContent);
                                 }
                                 i--;
                                 previous = node;
@@ -4368,7 +4562,7 @@ function minify(ast, options = {}, recursive = false, errors) {
                             minifyRule(previous);
                         }
                         else {
-                            minify(previous, options, recursive, errors);
+                            minify(previous, options, recursive, errors, nestingContent);
                         }
                     }
                 }
@@ -4380,11 +4574,19 @@ function minify(ast, options = {}, recursive = false, errors) {
                             minifyRule(previous);
                         }
                         else {
-                            minify(previous, options, recursive, errors);
+                            minify(previous, options, recursive, errors, nestingContent);
                         }
                     }
                 }
             }
+            if (!nestingContent &&
+                // @ts-ignore
+                previous != null &&
+                // previous.optimized != null &&
+                previous.typ == 'Rule' &&
+                previous.sel.includes('&')) {
+                fixSelector(previous);
+            }
             previous = node;
             nodeIndex = i;
         }
@@ -4397,10 +4599,18 @@ function minify(ast, options = {}, recursive = false, errors) {
             else {
                 // @ts-ignore
                 if (!(node.typ == 'AtRule' && node.nam != 'font-face')) {
-                    minify(node, options, recursive, errors);
+                    minify(node, options, recursive, errors, nestingContent);
                 }
             }
         }
+        if (!nestingContent &&
+            // @ts-ignore
+            node != null &&
+            // previous.optimized != null &&
+            node.typ == 'Rule' &&
+            node.sel.includes('&')) {
+            fixSelector(node);
+        }
     }
     return ast;
 }
@@ -4639,181 +4849,6 @@ function reduceRuleSelector(node) {
             Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: raw });
         }
     }
-    // }
-}
-
-function* walk(node) {
-    // @ts-ignore
-    yield* doWalk(node, null, null);
-}
-function* doWalk(node, parent, root) {
-    yield { node, parent, root };
-    if ('chi' in node) {
-        for (const child of node.chi) {
-            yield* doWalk(child, node, (root ?? node));
-        }
-    }
-}
-function* walkValues(values, parent) {
-    for (const value of values) {
-        // @ts-ignore
-        yield { value, parent };
-        if ('chi' in value) {
-            yield* walkValues(value.chi, value);
-        }
-    }
-}
-
-function expand(ast) {
-    //
-    if (!['Rule', 'StyleSheet', 'AtRule'].includes(ast.typ)) {
-        return ast;
-    }
-    if ('Rule' == ast.typ) {
-        return {
-            typ: 'StyleSheet',
-            chi: expandRule(ast)
-        };
-    }
-    if (!('chi' in ast)) {
-        return { ...ast };
-    }
-    const result = { ...ast, chi: [] };
-    // @ts-ignore
-    for (let i = 0; i < ast.chi.length; i++) {
-        // @ts-ignore
-        const node = ast.chi[i];
-        if (node.typ == 'Rule') {
-            // @ts-ignore
-            result.chi.push(...expandRule(node));
-            // i += expanded.length - 1;
-        }
-        else if (node.typ == 'AtRule' && 'chi' in node) {
-            let hasRule = false;
-            let j = node.chi.length;
-            while (j--) {
-                if (node.chi[j].typ == 'Rule' || node.chi[j].typ == 'AtRule') {
-                    hasRule = true;
-                    break;
-                }
-            }
-            // @ts-ignore
-            result.chi.push({ ...(hasRule ? expand(node) : node) });
-        }
-        else {
-            // @ts-ignore
-            result.chi.push(node);
-        }
-    }
-    return result;
-}
-function expandRule(node) {
-    const ast = { ...node, chi: node.chi.slice() };
-    const result = [];
-    if (ast.typ == 'Rule') {
-        let i = 0;
-        // @ts-ignore
-        delete ast.raw;
-        // @ts-ignore
-        delete ast.optimized;
-        for (; i < ast.chi.length; i++) {
-            if (ast.chi[i].typ == 'Rule') {
-                const rule = ast.chi[i];
-                if (!rule.sel.includes('&')) {
-                    const selRule = splitRule(rule.sel);
-                    selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(ast.sel) : arr.unshift(ast.sel, ' '));
-                    rule.sel = selRule.reduce((acc, curr) => {
-                        acc.push(curr.join(''));
-                        return acc;
-                    }, []).join(',');
-                }
-                else {
-                    rule.sel = replaceCompount(rule.sel, ast.sel);
-                }
-                delete rule.raw;
-                delete rule.optimized;
-                ast.chi.splice(i--, 1);
-                result.push(...expandRule(rule));
-            }
-            else if (ast.chi[i].typ == 'AtRule') {
-                let astAtRule = ast.chi[i];
-                const values = [];
-                if (astAtRule.nam == 'scope') {
-                    if (astAtRule.val.includes('&')) {
-                        astAtRule.val = replaceCompount(astAtRule.val, ast.sel);
-                    }
-                    // @ts-ignore
-                    astAtRule = expand(astAtRule);
-                }
-                else {
-                    // @ts-ignore
-                    const clone = { ...ast, chi: astAtRule.chi.slice() };
-                    // @ts-ignore
-                    astAtRule.chi.length = 0;
-                    for (const r of expandRule(clone)) {
-                        if (r.typ == 'AtRule' && 'chi' in r) {
-                            if (astAtRule.val !== '' && r.val !== '') {
-                                if (astAtRule.nam == 'media' && r.nam == 'media') {
-                                    r.val = astAtRule.val + ' and ' + r.val;
-                                }
-                                else if (astAtRule.nam == 'layer' && r.nam == 'layer') {
-                                    r.val = astAtRule.val + '.' + r.val;
-                                }
-                            }
-                            // @ts-ignore
-                            values.push(r);
-                        }
-                        else if (r.typ == 'Rule') {
-                            // @ts-ignore
-                            astAtRule.chi.push(...expandRule(r));
-                        }
-                        else {
-                            // @ts-ignore
-                            astAtRule.chi.push(r);
-                        }
-                    }
-                }
-                // @ts-ignore
-                result.push(...(astAtRule.chi.length > 0 ? [astAtRule].concat(values) : values));
-                ast.chi.splice(i--, 1);
-            }
-        }
-    }
-    // @ts-ignore
-    return ast.chi.length > 0 ? [ast].concat(result) : result;
-}
-function replaceCompount(input, replace) {
-    const tokens = parseString(input);
-    for (const t of walkValues(tokens)) {
-        if (t.value.typ == 'Literal') {
-            if (t.value.val == '&') {
-                t.value.val = replace;
-            }
-            else if (t.value.val.length > 1 && t.value.val.charAt(0) == '&') {
-                t.value.val = replaceCompoundLiteral(t.value.val, replace);
-            }
-        }
-    }
-    return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
-}
-function replaceCompoundLiteral(selector, replace) {
-    const tokens = [''];
-    let i = 0;
-    for (; i < selector.length; i++) {
-        if (selector.charAt(i) == '&') {
-            tokens.push('&');
-            tokens.push('');
-        }
-        else {
-            tokens[tokens.length - 1] += selector.charAt(i);
-        }
-    }
-    return tokens.sort((a, b) => {
-        if (a == '&') {
-            return 1;
-        }
-        return b == '&' ? -1 : 0;
-    }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
 }
 
 async function transform$1(css, options = {}) {
@@ -4991,6 +5026,7 @@ exports.parseString = parseString;
 exports.reduceSelector = reduceSelector;
 exports.render = render;
 exports.renderToken = renderToken;
+exports.replaceCompound = replaceCompound;
 exports.resolve = resolve;
 exports.splitRule = splitRule;
 exports.tokenize = tokenize;

package/dist/index.d.ts

@@ -633,7 +633,7 @@ type AstNode =
     | AstDeclaration;
 
 declare const combinators: string[];
-declare function minify(ast: AstNode, options?: ParserOptions, recursive?: boolean, errors?: ErrorDescription[]): AstNode;
+declare function minify(ast: AstNode, options?: ParserOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean): AstNode;
 declare function reduceSelector(selector: string[][]): {
     match: boolean;
     optimized: string[];
@@ -644,7 +644,7 @@ declare function hasDeclaration(node: AstRule): boolean;
 declare function minifyRule(ast: AstRule | AstAtRule): AstRule | AstAtRule;
 declare function splitRule(buffer: string): string[][];
 
-declare function walk(node: AstNode): Generator<{
+declare function walk(node: AstNode, parent?: AstRuleList, root?: AstRuleList): Generator<{
     node: AstNode;
     parent?: AstRuleList;
     root?: AstRuleList;
@@ -655,6 +655,7 @@ declare function walkValues(values: Token[], parent?: Token): Generator<{
 }>;
 
 declare function expand(ast: AstNode): AstNode;
+declare function replaceCompound(input: string, replace: string): string;
 
 declare const colorsFunc: string[];
 declare function render(data: AstNode, opt?: RenderOptions): RenderResult;
@@ -707,4 +708,4 @@ declare function resolve(url: string, currentDirectory: string, cwd?: string): {
 declare function parse(iterator: string, opt?: ParserOptions): Promise<ParseResult>;
 declare function transform(css: string, options?: TransformOptions): Promise<TransformResult>;
 
-export { colorsFunc, combinators, dirname, expand, funcList, getConfig, hasDeclaration, isAngle, isAtKeyword, isColor, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, load, matchType, matchUrl, minify, minifyRule, parse, parseDimension, parseString, reduceSelector, render, renderToken, resolve, splitRule, tokenize, transform, urlTokenMatcher, walk, walkValues };
+export { colorsFunc, combinators, dirname, expand, funcList, getConfig, hasDeclaration, isAngle, isAtKeyword, isColor, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, load, matchType, matchUrl, minify, minifyRule, parse, parseDimension, parseString, reduceSelector, render, renderToken, replaceCompound, resolve, splitRule, tokenize, transform, urlTokenMatcher, walk, walkValues };

package/dist/lib/ast/expand.js

@@ -52,10 +52,6 @@ function expandRule(node) {
     const result = [];
     if (ast.typ == 'Rule') {
         let i = 0;
-        // @ts-ignore
-        delete ast.raw;
-        // @ts-ignore
-        delete ast.optimized;
         for (; i < ast.chi.length; i++) {
             if (ast.chi[i].typ == 'Rule') {
                 const rule = ast.chi[i];
@@ -68,10 +64,8 @@ function expandRule(node) {
                     }, []).join(',');
                 }
                 else {
-                    rule.sel = replaceCompount(rule.sel, ast.sel);
+                    rule.sel = replaceCompound(rule.sel, ast.sel);
                 }
-                delete rule.raw;
-                delete rule.optimized;
                 ast.chi.splice(i--, 1);
                 result.push(...expandRule(rule));
             }
@@ -80,7 +74,7 @@ function expandRule(node) {
                 const values = [];
                 if (astAtRule.nam == 'scope') {
                     if (astAtRule.val.includes('&')) {
-                        astAtRule.val = replaceCompount(astAtRule.val, ast.sel);
+                        astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
                     }
                     // @ts-ignore
                     astAtRule = expand(astAtRule);
@@ -122,7 +116,7 @@ function expandRule(node) {
     // @ts-ignore
     return ast.chi.length > 0 ? [ast].concat(result) : result;
 }
-function replaceCompount(input, replace) {
+function replaceCompound(input, replace) {
     const tokens = parseString(input);
     for (const t of walkValues(tokens)) {
         if (t.value.typ == 'Literal') {
@@ -156,4 +150,4 @@ function replaceCompoundLiteral(selector, replace) {
     }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
 }
 
-export { expand };
+export { expand, replaceCompound };