@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/postcss/plugins/stylePluginScoped.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss_selector_parser_1 = __importDefault(require("postcss-selector-parser"));
+const scopedPlugin = () => {
+    return {
+        postcssPlugin: 'uni-sfc-scoped',
+        prepare({ processor: { plugins } }) {
+            const hasVueSfcScoped = !!plugins.find((plugin) => plugin.postcssPlugin === 'vue-sfc-scoped');
+            return {
+                Rule(rule) {
+                    processRule(rule, hasVueSfcScoped);
+                },
+            };
+        },
+    };
+};
+const processedRules = new WeakSet();
+function processRule(rule, hasVueSfcScoped) {
+    if (processedRules.has(rule) ||
+        (rule.parent &&
+            rule.parent.type === 'atrule' &&
+            /-?keyframes$/.test(rule.parent.name))) {
+        return;
+    }
+    processedRules.add(rule);
+    rule.selector = (0, postcss_selector_parser_1.default)((selectorRoot) => {
+        selectorRoot.each((selector) => {
+            hasVueSfcScoped
+                ? rewriteDeprecatedSelector(selector)
+                : rewriteSelector(selector, selectorRoot);
+        });
+    }).processSync(rule.selector);
+}
+/**
+ * @param selector
+ * @returns
+ */
+function rewriteDeprecatedSelector(selector) {
+    const nodes = [];
+    let deepNode;
+    selector.each((n) => {
+        if (deepNode) {
+            nodes.push(n);
+            selector.removeChild(n);
+        }
+        else {
+            const { type, value } = n;
+            if (type === 'pseudo' && value === '::v-deep') {
+                deepNode = n;
+            }
+            else if (type === 'combinator' &&
+                (value === '>>>' || value === '/deep/')) {
+                deepNode = n;
+            }
+        }
+    });
+    if (!deepNode) {
+        return;
+    }
+    if (deepNode.type === 'combinator') {
+        const index = selector.index(deepNode);
+        if (index > 0) {
+            selector.insertBefore(deepNode, postcss_selector_parser_1.default.combinator({ value: ' ' }));
+        }
+    }
+    // remove first combinator
+    // ::v-deep a{color:red;} => :deep(a){color:red;}
+    const firstNode = nodes[0];
+    if (firstNode && firstNode.type === 'combinator' && firstNode.value === ' ') {
+        nodes.shift();
+    }
+    selector.insertBefore(deepNode, postcss_selector_parser_1.default.pseudo({
+        value: ':deep',
+        nodes: [postcss_selector_parser_1.default.selector({ value: '', nodes })],
+    }));
+    selector.removeChild(deepNode);
+}
+function rewriteSelector(selector, selectorRoot) {
+    let node = null;
+    // find the last child node to insert attribute selector
+    selector.each((n) => {
+        // DEPRECATED ">>>" and "/deep/" combinator
+        if (n.type === 'combinator' &&
+            (n.value === '>>>' || n.value === '/deep/')) {
+            n.value = ' ';
+            n.spaces.before = n.spaces.after = '';
+            // warn(
+            //   `the >>> and /deep/ combinators have been deprecated. ` +
+            //     `Use :deep() instead.`
+            // )
+            return false;
+        }
+        if (n.type === 'pseudo') {
+            const { value } = n;
+            // deep: inject [id] attribute at the node before the ::v-deep
+            // combinator.
+            if (value === ':deep' || value === '::v-deep') {
+                if (n.nodes.length) {
+                    // .foo ::v-deep(.bar) -> .foo[xxxxxxx] .bar
+                    // replace the current node with ::v-deep's inner selector
+                    let last = n;
+                    n.nodes[0].each((ss) => {
+                        selector.insertAfter(last, ss);
+                        last = ss;
+                    });
+                    // insert a space combinator before if it doesn't already have one
+                    const prev = selector.at(selector.index(n) - 1);
+                    if (!prev || !isSpaceCombinator(prev)) {
+                        selector.insertAfter(n, postcss_selector_parser_1.default.combinator({
+                            value: ' ',
+                        }));
+                    }
+                    selector.removeChild(n);
+                }
+                else {
+                    // DEPRECATED usage
+                    // .foo ::v-deep .bar -> .foo[xxxxxxx] .bar
+                    // warn(
+                    //   `::v-deep usage as a combinator has ` +
+                    //     `been deprecated. Use :deep(<inner-selector>) instead.`
+                    // )
+                    const prev = selector.at(selector.index(n) - 1);
+                    if (prev && isSpaceCombinator(prev)) {
+                        selector.removeChild(prev);
+                    }
+                    selector.removeChild(n);
+                }
+                return false;
+            }
+            // slot: use selector inside `::v-slotted` and inject [id + '-s']
+            // instead.
+            // ::v-slotted(.foo) -> .foo[xxxxxxx-s]
+            if (value === ':slotted' || value === '::v-slotted') {
+                rewriteSelector(n.nodes[0], selectorRoot);
+                let last = n;
+                n.nodes[0].each((ss) => {
+                    selector.insertAfter(last, ss);
+                    last = ss;
+                });
+                // selector.insertAfter(n, n.nodes[0])
+                selector.removeChild(n);
+                // since slotted attribute already scopes the selector there's no
+                // need for the non-slot attribute.
+                return false;
+            }
+            // global: replace with inner selector and do not inject [id].
+            // ::v-global(.foo) -> .foo
+            if (value === ':global' || value === '::v-global') {
+                selectorRoot.insertAfter(selector, n.nodes[0]);
+                selectorRoot.removeChild(selector);
+                return false;
+            }
+        }
+        if (n.type !== 'pseudo' && n.type !== 'combinator') {
+            node = n;
+        }
+    });
+    if (node) {
+        ;
+        node.spaces.after = '';
+    }
+    else {
+        // For deep selectors & standalone pseudo selectors,
+        // the attribute selectors are prepended rather than appended.
+        // So all leading spaces must be eliminated to avoid problems.
+        selector.first.spaces.before = '';
+    }
+}
+function isSpaceCombinator(node) {
+    return node.type === 'combinator' && /^\s+$/.test(node.value);
+}
+scopedPlugin.postcss = true;
+exports.default = scopedPlugin;

