@plumeria/init 19.1.1

package/dist/prompt.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ask = exports.terminal = void 0;
+const promises_1 = __importDefault(require("node:readline/promises"));
+const setup_1 = require("./setup");
+const style_1 = require("./style");
+const SPELLINGS = {
+    '1': 'logical',
+    '2': 'physical',
+    '3': 'both',
+    l: 'logical',
+    logical: 'logical',
+    p: 'physical',
+    physical: 'physical',
+    b: 'both',
+    both: 'both',
+};
+const terminal = () => {
+    const rl = promises_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        question: (prompt) => rl.question(prompt),
+        close: () => rl.close(),
+    };
+};
+exports.terminal = terminal;
+const confirm = async (asker, prompt, fallback) => {
+    const answer = (await asker.question(`${prompt} ${style_1.style.faint(fallback ? '(Y/n)' : '(y/N)')} `))
+        .trim()
+        .toLowerCase();
+    if (answer === '')
+        return fallback;
+    return answer === 'y' || answer === 'yes';
+};
+const ask = async (asker, preset) => {
+    const answers = { ...setup_1.DEFAULT_ANSWERS, ...preset };
+    if (preset.spelling === undefined) {
+        const choices = [
+            ['1', 'logical', 'marginBlockStart, insetInlineStart'],
+            ['2', 'physical', 'marginTop, left'],
+            ['3', 'both', 'no policy'],
+        ];
+        console.log(`\nWhich spelling of a two-named property does this project write?`);
+        for (const [key, name, hint] of choices) {
+            console.log(`  ${style_1.style.choice(`${key}:`)} ${name.padEnd(9)}${style_1.style.faint(hint)}`);
+        }
+        console.log('');
+        for (;;) {
+            const answer = (await asker.question(`Spelling ${style_1.style.faint('(1/2/3) [3]')} `))
+                .trim()
+                .toLowerCase();
+            if (answer === '')
+                break;
+            const spelling = SPELLINGS[answer];
+            if (spelling) {
+                answers.spelling = spelling;
+                break;
+            }
+            console.log(`${style_1.style.failure('✖')} answer 1, 2 or 3.`);
+        }
+    }
+    if (answers.spelling !== 'both' && preset.sizes === undefined) {
+        answers.sizes = await confirm(asker, 'Reject the size axis too (width/height ↔ inlineSize/blockSize)?', false);
+    }
+    if (preset.expandBorderShorthands === undefined) {
+        answers.expandBorderShorthands = await confirm(asker, 'Expand a border shorthand into the three declarations it sets?', true);
+    }
+    if (preset.styleProp === undefined) {
+        const answer = (await asker.question(`Which JSX prop carries styles? ${style_1.style.faint(`[${setup_1.DEFAULT_STYLE_PROP}]`)} `)).trim();
+        if (answer !== '') {
+            answers.styleProp = (0, setup_1.assertStyleProp)(answer);
+        }
+    }
+    if (preset.eslint === undefined) {
+        answers.eslint = await confirm(asker, 'Set up @plumeria/eslint-plugin and the plumerialint build guard?', true);
+    }
+    return answers;
+};
+exports.ask = ask;

package/dist/setup.d.ts

@@ -0,0 +1,58 @@
+import type { Bundler, Detected, PackageManager } from './detect';
+export type Spelling = 'logical' | 'physical' | 'both';
+export interface Answers {
+    spelling: Spelling;
+    sizes: boolean;
+    styleProp: string;
+    expandBorderShorthands: boolean;
+    eslint: boolean;
+    install: boolean;
+}
+export type Action = {
+    kind: 'install';
+    label: string;
+    note: string;
+    command: string;
+    packages: string[];
+} | {
+    kind: 'write';
+    label: string;
+    note: string;
+    file: string;
+    contents: string;
+} | {
+    kind: 'patch';
+    label: string;
+    note: string;
+    file: string;
+    contents: string;
+} | {
+    kind: 'manual';
+    label: string;
+    note: string;
+    file: string;
+    snippet: string;
+} | {
+    kind: 'skip';
+    label: string;
+    note: string;
+    file: string;
+};
+export declare const DEFAULT_STYLE_PROP = "classStyle";
+export declare const assertStyleProp: (value: string) => string;
+export declare const DEFAULT_ANSWERS: Answers;
+export declare const rejectedSpelling: (spelling: Spelling) => "logical" | "physical" | undefined;
+export declare const compilerOption: (answers: Answers) => string | undefined;
+export declare const spellingRule: (answers: Answers) => string | undefined;
+export declare const pluginOptions: (answers: Answers) => string;
+export declare const pluginCall: (bundler: Bundler, answers: Answers, local?: string) => string;
+export declare const declarationSource: (answers: Answers) => string;
+export declare const bundlerSource: (bundler: Bundler, answers: Answers, typescript: boolean) => string | undefined;
+export declare const eslintSource: (answers: Answers, typescript: boolean) => string;
+export declare const eslintEntries: (answers: Answers, typescript: boolean) => string[];
+export declare const packages: (detected: Detected, answers: Answers) => string[];
+export declare const installCommand: (manager: PackageManager, names: readonly string[]) => string;
+export declare const buildScript: (existing: string) => string;
+export declare const plan: (detected: Detected, answers: Answers) => Action[];
+export declare const CLEAN_SCRIPT = "rimraf .next";
+export declare const cleanScripts: (scripts: Record<string, string>) => Record<string, string>;

