@master/css-compiler 2.0.0-beta.98 → 2.0.0-rc.70

package/dist/lexer/standalone-master.mjs

@@ -0,0 +1,233 @@
+import { removeSourceRanges, escapeRegExp } from '@master/css-lexer';
+import { findAtRuleStatementEnd } from './source.mjs';
+
+const STANDALONE_CSS_DIRECTIVE_NAMES = new Set([
+    'master',
+    'source',
+    'safelist',
+    'blocklist',
+    'preserve'
+]);
+function isIdentChar(char) {
+    return Boolean(char && /[-_a-zA-Z0-9]/.test(char));
+}
+function parseQuotedStrings(source) {
+    const values = [];
+    let quote = '';
+    let value = '';
+    for(let index = 0; index < source.length; index++){
+        const char = source[index];
+        if (!quote) {
+            if (char === '"' || char === '\'') {
+                quote = char;
+                value = '';
+            }
+            continue;
+        }
+        if (char === '\\') {
+            value += source[index + 1] || '';
+            index++;
+            continue;
+        }
+        if (char === quote) {
+            values.push(value);
+            quote = '';
+            continue;
+        }
+        value += char;
+    }
+    return values;
+}
+function parseUnquotedWords(source) {
+    const words = [];
+    let quote = '';
+    let comment = false;
+    let word = '';
+    for(let index = 0; index < source.length; index++){
+        const char = source[index];
+        const next = source[index + 1];
+        if (comment) {
+            if (char === '*' && next === '/') {
+                comment = false;
+                index++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (char === '\\') index++;
+            else if (char === quote) quote = '';
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            comment = true;
+            index++;
+            continue;
+        }
+        if (char === '"' || char === '\'') {
+            quote = char;
+            if (word) {
+                words.push(word);
+                word = '';
+            }
+            continue;
+        }
+        if (isIdentChar(char)) {
+            word += char;
+            continue;
+        }
+        if (word) {
+            words.push(word);
+            word = '';
+        }
+    }
+    if (word) words.push(word);
+    return words;
+}
+function wildcardToRegExp(source) {
+    return new RegExp(`^${source.split(/([*?])/g).map((part)=>{
+        if (part === '*') return '.*';
+        if (part === '?') return '.';
+        return escapeRegExp(part);
+    }).join('')}$`);
+}
+function normalizeBlocklistPattern(pattern) {
+    return /[*?]/.test(pattern) ? wildcardToRegExp(pattern) : pattern;
+}
+function addUnique(target, values) {
+    for (const value of values){
+        if (!target.includes(value)) {
+            target.push(value);
+        }
+    }
+}
+function createCSSDirectiveExtractionPolicy() {
+    return {
+        include: [],
+        exclude: [],
+        safelist: [],
+        blocklist: [],
+        preserveNative: false
+    };
+}
+function mergeCSSDirectiveExtractionPolicy(...policies) {
+    const merged = createCSSDirectiveExtractionPolicy();
+    for (const policy of policies){
+        if (!policy) continue;
+        addUnique(merged.include, policy.include || []);
+        addUnique(merged.exclude, policy.exclude || []);
+        addUnique(merged.safelist, policy.safelist || []);
+        addUnique(merged.blocklist, policy.blocklist || []);
+        merged.preserveNative ||= Boolean(policy.preserveNative);
+    }
+    return merged;
+}
+function parseAtRuleName(source, start) {
+    let cursor = start + 1;
+    while(isIdentChar(source[cursor]))cursor++;
+    return source.slice(start + 1, cursor);
+}
+function parseStandaloneCSSDirectiveStatement(source, start, atRuleName) {
+    const end = findAtRuleStatementEnd(source, start);
+    if (end === -1) return;
+    const statement = source.slice(start, end);
+    const prelude = statement.replace(new RegExp(`^@${atRuleName}\\b`), '').replace(/;$/, '');
+    if (atRuleName === 'master' && prelude.trim()) return;
+    const name = atRuleName === 'master' ? '' : atRuleName;
+    return {
+        start,
+        end,
+        atRuleName,
+        name,
+        statement,
+        args: parseQuotedStrings(prelude),
+        modifiers: parseUnquotedWords(prelude)
+    };
+}
+function findStandaloneCSSDirectiveStatements(source, filename = 'master.css') {
+    const statements = [];
+    let quote = '';
+    let comment = false;
+    let depth = 0;
+    for(let index = 0; index < source.length; index++){
+        const char = source[index];
+        const next = source[index + 1];
+        if (comment) {
+            if (char === '*' && next === '/') {
+                comment = false;
+                index++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (char === '\\') {
+                index++;
+            } else if (char === quote) {
+                quote = '';
+            }
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            comment = true;
+            index++;
+            continue;
+        }
+        if (char === '"' || char === '\'') {
+            quote = char;
+            continue;
+        }
+        if (char === '{') {
+            depth++;
+            continue;
+        }
+        if (char === '}') {
+            depth--;
+            continue;
+        }
+        if (depth !== 0 || char !== '@') continue;
+        const name = parseAtRuleName(source, index);
+        if (!STANDALONE_CSS_DIRECTIVE_NAMES.has(name)) continue;
+        if (isIdentChar(source[index + name.length + 1])) continue;
+        const statement = parseStandaloneCSSDirectiveStatement(source, index, name);
+        if (!statement) continue;
+        statements.push(statement);
+        index = statement.end - 1;
+    }
+    return statements;
+}
+function findStandaloneMasterDirectiveStatements(source, filename = 'master.css') {
+    return findStandaloneCSSDirectiveStatements(source, filename).filter((statement)=>statement.atRuleName === 'master');
+}
+function collectStandaloneCSSDirectiveExtractionPolicy(source, filename = 'master.css') {
+    const policy = createCSSDirectiveExtractionPolicy();
+    for (const statement of findStandaloneCSSDirectiveStatements(source, filename)){
+        switch(statement.atRuleName){
+            case 'source':
+                if (statement.modifiers.includes('not')) {
+                    policy.exclude.push(...statement.args);
+                } else {
+                    policy.include.push(...statement.args);
+                }
+                break;
+            case 'safelist':
+                policy.safelist.push(...statement.args.flatMap((arg)=>arg.split(/\s+/).filter(Boolean)));
+                break;
+            case 'blocklist':
+                policy.blocklist.push(...statement.args.flatMap((arg)=>arg.split(/\s+/).filter(Boolean)).map(normalizeBlocklistPattern));
+                break;
+            case 'preserve':
+                if (statement.modifiers.includes('native')) {
+                    policy.preserveNative = true;
+                }
+                break;
+        }
+    }
+    return policy;
+}
+function removeStandaloneCSSDirectives(source, filename = 'master.css') {
+    return removeSourceRanges(source, findStandaloneCSSDirectiveStatements(source, filename));
+}
+function removeStandaloneMasterDirectives(source, filename = 'master.css') {
+    return removeSourceRanges(source, findStandaloneMasterDirectiveStatements(source, filename));
+}
+
+export { collectStandaloneCSSDirectiveExtractionPolicy, createCSSDirectiveExtractionPolicy, findStandaloneCSSDirectiveStatements, findStandaloneMasterDirectiveStatements, mergeCSSDirectiveExtractionPolicy, removeStandaloneCSSDirectives, removeStandaloneMasterDirectives };

package/dist/lower-css-directives.d.ts

@@ -0,0 +1,16 @@
+import { type CSSDirectiveManifestInput, type CSSDirectiveResult } from '@master/css-schema/css-directives';
+import type { MasterCSSManifest } from '@master/css-schema/manifest';
+export interface LowerCSSDirectivesOptions {
+    baseManifest?: MasterCSSManifest;
+    resolutionManifest?: MasterCSSManifest;
+    onWarning?: (warning: string) => void;
+}
+export interface LowerCSSDirectivesResult {
+    input: CSSDirectiveManifestInput;
+    manifest: MasterCSSManifest;
+    warnings: string[];
+    generatedCSS: string;
+}
+type CSSDirectiveManifestInputSource = CSSDirectiveResult | CSSDirectiveManifestInput;
+export default function lowerCSSDirectives(input: CSSDirectiveManifestInputSource, options?: LowerCSSDirectivesOptions): LowerCSSDirectivesResult;
+export {};