package/dist/postcss/plugins/uniapp.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'postcss';
+export interface UniAppCssProcessorOptions {
+    unit?: string;
+    unitRatio?: number;
+    unitPrecision?: number;
+}
+declare const uniapp: {
+    (opts?: UniAppCssProcessorOptions | undefined): Plugin;
+    postcss: boolean;
+};
+export default uniapp;

package/dist/postcss/plugins/uniapp.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("@vue/shared");
+const postcss_selector_parser_1 = __importDefault(require("postcss-selector-parser"));
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const defaultUniAppCssProcessorOptions = (0, shared_1.extend)({}, uni_shared_1.defaultRpx2Unit);
+const BG_PROPS = [
+    'background',
+    'background-clip',
+    'background-color',
+    'background-image',
+    'background-origin',
+    'background-position',
+    'background-repeat',
+    'background-size',
+    'background-attachment',
+];
+function transform(selector, state, { rewriteTag }) {
+    if (selector.type !== 'tag') {
+        return;
+    }
+    const { value } = selector;
+    selector.value = rewriteTag(value);
+    if (value === 'page' && selector.value === 'uni-page-body') {
+        state.bg = true;
+    }
+}
+function createBodyBackgroundRule(origRule) {
+    const bgDecls = [];
+    origRule.walkDecls((decl) => {
+        if (BG_PROPS.indexOf(decl.prop) !== -1) {
+            bgDecls.push(decl.clone());
+        }
+    });
+    if (bgDecls.length) {
+        const { rule } = require('postcss');
+        origRule.after(rule({ selector: 'body' }).append(bgDecls));
+    }
+}
+function walkRules(options) {
+    return (rule) => {
+        const state = { bg: false };
+        rule.selector = (0, postcss_selector_parser_1.default)((selectors) => selectors.walk((selector) => transform(selector, state, options))).processSync(rule.selector);
+        state.bg && createBodyBackgroundRule(rule);
+    };
+}
+function walkDecls(rpx2unit) {
+    return (decl) => {
+        const { value } = decl;
+        if (value.indexOf('rpx') === -1 && value.indexOf('upx') === -1) {
+            return;
+        }
+        decl.value = rpx2unit(decl.value);
+    };
+}
+const baiduTags = {
+    navigator: 'nav',
+};
+function rewriteBaiduTags(tag) {
+    return baiduTags[tag] || tag;
+}
+function rewriteUniH5Tags(tag) {
+    if (tag === 'page') {
+        return 'uni-page-body';
+    }
+    if ((0, uni_shared_1.isBuiltInComponent)(tag)) {
+        return uni_shared_1.COMPONENT_SELECTOR_PREFIX + tag;
+    }
+    return tag;
+}
+function rewriteUniAppTags(tag) {
+    if (tag === 'page') {
+        return 'body';
+    }
+    if ((0, uni_shared_1.isBuiltInComponent)(tag)) {
+        return uni_shared_1.COMPONENT_SELECTOR_PREFIX + tag;
+    }
+    return tag;
+}
+const transforms = {
+    h5: rewriteUniH5Tags,
+    app: rewriteUniAppTags,
+    'mp-baidu': rewriteBaiduTags,
+};
+const uniapp = (opts) => {
+    const platform = process.env.UNI_PLATFORM;
+    const { unit, unitRatio, unitPrecision } = (0, shared_1.extend)({}, defaultUniAppCssProcessorOptions, opts);
+    const rpx2unit = (0, uni_shared_1.createRpx2Unit)(unit, unitRatio, unitPrecision);
+    return {
+        postcssPlugin: 'uni-app',
+        prepare() {
+            return {
+                OnceExit(root) {
+                    root.walkDecls(walkDecls(rpx2unit));
+                    const rewriteTag = transforms[platform];
+                    if (rewriteTag) {
+                        root.walkRules(walkRules({
+                            rewriteTag,
+                        }));
+                    }
+                },
+            };
+        },
+    };
+};
+uniapp.postcss = true;
+exports.default = uniapp;