package/dist/setup.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanScripts = exports.CLEAN_SCRIPT = exports.plan = exports.buildScript = exports.installCommand = exports.packages = exports.eslintEntries = exports.eslintSource = exports.bundlerSource = exports.declarationSource = exports.pluginCall = exports.pluginOptions = exports.spellingRule = exports.compilerOption = exports.rejectedSpelling = exports.DEFAULT_ANSWERS = exports.assertStyleProp = exports.DEFAULT_STYLE_PROP = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const detect_1 = require("./detect");
+const source_1 = require("./source");
+exports.DEFAULT_STYLE_PROP = 'classStyle';
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED = new Set(['className', 'key', 'ref', 'children', 'style']);
+const assertStyleProp = (value) => {
+    if (!IDENTIFIER.test(value))
+        throw new Error(`"${value}" is not a valid identifier`);
+    if (RESERVED.has(value))
+        throw new Error(`"${value}" is already used by React`);
+    return value;
+};
+exports.assertStyleProp = assertStyleProp;
+exports.DEFAULT_ANSWERS = {
+    spelling: 'both',
+    sizes: false,
+    styleProp: exports.DEFAULT_STYLE_PROP,
+    expandBorderShorthands: true,
+    eslint: true,
+    install: true,
+};
+const UNPLUGIN_METHOD = {
+    next: 'next',
+    vite: 'vite',
+    astro: 'vite',
+    webpack: 'webpack',
+    rspack: 'rspack',
+    rollup: 'rollup',
+    rolldown: 'rolldown',
+    esbuild: 'esbuild',
+    farm: 'farm',
+    bun: 'bun',
+};
+const INSTALL = {
+    npm: 'npm i -D',
+    pnpm: 'pnpm add -D',
+    yarn: 'yarn add -D',
+    bun: 'bun add -d',
+};
+const rejectedSpelling = (spelling) => spelling === 'both'
+    ? undefined
+    : spelling === 'logical'
+        ? 'physical'
+        : 'logical';
+exports.rejectedSpelling = rejectedSpelling;
+const compilerOption = (answers) => {
+    const rejected = (0, exports.rejectedSpelling)(answers.spelling);
+    if (!rejected)
+        return undefined;
+    const name = rejected === 'logical'
+        ? 'withoutLogicalProperties'
+        : 'withoutPhysicalProperties';
+    return `${name}: ${answers.sizes ? '{ sizes: true }' : 'true'}`;
+};
+exports.compilerOption = compilerOption;
+const spellingRule = (answers) => {
+    const rejected = (0, exports.rejectedSpelling)(answers.spelling);
+    if (!rejected)
+        return undefined;
+    const name = `'@plumeria/no-${rejected}-properties'`;
+    return answers.sizes
+        ? `${name}: ['error', { sizes: true }]`
+        : `${name}: 'error'`;
+};
+exports.spellingRule = spellingRule;
+const pluginOptions = (answers) => {
+    const entries = [];
+    if (answers.styleProp !== exports.DEFAULT_STYLE_PROP) {
+        entries.push(`styleProp: '${answers.styleProp}'`);
+    }
+    const policy = (0, exports.compilerOption)(answers);
+    if (policy)
+        entries.push(policy);
+    return entries.length === 0 ? '' : `{ ${entries.join(', ')} }`;
+};
+exports.pluginOptions = pluginOptions;
+const pluginCall = (bundler, answers, local = 'plumeria') => `${local}.${UNPLUGIN_METHOD[bundler]}(${(0, exports.pluginOptions)(answers)})`;
+exports.pluginCall = pluginCall;
+const declarationSource = (answers) => {
+    if (answers.styleProp === exports.DEFAULT_STYLE_PROP) {
+        return `/// <reference types="@plumeria/core/class-style" />\n`;
+    }
+    return `import type { Style } from '@plumeria/core';
+
+declare global {
+  namespace React {
+    interface HTMLAttributes<T> {
+      ${answers.styleProp}?: Style;
+    }
+    interface SVGAttributes<T> {
+      ${answers.styleProp}?: Style;
+    }
+  }
+}
+`;
+};
+exports.declarationSource = declarationSource;
+const nextOptions = (answers) => {
+    const options = (0, exports.pluginOptions)(answers);
+    return options === '' ? '' : `, ${options}`;
+};
+const bundlerSource = (bundler, answers, typescript) => {
+    if (bundler === 'next') {
+        return typescript
+            ? `import type { NextConfig } from 'next';
+import { withPlumeria } from '@plumeria/next-plugin';
+
+const nextConfig: NextConfig = {};
+
+export default withPlumeria(nextConfig${nextOptions(answers)});
+`
+            : `import { withPlumeria } from '@plumeria/next-plugin';
+
+export default withPlumeria({}${nextOptions(answers)});
+`;
+    }
+    if (bundler === 'vite') {
+        return `import { defineConfig } from 'vite';
+import plumeria from '@plumeria/unplugin';
+
+export default defineConfig({
+  plugins: [${(0, exports.pluginCall)(bundler, answers)}],
+});
+`;
+    }
+    if (bundler === 'astro') {
+        return `import { defineConfig } from 'astro/config';
+import plumeria from '@plumeria/unplugin';
+
+export default defineConfig({
+  vite: {
+    plugins: [${(0, exports.pluginCall)(bundler, answers)}],
+  },
+});
+`;
+    }
+    return undefined;
+};
+exports.bundlerSource = bundlerSource;
+const eslintSource = (answers, typescript) => {
+    const rules = [
+        answers.expandBorderShorthands
+            ? `'@plumeria/expand-border-shorthands': 'warn'`
+            : undefined,
+        (0, exports.spellingRule)(answers),
+    ].filter((rule) => rule !== undefined);
+    const block = [
+        `  {`,
+        `    files: ['**/*.{${typescript ? 'ts,tsx' : 'js,jsx'}}'],`,
+        typescript ? `    languageOptions: {` : undefined,
+        typescript ? `      parserOptions: { projectService: true },` : undefined,
+        typescript ? `    },` : undefined,
+        rules.length > 0 ? `    rules: {` : undefined,
+        ...rules.map((rule) => `      ${rule},`),
+        rules.length > 0 ? `    },` : undefined,
+        `  },`,
+    ].filter((line) => line !== undefined);
+    const head = [
+        `import eslint from '@eslint/js';`,
+        typescript ? `import tseslint from 'typescript-eslint';` : undefined,
+        `import { defineConfig } from 'eslint/config';`,
+        `import plumeria from '@plumeria/eslint-plugin';`,
+    ].filter((line) => line !== undefined);
+    const configs = [
+        `  eslint.configs.recommended,`,
+        typescript ? `  tseslint.configs.recommended,` : undefined,
+        `  plumeria.configs.recommended,`,
+    ].filter((line) => line !== undefined);
+    return `${head.join('\n')}
+
+export default defineConfig(
+${configs.join('\n')}
+${block.join('\n')}
+);
+`;
+};
+exports.eslintSource = eslintSource;
+const eslintEntries = (answers, typescript) => {
+    const rules = [
+        answers.expandBorderShorthands
+            ? `'@plumeria/expand-border-shorthands': 'warn'`
+            : undefined,
+        (0, exports.spellingRule)(answers),
+    ].filter((rule) => rule !== undefined);
+    const entries = ['plumeria.configs.recommended'];
+    if (rules.length > 0) {
+        entries.push([
+            `{`,
+            `  files: ['**/*.{${typescript ? 'ts,tsx' : 'js,jsx'}}'],`,
+            `  rules: {`,
+            ...rules.map((rule) => `    ${rule},`),
+            `  },`,
+            `}`,
+        ].join('\n'));
+    }
+    return entries;
+};
+exports.eslintEntries = eslintEntries;
+const packages = (detected, answers) => {
+    const present = (0, detect_1.installed)(detected.manifest);
+    const wanted = [
+        '@plumeria/core',
+        detected.bundler === 'next'
+            ? '@plumeria/next-plugin'
+            : '@plumeria/unplugin',
+    ];
+    if (answers.eslint) {
+        wanted.push('@plumeria/eslint-plugin', 'oxlint');
+        if (!detected.eslintConfig) {
+            wanted.push('eslint', '@eslint/js');
+            if (detected.typescript)
+                wanted.push('typescript-eslint');
+        }
+    }
+    if (detected.bundler === 'next' &&
+        Object.keys((0, exports.cleanScripts)(detected.manifest.scripts ?? {})).length > 0) {
+        wanted.push('rimraf');
+    }
+    return wanted.filter((name) => !(name in present));
+};
+exports.packages = packages;
+const installCommand = (manager, names) => `${INSTALL[manager]} ${names.join(' ')}`;
+exports.installCommand = installCommand;
+const indentOfJson = (source) => {
+    const match = /\n(\s+)"/.exec(source);
+    return match ? match[1].length : 2;
+};
+const buildScript = (existing) => `plumerialint -- ${existing}`;
+exports.buildScript = buildScript;
+const plan = (detected, answers) => {
+    const actions = [];
+    const names = (0, exports.packages)(detected, answers);
+    if (names.length > 0) {
+        actions.push({
+            kind: 'install',
+            label: 'install',
+            note: names.join(' '),
+            command: (0, exports.installCommand)(detected.packageManager, names),
+            packages: names,
+        });
+    }
+    if (detected.declaration) {
+        actions.push({
+            kind: 'skip',
+            label: 'skip',
+            note: 'already declares the styling prop',
+            file: detected.declaration,
+        });
+    }
+    else {
+        actions.push({
+            kind: 'write',
+            label: 'write',
+            note: answers.styleProp,
+            file: 'plumeria.d.ts',
+            contents: (0, exports.declarationSource)(answers),
+        });
+    }
+    actions.push(bundlerAction(detected, answers));
+    if (answers.eslint)
+        actions.push(eslintAction(detected, answers));
+    if (answers.eslint || detected.bundler === 'next')
+        actions.push(scriptAction(detected, answers));
+    return actions;
+};
+exports.plan = plan;
+const read = (detected, file) => node_fs_1.default.readFileSync(node_path_1.default.join(detected.root, file), 'utf8');
+const bundlerAction = (detected, answers) => {
+    const { bundler, bundlerConfig, typescript } = detected;
+    const call = (0, exports.pluginCall)(bundler, answers);
+    if (!bundlerConfig) {
+        const fresh = (0, exports.bundlerSource)(bundler, answers, typescript);
+        const file = (0, detect_1.defaultConfigName)(bundler, typescript);
+        if (!fresh) {
+            return {
+                kind: 'manual',
+                label: 'manual',
+                note: bundler === 'esbuild' || bundler === 'bun'
+                    ? 'add the plugin to the build script'
+                    : `no ${bundler} config found`,
+                file,
+                snippet: snippetFor(bundler, call),
+            };
+        }
+        return {
+            kind: 'write',
+            label: 'write',
+            note: bundler,
+            file,
+            contents: fresh,
+        };
+    }
+    const source = read(detected, bundlerConfig);
+    const kind = (0, source_1.moduleKindOf)(bundlerConfig, source);
+    if (bundler === 'next') {
+        const { names, rest } = (0, source_1.importedFrom)(source, '@plumeria/next-plugin');
+        const local = names.find((name) => (0, source_1.callsFunction)(rest, name));
+        if (local) {
+            return {
+                kind: 'skip',
+                label: 'skip',
+                note: 'withPlumeria is already applied',
+                file: bundlerConfig,
+            };
+        }
+        const bound = names[0];
+        const wrapped = (0, source_1.wrapDefaultExport)(bound
+            ? source
+            : (0, source_1.addImport)(source, NAMED_IMPORTS[kind]('withPlumeria', '@plumeria/next-plugin')), bound ?? 'withPlumeria', nextOptions(answers));
+        return wrapped
+            ? {
+                kind: 'patch',
+                label: 'patch',
+                note: `${bound ?? 'withPlumeria'}(...)`,
+                file: bundlerConfig,
+                contents: wrapped,
+            }
+            : {
+                kind: 'manual',
+                label: 'manual',
+                note: 'no default export to wrap',
+                file: bundlerConfig,
+                snippet: snippetFor(bundler, call),
+            };
+    }
+    const { names, rest } = (0, source_1.importedFrom)(source, '@plumeria/unplugin');
+    const used = names.find((name) => (0, source_1.callsMethod)(rest, name));
+    if (used) {
+        return {
+            kind: 'skip',
+            label: 'skip',
+            note: 'the plugin is already registered',
+            file: bundlerConfig,
+        };
+    }
+    const bound = names[0];
+    const entry = (0, exports.pluginCall)(bundler, answers, bound ?? 'plumeria');
+    const imported = bound
+        ? source
+        : (0, source_1.addImport)(source, IMPORTS[kind]('plumeria', '@plumeria/unplugin'));
+    const at = (0, source_1.pluginsArrayOf)(imported);
+    const patched = (at === undefined ? undefined : (0, source_1.appendAtArray)(imported, at, entry)) ??
+        (bundler === 'astro' ? addViteBlock(imported, entry) : undefined);
+    return patched
+        ? {
+            kind: 'patch',
+            label: 'patch',
+            note: entry,
+            file: bundlerConfig,
+            contents: patched,
+        }
+        : {
+            kind: 'manual',
+            label: 'manual',
+            note: 'no plugins array of its own to extend',
+            file: bundlerConfig,
+            snippet: snippetFor(bundler, call),
+        };
+};
+const IMPORTS = {
+    esm: (name, specifier) => `import ${name} from '${specifier}';`,
+    cjs: (name, specifier) => `const ${name} = require('${specifier}').default;`,
+};
+const NAMED_IMPORTS = {
+    esm: (name, specifier) => `import { ${name} } from '${specifier}';`,
+    cjs: (name, specifier) => `const { ${name} } = require('${specifier}');`,
+};
+const addViteBlock = (source, call) => {
+    const match = /\bdefineConfig\s*\(/.exec(source);
+    if (!match)
+        return undefined;
+    const open = source.indexOf('{', match.index + match[0].length - 1);
+    if (open === -1 || open > (0, source_1.closerOf)(source, match.index + match[0].length - 1))
+        return undefined;
+    return (0, source_1.appendInside)(source, open, [`vite: {\n  plugins: [${call}],\n}`]);
+};
+const snippetFor = (bundler, call) => {
+    if (bundler === 'next') {
+        return `import { withPlumeria } from '@plumeria/next-plugin';\n\nexport default withPlumeria(nextConfig);`;
+    }
+    const imported = `import plumeria from '@plumeria/unplugin';`;
+    if (bundler === 'astro') {
+        return `${imported}\n\nvite: {\n  plugins: [${call}],\n}`;
+    }
+    return `${imported}\n\nplugins: [${call}]`;
+};
+const eslintAction = (detected, answers) => {
+    const { eslintConfig, typescript } = detected;
+    const entries = (0, exports.eslintEntries)(answers, typescript);
+    if (!eslintConfig) {
+        return {
+            kind: 'write',
+            label: 'write',
+            note: 'plumeria.configs.recommended',
+            file: typescript ? 'eslint.config.ts' : 'eslint.config.mjs',
+            contents: (0, exports.eslintSource)(answers, typescript),
+        };
+    }
+    if (!eslintConfig.startsWith('eslint.config.')) {
+        return {
+            kind: 'manual',
+            label: 'manual',
+            note: 'flat config only',
+            file: eslintConfig,
+            snippet: `{\n  "plugins": ["@plumeria"],\n  "extends": ["plugin:@plumeria/recommended"]\n}`,
+        };
+    }
+    const source = read(detected, eslintConfig);
+    const { names, rest } = (0, source_1.importedFrom)(source, '@plumeria/eslint-plugin');
+    const used = names.find((name) => (0, source_1.readsMember)(rest, name, 'configs'));
+    if (used) {
+        return {
+            kind: 'skip',
+            label: 'skip',
+            note: 'the plugin is already configured',
+            file: eslintConfig,
+        };
+    }
+    const bound = names[0] ?? 'plumeria';
+    const patched = (0, source_1.appendToConfigList)(names.length > 0
+        ? source
+        : (0, source_1.addImport)(source, (0, source_1.moduleKindOf)(eslintConfig, source) === 'cjs'
+            ? `const plumeria = require('@plumeria/eslint-plugin');`
+            : `import plumeria from '@plumeria/eslint-plugin';`), entries.map((entry) => entry.replace(/^plumeria\.configs\b/, `${bound}.configs`)));
+    return patched
+        ? {
+            kind: 'patch',
+            label: 'patch',
+            note: `${bound}.configs.recommended`,
+            file: eslintConfig,
+            contents: patched,
+        }
+        : {
+            kind: 'manual',
+            label: 'manual',
+            note: 'no config list to extend',
+            file: eslintConfig,
+            snippet: entries.join(',\n'),
+        };
+};
+exports.CLEAN_SCRIPT = 'rimraf .next';
+const cleanScripts = (scripts) => {
+    const added = {};
+    for (const name of ['dev', 'build']) {
+        if (scripts[name] === undefined)
+            continue;
+        if (scripts[`pre${name}`] === undefined)
+            added[`pre${name}`] = exports.CLEAN_SCRIPT;
+    }
+    return added;
+};
+exports.cleanScripts = cleanScripts;
+const scriptAction = (detected, answers) => {
+    const source = read(detected, 'package.json');
+    const manifest = JSON.parse(source);
+    const scripts = { ...manifest.scripts };
+    const notes = [];
+    const existing = scripts.build;
+    if (answers.eslint && existing && !existing.includes('plumerialint')) {
+        scripts.build = (0, exports.buildScript)(existing);
+        notes.push(`build: ${scripts.build}`);
+    }
+    if (detected.bundler === 'next') {
+        const added = (0, exports.cleanScripts)(scripts);
+        for (const [name, script] of Object.entries(added)) {
+            scripts[name] = script;
+            notes.push(`${name}: ${script}`);
+        }
+    }
+    if (notes.length === 0) {
+        return {
+            kind: 'skip',
+            label: 'skip',
+            note: answers.eslint && !existing
+                ? 'no build script to guard'
+                : 'the scripts already carry it',
+            file: 'package.json',
+        };
+    }
+    return {
+        kind: 'patch',
+        label: 'patch',
+        note: notes.join(', '),
+        file: 'package.json',
+        contents: `${JSON.stringify({ ...manifest, scripts }, null, indentOfJson(source))}\n`,
+    };
+};

package/dist/source.d.ts

@@ -0,0 +1,30 @@
+export declare const closerOf: (source: string, open: number) => number;
+export declare const importsModule: (source: string, specifier: string) => boolean;
+export declare const addImport: (source: string, statement: string) => string;
+export declare const appendToArray: (source: string, key: string, entry: string) => string | undefined;
+export declare const appendAtArray: (source: string, open: number, entry: string) => string | undefined;
+export declare const appendToCall: (source: string, callee: string, entries: readonly string[]) => string | undefined;
+export declare const appendInside: (source: string, open: number, entries: readonly string[]) => string | undefined;
+export interface DefaultExport {
+    keyword: string;
+    start: number;
+    end: number;
+    expression: string;
+}
+export declare const defaultExportOf: (source: string) => DefaultExport | undefined;
+export declare const wrapDefaultExport: (source: string, wrapper: string, extra?: string) => string | undefined;
+export declare const appendToConfigList: (source: string, entries: readonly string[]) => string | undefined;
+export type ModuleKind = 'esm' | 'cjs';
+export declare const moduleKindOf: (file: string, source: string) => ModuleKind;
+export declare const directProperty: (source: string, open: number, key: string) => number | undefined;
+export declare const configObjects: (source: string) => number[];
+export declare const pluginsArrayOf: (source: string) => number | undefined;
+export interface Imported {
+    names: string[];
+    rest: string;
+}
+export declare const codeMask: (source: string) => string;
+export declare const importedFrom: (source: string, specifier: string) => Imported;
+export declare const callsMethod: (source: string, name: string) => boolean;
+export declare const callsFunction: (source: string, name: string) => boolean;
+export declare const readsMember: (source: string, name: string, member: string) => boolean;