package/dist/preprocess/context.d.ts

@@ -0,0 +1,3 @@
+export declare function getPreVueContext(): any;
+export declare function getPreNVueContext(): any;
+export declare function initPreContext(platform: UniApp.PLATFORM, userPreContext?: Record<string, boolean> | string): void;

package/dist/preprocess/context.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPreContext = exports.getPreNVueContext = exports.getPreVueContext = void 0;
+const shared_1 = require("@vue/shared");
+const DEFAULT_KEYS = [
+    'APP',
+    'APP_NVUE',
+    'APP_PLUS',
+    'APP_PLUS_NVUE',
+    'APP_VUE',
+    'H5',
+    'MP',
+    'MP_360',
+    'MP_ALIPAY',
+    'MP_BAIDU',
+    'MP_QQ',
+    'MP_LARK',
+    'MP_TOUTIAO',
+    'MP_WEIXIN',
+    'MP_KUAISHOU',
+    'MP_JD',
+    'QUICKAPP_NATIVE',
+    'QUICKAPP_WEBVIEW',
+    'QUICKAPP_WEBVIEW_HUAWEI',
+    'QUICKAPP_WEBVIEW_UNION',
+    'VUE2',
+    'VUE3',
+];
+const preVueContext = Object.create(null);
+const preNVueContext = Object.create(null);
+function getPreVueContext() {
+    return preVueContext;
+}
+exports.getPreVueContext = getPreVueContext;
+function getPreNVueContext() {
+    return preNVueContext;
+}
+exports.getPreNVueContext = getPreNVueContext;
+function initPreContext(platform, userPreContext) {
+    const vueContext = Object.create(null);
+    const nvueContext = Object.create(null);
+    const defaultContext = Object.create(null);
+    DEFAULT_KEYS.forEach((key) => {
+        defaultContext[key] = false;
+    });
+    defaultContext[normalizeKey(platform)] = true;
+    vueContext.VUE3 = true;
+    nvueContext.VUE2 = true;
+    if (platform === 'app' || platform === 'app-plus') {
+        defaultContext.APP = true;
+        defaultContext.APP_PLUS = true;
+        vueContext.APP_VUE = true;
+        nvueContext.APP_NVUE = true;
+        nvueContext.APP_PLUS_NVUE = true;
+    }
+    else if (platform.startsWith('mp-')) {
+        defaultContext.MP = true;
+    }
+    else if (platform.startsWith('quickapp-webview')) {
+        defaultContext.QUICKAPP_WEBVIEW = true;
+    }
+    if (userPreContext) {
+        if ((0, shared_1.isString)(userPreContext)) {
+            try {
+                userPreContext = JSON.parse(userPreContext);
+            }
+            catch (e) { }
+        }
+        if ((0, shared_1.isPlainObject)(userPreContext)) {
+            Object.keys(userPreContext).forEach((key) => {
+                defaultContext[normalizeKey(key)] = !!userPreContext[key];
+            });
+        }
+    }
+    (0, shared_1.extend)(preVueContext, defaultContext, vueContext);
+    (0, shared_1.extend)(preNVueContext, defaultContext, nvueContext);
+}
+exports.initPreContext = initPreContext;
+function normalizeKey(name) {
+    return name.replace(/-/g, '_').toUpperCase();
+}

package/dist/preprocess/index.d.ts

@@ -0,0 +1,9 @@
+export { initPreContext } from './context';
+export declare function preJs(jsCode: string): any;
+export declare function preHtml(htmlCode: string): any;
+export declare const preCss: typeof preJs;
+export declare const preJson: typeof preJs;
+export declare function preNVueJs(jsCode: string): any;
+export declare function preNVueHtml(htmlCode: string): any;
+export declare const preNVueCss: typeof preNVueJs;
+export declare const preNVueJson: typeof preNVueJs;

package/dist/preprocess/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preNVueJson = exports.preNVueCss = exports.preNVueHtml = exports.preNVueJs = exports.preJson = exports.preCss = exports.preHtml = exports.preJs = exports.initPreContext = void 0;
+const context_1 = require("./context");
+/* eslint-disable no-restricted-globals */
+const { preprocess } = require('../../lib/preprocess');
+var context_2 = require("./context");
+Object.defineProperty(exports, "initPreContext", { enumerable: true, get: function () { return context_2.initPreContext; } });
+function preJs(jsCode) {
+    return preprocess(jsCode, (0, context_1.getPreVueContext)(), { type: 'js' });
+}
+exports.preJs = preJs;
+function preHtml(htmlCode) {
+    return preprocess(htmlCode, (0, context_1.getPreVueContext)(), { type: 'html' });
+}
+exports.preHtml = preHtml;
+exports.preCss = preJs;
+exports.preJson = preJs;
+function preNVueJs(jsCode) {
+    return preprocess(jsCode, (0, context_1.getPreNVueContext)(), { type: 'js' });
+}
+exports.preNVueJs = preNVueJs;
+function preNVueHtml(htmlCode) {
+    return preprocess(htmlCode, (0, context_1.getPreNVueContext)(), { type: 'html' });
+}
+exports.preNVueHtml = preNVueHtml;
+exports.preNVueCss = preNVueJs;
+exports.preNVueJson = preNVueJs;

package/dist/resolve.d.ts

@@ -0,0 +1,6 @@
+export declare function requireResolve(filename: string, basedir: string): string;
+export declare function relativeFile(from: string, to: string): string;
+export declare const resolveMainPathOnce: (inputDir: string) => string;
+export declare function getBuiltInPaths(): string[];
+export declare function resolveBuiltIn(path: string): string;
+export declare function resolveComponentsLibPath(): string;

package/dist/resolve.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveComponentsLibPath = exports.resolveBuiltIn = exports.getBuiltInPaths = exports.resolveMainPathOnce = exports.relativeFile = exports.requireResolve = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const resolve_1 = __importDefault(require("resolve"));
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const utils_1 = require("./utils");
+const env_1 = require("./hbx/env");
+const constants_1 = require("./constants");
+function requireResolve(filename, basedir) {
+    return resolveWithSymlinks(filename, basedir);
+}
+exports.requireResolve = requireResolve;
+function resolveWithSymlinks(id, basedir) {
+    return resolve_1.default.sync(id, {
+        basedir,
+        extensions: constants_1.extensions,
+        // necessary to work with pnpm
+        preserveSymlinks: true,
+    });
+}
+function relativeFile(from, to) {
+    const relativePath = (0, utils_1.normalizePath)(path_1.default.relative(path_1.default.dirname(from), to));
+    return relativePath.startsWith('.') ? relativePath : './' + relativePath;
+}
+exports.relativeFile = relativeFile;
+exports.resolveMainPathOnce = (0, uni_shared_1.once)((inputDir) => {
+    const mainTsPath = path_1.default.resolve(inputDir, 'main.ts');
+    if (fs_1.default.existsSync(mainTsPath)) {
+        return (0, utils_1.normalizePath)(mainTsPath);
+    }
+    return (0, utils_1.normalizePath)(path_1.default.resolve(inputDir, 'main.js'));
+});
+const ownerModules = ['@dcloudio/uni-app', '@dcloudio/vite-plugin-uni'];
+const paths = [];
+function resolveNodeModulePath(modulePath) {
+    const nodeModulesPaths = [];
+    const nodeModulesPath = path_1.default.join(modulePath, 'node_modules');
+    if (fs_1.default.existsSync(nodeModulesPath)) {
+        nodeModulesPaths.push(nodeModulesPath);
+    }
+    const index = modulePath.lastIndexOf('node_modules');
+    if (index > -1) {
+        nodeModulesPaths.push(path_1.default.join(modulePath.substr(0, index), 'node_modules'));
+    }
+    return nodeModulesPaths;
+}
+function initPaths() {
+    const cliContext = process.env.UNI_CLI_CONTEXT;
+    if (cliContext) {
+        const pathSet = new Set();
+        pathSet.add(path_1.default.join(cliContext, 'node_modules'));
+        if (!(0, env_1.isInHBuilderX)()) {
+            ;
+            [`@dcloudio/uni-` + process.env.UNI_PLATFORM, ...ownerModules].forEach((ownerModule) => {
+                let pkgPath = '';
+                try {
+                    pkgPath = require.resolve(ownerModule + '/package.json', {
+                        paths: [cliContext],
+                    });
+                }
+                catch (e) { }
+                if (pkgPath) {
+                    resolveNodeModulePath(path_1.default.dirname(pkgPath)).forEach((nodeModulePath) => {
+                        pathSet.add(nodeModulePath);
+                    });
+                }
+            });
+        }
+        paths.push(...pathSet);
+        (0, debug_1.default)('uni-paths')(paths);
+    }
+}
+function getBuiltInPaths() {
+    if (!paths.length) {
+        initPaths();
+    }
+    return paths;
+}
+exports.getBuiltInPaths = getBuiltInPaths;
+function resolveBuiltIn(path) {
+    return require.resolve(path, { paths: getBuiltInPaths() });
+}
+exports.resolveBuiltIn = resolveBuiltIn;
+let componentsLibPath = '';
+function resolveComponentsLibPath() {
+    if (!componentsLibPath) {
+        if ((0, env_1.isInHBuilderX)()) {
+            componentsLibPath = path_1.default.join(resolveBuiltIn('@dcloudio/uni-components/package.json'), '../lib');
+        }
+        else {
+            componentsLibPath = path_1.default.join(resolveWithSymlinks('@dcloudio/uni-components/package.json', process.env.UNI_INPUT_DIR), '../lib');
+        }
+    }
+    return componentsLibPath;
+}
+exports.resolveComponentsLibPath = resolveComponentsLibPath;

package/dist/scripts.d.ts

@@ -0,0 +1,10 @@
+export declare function parseScripts(name: string, pkgPath: string): {
+    name: string;
+    platform: keyof UniApp.PagesJsonPagePlatformStyle;
+    define: {
+        [name: string]: string;
+    };
+    context: {
+        [name: string]: boolean;
+    };
+} | undefined;

package/dist/scripts.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScripts = void 0;
+const shared_1 = require("@vue/shared");
+const fs_1 = __importDefault(require("fs"));
+function parseScripts(name, pkgPath) {
+    var _a, _b;
+    if (!fs_1.default.existsSync(pkgPath)) {
+        return;
+    }
+    const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+    const scripts = ((_a = pkg['uni-app']) === null || _a === void 0 ? void 0 : _a.scripts) || {};
+    const options = scripts[name];
+    if (!options) {
+        return;
+    }
+    if (!((_b = options.env) === null || _b === void 0 ? void 0 : _b.UNI_PLATFORM)) {
+        console.error(`package.json->uni-app->scripts->${name}->env->UNI_PLATFORM is required`);
+        process.exit(0);
+    }
+    const { UNI_PLATFORM, ...define } = options.env;
+    const context = options.define || {};
+    // 补充当前编译环境未定义的其他编译环境 define
+    Object.keys(scripts).forEach((scriptName) => {
+        if (scriptName !== name) {
+            const scriptDefine = scripts[scriptName].define || {};
+            Object.keys(scriptDefine).forEach((key) => {
+                if (!(0, shared_1.hasOwn)(context, key)) {
+                    context[key] = false;
+                }
+            });
+        }
+    });
+    return {
+        name: name,
+        platform: UNI_PLATFORM,
+        define,
+        context,
+    };
+}
+exports.parseScripts = parseScripts;

package/dist/ssr.d.ts

@@ -0,0 +1,4 @@
+export declare const stripOptions: {
+    include: string[];
+    functions: string[];
+};

package/dist/ssr.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripOptions = void 0;
+exports.stripOptions = {
+    include: ['**/*.js', '**/*.ts', '**/*.tsx', '**/*.vue'],
+    functions: [
+        'onBeforeMount',
+        'onMounted',
+        'onBeforeUpdate',
+        'onUpdated',
+        'onActivated',
+        'onDeactivated',
+        'onBeforeActivate',
+        'onBeforeDeactivate',
+        'onBeforeUnmount',
+        'onUnmounted',
+        'onRenderTracked',
+        'onRenderTriggered',
+    ],
+};

package/dist/url.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeBase64Url(str: string): string;
+export declare function decodeBase64Url(str: string): string;

package/dist/url.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64Url = exports.encodeBase64Url = void 0;
+const base64url_1 = __importDefault(require("base64url"));
+function encodeBase64Url(str) {
+    return base64url_1.default.encode(str);
+}
+exports.encodeBase64Url = encodeBase64Url;
+function decodeBase64Url(str) {
+    return base64url_1.default.decode(str);
+}
+exports.decodeBase64Url = decodeBase64Url;

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+export { default as hash } from 'hash-sum';
+import { ElementNode, RootNode, TemplateChildNode } from '@vue/compiler-core';
+import { ParserPlugin } from '@babel/parser';
+export declare let isRunningWithYarnPnp: boolean;
+export declare const isWindows: boolean;
+export declare function normalizePath(id: string): string;
+export declare function checkElementNodeTag(node: RootNode | TemplateChildNode | null | undefined, tag: string): node is ElementNode;
+export declare function normalizeIdentifier(str: string): string;
+export declare function normalizePagePath(pagePath: string, platform: UniApp.PLATFORM): string | undefined;
+export declare function removeExt(str: string): string;
+export declare function normalizeNodeModules(str: string): string;
+export declare function normalizeMiniProgramFilename(filename: string, inputDir?: string): string;
+export declare function normalizeParsePlugins(importer: string, babelParserPlugins?: ParserPlugin[]): ParserPlugin[];