@dimina-kit/compiler 0.0.1-dev.20260702173719

package/dist/pool.node.js

@@ -0,0 +1,3743 @@
+// src/pool-node.js
+import { createRequire } from "node:module";
+import nodeFs from "node:fs";
+import nodePath from "node:path";
+import process4 from "node:process";
+
+// src/shims/fs.js
+var current = null;
+function setFs(impl) {
+  current = impl;
+}
+function resetFs() {
+  current = null;
+}
+var call = (name) => (...args) => {
+  if (!current) throw new Error("[compiler] no fs backend injected \u2014 call compileMiniApp({ fs })");
+  const fn = current[name];
+  if (typeof fn === "function") return fn.apply(current, args);
+  throw new Error(`[compiler] injected fs is missing ${name}()`);
+};
+var existsSync = call("existsSync");
+var readFileSync = call("readFileSync");
+var writeFileSync = call("writeFileSync");
+var mkdirSync = call("mkdirSync");
+var rmSync = call("rmSync");
+var rmdirSync = call("rmdirSync");
+var readdirSync = call("readdirSync");
+var copyFileSync = call("copyFileSync");
+var statSync = call("statSync");
+var lstatSync = call("lstatSync");
+var unlinkSync = call("unlinkSync");
+var renameSync = call("renameSync");
+var appendFileSync = call("appendFileSync");
+var realpathSync = call("realpathSync");
+var accessSync = call("accessSync");
+var readlinkSync = call("readlinkSync");
+var watch = call("watch");
+var promises = new Proxy({}, {
+  get: (_t, prop) => (...args) => {
+    if (!current || !current.promises || typeof current.promises[prop] !== "function") {
+      throw new Error(`[compiler] injected fs has no promises.${String(prop)}()`);
+    }
+    return current.promises[prop](...args);
+  }
+});
+
+// ../../dimina/fe/packages/compiler/src/env.js
+import fs3 from "node:fs";
+import os from "node:os";
+import path4 from "node:path";
+import process2 from "node:process";
+
+// ../../dimina/fe/packages/compiler/src/common/path-utils.js
+import path from "node:path";
+var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
+function isWindowsFsPath(targetPath) {
+  return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
+}
+function getFsPathApi(targetPath) {
+  return isWindowsFsPath(targetPath) ? path.win32 : path.posix;
+}
+function normalizeToPosixPath(targetPath) {
+  return targetPath.replace(/\\/g, "/");
+}
+function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
+  const pathApi = getFsPathApi(importerPath || workPath);
+  return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
+}
+function toMiniProgramModuleId(resolvedPath, workPath) {
+  const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
+  const normalizedWorkPath = normalizeToPosixPath(workPath);
+  let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
+  moduleId = moduleId.replace(/\/+/g, "/");
+  if (!moduleId.startsWith("/")) {
+    moduleId = `/${moduleId}`;
+  }
+  return moduleId;
+}
+function getRelativePosixPath(targetPath, rootPath) {
+  return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
+}
+
+// ../../dimina/fe/packages/compiler/src/common/utils.js
+import fs from "node:fs";
+import path2 from "node:path";
+import process from "node:process";
+function hasCompileInfo(modulePath, list, preList) {
+  const mergeList = Array.isArray(preList) ? [...preList, ...list] : list;
+  for (const element of mergeList) {
+    if (element.path === modulePath) {
+      return true;
+    }
+  }
+  return false;
+}
+function getAbsolutePath(workPath, pagePath, src) {
+  if (src.startsWith("/")) {
+    return path2.join(workPath, src);
+  }
+  if (pagePath.includes("/miniprogram_npm/")) {
+    const componentDir = pagePath.split("/").slice(0, -1).join("/");
+    const componentFullPath = workPath + componentDir;
+    return path2.resolve(componentFullPath, src);
+  }
+  const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
+  return path2.resolve(workPath, relativePath, src);
+}
+var assetsMap = {};
+function collectAssets(workPath, pagePath, src, targetPath, appId) {
+  if (src.startsWith("http") || src.startsWith("//")) {
+    return src;
+  }
+  if (!/\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(src)) {
+    return src;
+  }
+  const relativePath = pagePath.split("/").slice(0, -1).join("/");
+  const absolutePath = src.startsWith("/") ? workPath + src : path2.resolve(workPath, relativePath, src);
+  if (assetsMap[absolutePath]) {
+    return assetsMap[absolutePath];
+  }
+  try {
+    const ext = `.${src.split(".").pop()}`;
+    const dirPath = absolutePath.split(path2.sep).slice(0, -1).join("/");
+    const prefix = uuid();
+    const targetStatic = `${targetPath}/main/static`;
+    if (!fs.existsSync(targetStatic)) {
+      fs.mkdirSync(targetStatic, { recursive: true });
+    }
+    getFilesWithExtension(dirPath, ext).forEach((file) => {
+      fs.copyFileSync(path2.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+    });
+    const filename = src.split("/").pop();
+    const pathPrefix = process.env.ASSETS_PATH_PREFIX ? "" : "/";
+    assetsMap[absolutePath] = `${pathPrefix}${appId}/main/static/${prefix}_${filename}`;
+  } catch (error) {
+    console.log(error);
+  }
+  return assetsMap[absolutePath] || src;
+}
+function getFilesWithExtension(directory, extension) {
+  const files = fs.readdirSync(directory);
+  const filteredFiles = files.filter((file) => path2.extname(file) === extension);
+  return filteredFiles;
+}
+function isObjectEmpty(objectName) {
+  if (!objectName) {
+    return true;
+  }
+  return Object.keys(objectName).length === 0 && objectName.constructor === Object;
+}
+function isString(o) {
+  return Object.prototype.toString.call(o) === "[object String]";
+}
+function transformRpx(styleText) {
+  if (!isString(styleText)) {
+    return styleText;
+  }
+  return styleText.replace(/([+-]?\d+(?:\.\d+)?)rpx/g, (_, pixel) => {
+    return `${Number(pixel)}rem`;
+  });
+}
+function uuid() {
+  return Math.random().toString(36).slice(2, 7);
+}
+var tagWhiteList = [
+  "page",
+  "wrapper",
+  "block",
+  "button",
+  "camera",
+  "checkbox-group",
+  "checkbox",
+  "cover-image",
+  "cover-view",
+  "form",
+  "icon",
+  "image",
+  "input",
+  "keyboard-accessory",
+  "label",
+  "map",
+  "movable-area",
+  "movable-view",
+  "navigation-bar",
+  "navigator",
+  "open-data",
+  "page-meta",
+  "picker-view-column",
+  "picker-view",
+  "picker",
+  "progress",
+  "radio-group",
+  "radio",
+  "rich-text",
+  "root-portal",
+  "scroll-view",
+  "slider",
+  "swiper-item",
+  "swiper",
+  "switch",
+  "template",
+  "text",
+  "textarea",
+  "video",
+  "view",
+  "web-view"
+];
+function __resetAssets() {
+  for (const k of Object.keys(assetsMap)) delete assetsMap[k];
+}
+
+// ../../dimina/fe/packages/compiler/src/common/npm-resolver.js
+import fs2 from "node:fs";
+import path3 from "node:path";
+var NpmResolver = class {
+  constructor(workPath) {
+    this.workPath = workPath;
+    this.miniprogramNpmCache = /* @__PURE__ */ new Map();
+    this.packageCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 解析组件路径，支持 npm 包组件
+   * @param {string} componentPath 组件路径
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string} 解析后的组件路径
+   */
+  resolveComponentPath(componentPath, pageFilePath) {
+    if (componentPath.startsWith("./") || componentPath.startsWith("../") || componentPath.startsWith("/")) {
+      return this.resolveRelativePath(componentPath, pageFilePath);
+    }
+    const npmPath = this.resolveNpmComponent(componentPath, pageFilePath);
+    if (npmPath) {
+      return npmPath;
+    }
+    return this.resolveRelativePath(componentPath, pageFilePath);
+  }
+  /**
+   * 解析相对路径组件
+   * @param {string} componentPath 组件路径
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string} 解析后的路径
+   */
+  resolveRelativePath(componentPath, pageFilePath) {
+    return toMiniProgramModuleId(
+      resolveMiniProgramPath(this.workPath, pageFilePath, componentPath),
+      this.workPath
+    );
+  }
+  /**
+   * 解析 npm 组件
+   * @param {string} componentName 组件名称
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string|null} 解析后的组件路径，如果找不到返回 null
+   */
+  resolveNpmComponent(componentName, pageFilePath) {
+    const searchPaths = this.generateSearchPaths(pageFilePath);
+    for (const searchPath of searchPaths) {
+      const componentPath = this.findComponentInMiniprogramNpm(componentName, searchPath);
+      if (componentPath) {
+        return componentPath;
+      }
+    }
+    return null;
+  }
+  /**
+   * 解析脚本模块路径，支持微信小程序 npm 逐级寻址和 package.json 入口
+   * @param {string} specifier 模块导入路径
+   * @param {string} modulePath 当前模块绝对文件路径
+   * @param {(moduleId: string) => string | null} resolveExistingModuleId 解析真实存在模块的回调
+   * @returns {string|null} 解析后的模块 id
+   */
+  resolveScriptModule(specifier, modulePath, resolveExistingModuleId) {
+    if (!specifier || !resolveExistingModuleId) {
+      return null;
+    }
+    for (const searchPath of this.generateSearchPaths(modulePath)) {
+      const moduleId = this.normalizeModuleId(`/${searchPath}/${specifier}`);
+      const resolvedModuleId = resolveExistingModuleId(moduleId);
+      if (resolvedModuleId) {
+        return resolvedModuleId;
+      }
+    }
+    return null;
+  }
+  /**
+   * 生成 miniprogram_npm 搜索路径
+   * 按照微信小程序的寻址顺序生成搜索路径
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string[]} 搜索路径数组
+   */
+  generateSearchPaths(pageFilePath) {
+    const relativePath = getRelativePosixPath(pageFilePath, this.workPath);
+    const pathParts = relativePath.split("/").slice(0, -1);
+    const searchPaths = [];
+    for (let i = pathParts.length; i >= 0; i--) {
+      const currentPath = pathParts.slice(0, i).join("/");
+      const miniprogramNpmPath = currentPath ? `${currentPath}/miniprogram_npm` : "miniprogram_npm";
+      searchPaths.push(miniprogramNpmPath);
+    }
+    return searchPaths;
+  }
+  /**
+   * 在指定的 miniprogram_npm 目录中查找组件
+   * @param {string} componentName 组件名称
+   * @param {string} miniprogramNpmPath miniprogram_npm 路径
+   * @returns {string|null} 组件路径，如果找不到返回 null
+   */
+  findComponentInMiniprogramNpm(componentName, miniprogramNpmPath) {
+    const fullMiniprogramNpmPath = path3.join(this.workPath, miniprogramNpmPath);
+    if (!fs2.existsSync(fullMiniprogramNpmPath)) {
+      return null;
+    }
+    const cacheKey = `${miniprogramNpmPath}/${componentName}`;
+    if (this.miniprogramNpmCache.has(cacheKey)) {
+      return this.miniprogramNpmCache.get(cacheKey);
+    }
+    const candidatePaths = [
+      componentName,
+      `${componentName}/index`
+    ];
+    for (const candidatePath of candidatePaths) {
+      const componentDir = path3.join(fullMiniprogramNpmPath, candidatePath);
+      if (this.isValidComponent(componentDir)) {
+        const resolvedPath = `/${miniprogramNpmPath}/${candidatePath}`.replace(/\/+/g, "/");
+        this.miniprogramNpmCache.set(cacheKey, resolvedPath);
+        return resolvedPath;
+      }
+    }
+    this.miniprogramNpmCache.set(cacheKey, null);
+    return null;
+  }
+  normalizeModuleId(moduleId) {
+    let normalized = moduleId.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
+    if (!normalized.startsWith("/")) {
+      normalized = `/${normalized}`;
+    }
+    return normalized;
+  }
+  /**
+   * 检查是否为有效的组件
+   * @param {string} componentPath 组件路径
+   * @returns {boolean} 是否为有效组件
+   */
+  isValidComponent(componentPath) {
+    const requiredFiles = [".json", ".js"];
+    const hasRequiredFiles = requiredFiles.some((ext) => {
+      return fs2.existsSync(`${componentPath}${ext}`);
+    });
+    if (!hasRequiredFiles) {
+      const indexFiles = requiredFiles.some((ext) => {
+        return fs2.existsSync(path3.join(componentPath, `index${ext}`));
+      });
+      if (!indexFiles) {
+        return false;
+      }
+      const indexJsonFile = path3.join(componentPath, "index.json");
+      if (fs2.existsSync(indexJsonFile)) {
+        try {
+          const config = JSON.parse(fs2.readFileSync(indexJsonFile, "utf-8"));
+          return config.component === true;
+        } catch (e) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const jsonFile = `${componentPath}.json`;
+    if (fs2.existsSync(jsonFile)) {
+      try {
+        const config = JSON.parse(fs2.readFileSync(jsonFile, "utf-8"));
+        return config.component === true;
+      } catch (e) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 获取 npm 包信息
+   * @param {string} packageName 包名
+   * @param {string} searchPath 搜索路径
+   * @returns {object|null} 包信息，如果找不到返回 null
+   */
+  getPackageInfo(packageName, searchPath) {
+    const cacheKey = `${searchPath}/${packageName}`;
+    if (this.packageCache.has(cacheKey)) {
+      return this.packageCache.get(cacheKey);
+    }
+    const packageJsonPath = path3.join(this.workPath, searchPath, packageName, "package.json");
+    if (!fs2.existsSync(packageJsonPath)) {
+      this.packageCache.set(cacheKey, null);
+      return null;
+    }
+    try {
+      const packageInfo = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+      this.packageCache.set(cacheKey, packageInfo);
+      return packageInfo;
+    } catch (e) {
+      this.packageCache.set(cacheKey, null);
+      return null;
+    }
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.miniprogramNpmCache.clear();
+    this.packageCache.clear();
+  }
+};
+
+// ../../dimina/fe/packages/compiler/src/env.js
+var pathInfo = {};
+var configInfo = {};
+var npmResolver = null;
+var DEFAULT_TEMPLATE_EXTS = [".wxml", ".ddml"];
+var DEFAULT_STYLE_EXTS = [".wxss", ".ddss", ".less", ".scss", ".sass"];
+var DEFAULT_VIEW_SCRIPT_EXTS = [".wxs"];
+var DEFAULT_VIEW_SCRIPT_TAGS = ["wxs", "dds"];
+var RESERVED_EXTS = /* @__PURE__ */ new Set([
+  ...DEFAULT_TEMPLATE_EXTS,
+  ...DEFAULT_STYLE_EXTS,
+  ...DEFAULT_VIEW_SCRIPT_EXTS,
+  ".js",
+  ".ts",
+  ".json"
+]);
+var compilerOptions = normalizeFileTypes();
+function normalizeExt(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const v = raw.trim().toLowerCase().replace(/^\.+/, "");
+  if (!/^[a-z0-9_-]+$/.test(v)) {
+    return null;
+  }
+  return `.${v}`;
+}
+function normalizeTag(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const v = raw.trim().toLowerCase().replace(/^\.+/, "");
+  if (!/^[a-z][a-z0-9_-]*$/.test(v)) {
+    return null;
+  }
+  return v;
+}
+function mergeUnique(builtins, custom, normalizer, reserved) {
+  const out = [...builtins];
+  const seen = new Set(builtins);
+  if (Array.isArray(custom)) {
+    for (const raw of custom) {
+      const n = normalizer(raw);
+      if (n && !seen.has(n) && !reserved?.has(n)) {
+        seen.add(n);
+        out.push(n);
+      }
+    }
+  }
+  return out;
+}
+function normalizeFileTypes(fileTypes = {}) {
+  const ft = fileTypes || {};
+  return {
+    templateExts: mergeUnique(DEFAULT_TEMPLATE_EXTS, ft.template, normalizeExt, RESERVED_EXTS),
+    styleExts: mergeUnique(DEFAULT_STYLE_EXTS, ft.style, normalizeExt, RESERVED_EXTS),
+    viewScriptExts: mergeUnique(DEFAULT_VIEW_SCRIPT_EXTS, ft.viewScript, normalizeExt, RESERVED_EXTS),
+    viewScriptTags: mergeUnique(DEFAULT_VIEW_SCRIPT_TAGS, ft.viewScript, normalizeTag)
+  };
+}
+function storeInfo(workPath, options = {}) {
+  storePathInfo(workPath);
+  storeProjectConfig();
+  storeAppConfig();
+  storePageConfig();
+  compilerOptions = normalizeFileTypes(options.fileTypes);
+  return {
+    pathInfo,
+    configInfo,
+    compilerOptions
+  };
+}
+function resetStoreInfo(opts) {
+  pathInfo = opts.pathInfo;
+  configInfo = opts.configInfo;
+  compilerOptions = opts.compilerOptions || normalizeFileTypes();
+  if (pathInfo.workPath) {
+    npmResolver = new NpmResolver(pathInfo.workPath);
+  }
+}
+function getTemplateExts() {
+  return compilerOptions.templateExts;
+}
+function getStyleExts() {
+  return compilerOptions.styleExts;
+}
+function getViewScriptExts() {
+  return compilerOptions.viewScriptExts;
+}
+function getViewScriptTags() {
+  return compilerOptions.viewScriptTags;
+}
+function storePathInfo(workPath) {
+  pathInfo.workPath = workPath;
+  if (process2.env.TARGET_PATH) {
+    pathInfo.targetPath = process2.env.TARGET_PATH;
+  } else {
+    const tempDir = process2.env.GITHUB_WORKSPACE || os.tmpdir();
+    const targetDir = path4.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+    if (!fs3.existsSync(targetDir)) {
+      fs3.mkdirSync(targetDir, { recursive: true });
+    }
+    pathInfo.targetPath = targetDir;
+  }
+  npmResolver = new NpmResolver(workPath);
+}
+function storeProjectConfig() {
+  const privateConfigPath = `${pathInfo.workPath}/project.private.config.json`;
+  const defaultConfigPath = `${pathInfo.workPath}/project.config.json`;
+  let privateConfig = {};
+  let defaultConfig = {};
+  if (fs3.existsSync(defaultConfigPath)) {
+    try {
+      defaultConfig = parseContentByPath(defaultConfigPath);
+    } catch (e) {
+      console.warn("Failed to parse project.config.json:", e.message);
+    }
+  }
+  if (fs3.existsSync(privateConfigPath)) {
+    try {
+      privateConfig = parseContentByPath(privateConfigPath);
+    } catch (e) {
+      console.warn("Failed to parse project.private.config.json:", e.message);
+    }
+  }
+  configInfo.projectInfo = { ...defaultConfig, ...privateConfig };
+}
+function storeAppConfig() {
+  const filePath = `${pathInfo.workPath}/app.json`;
+  const content = parseContentByPath(filePath);
+  const newObj = {};
+  for (const key in content) {
+    if (Object.prototype.hasOwnProperty.call(content, key)) {
+      if (key === "subpackages") {
+        newObj.subPackages = content[key];
+      } else {
+        newObj[key] = content[key];
+      }
+    }
+  }
+  configInfo.appInfo = newObj;
+}
+function getContentByPath(path9) {
+  return fs3.readFileSync(path9, { encoding: "utf-8" });
+}
+function parseContentByPath(path9) {
+  return JSON.parse(getContentByPath(path9));
+}
+function storePageConfig() {
+  const { pages, subPackages } = configInfo.appInfo;
+  configInfo.pageInfo = {};
+  configInfo.componentInfo = {};
+  if (configInfo.appInfo.usingComponents) {
+    const appFilePath = `${pathInfo.workPath}/app.json`;
+    storeComponentConfig(configInfo.appInfo, appFilePath);
+  }
+  collectionPageJson(pages);
+  if (subPackages) {
+    subPackages.forEach((subPkg) => {
+      collectionPageJson(subPkg.pages, subPkg.root);
+    });
+  }
+}
+function collectionPageJson(pages, root) {
+  pages.forEach((pagePath) => {
+    let np = pagePath;
+    if (root) {
+      if (!root.endsWith("/")) {
+        root += "/";
+      }
+      np = root + np;
+    }
+    const pageFilePath = `${pathInfo.workPath}/${np}.json`;
+    if (fs3.existsSync(pageFilePath)) {
+      const pageJsonContent = parseContentByPath(pageFilePath);
+      if (root) {
+        pageJsonContent.root = transSubDir(root);
+      }
+      configInfo.pageInfo[np] = pageJsonContent;
+      storeComponentConfig(pageJsonContent, pageFilePath);
+    }
+  });
+}
+function storeComponentConfig(pageJsonContent, pageFilePath) {
+  if (isObjectEmpty(pageJsonContent.usingComponents)) {
+    return;
+  }
+  for (const [componentName, componentPath] of Object.entries(pageJsonContent.usingComponents)) {
+    const moduleId = getModuleId(componentPath, pageFilePath);
+    pageJsonContent.usingComponents[componentName] = moduleId;
+    if (configInfo.componentInfo[moduleId]) {
+      continue;
+    }
+    let componentFilePath = path4.resolve(getWorkPath(), `./${moduleId}.json`);
+    let cContent = null;
+    if (fs3.existsSync(componentFilePath)) {
+      cContent = parseContentByPath(componentFilePath);
+    } else {
+      const indexJsonPath = path4.resolve(getWorkPath(), `./${moduleId}/index.json`);
+      if (fs3.existsSync(indexJsonPath)) {
+        componentFilePath = indexJsonPath;
+        cContent = parseContentByPath(componentFilePath);
+      } else {
+        if (moduleId.includes("/miniprogram_npm/")) {
+          console.log(`[env] \u4E3A npm \u7EC4\u4EF6\u521B\u5EFA\u9ED8\u8BA4\u914D\u7F6E: ${moduleId}`);
+          cContent = {
+            component: true,
+            usingComponents: {}
+          };
+        } else {
+          console.warn(`[env] \u7EC4\u4EF6\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${componentFilePath}`);
+          continue;
+        }
+      }
+    }
+    const cUsing = cContent.usingComponents || {};
+    const isComponent = cContent.component || false;
+    const cComponents = Object.keys(cUsing).reduce((acc, key) => {
+      acc[key] = getModuleId(cUsing[key], componentFilePath);
+      return acc;
+    }, {});
+    configInfo.componentInfo[moduleId] = {
+      id: uuid(),
+      path: moduleId,
+      component: isComponent,
+      usingComponents: cComponents
+    };
+    if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) {
+      storeComponentConfig(configInfo.componentInfo[moduleId], componentFilePath);
+    }
+  }
+}
+function getModuleId(src, pageFilePath) {
+  const resolvedAlias = resolveAppAlias(src);
+  if (resolvedAlias) {
+    return resolvedAlias;
+  }
+  if (!npmResolver) {
+    const workPath = getWorkPath();
+    return toMiniProgramModuleId(
+      resolveMiniProgramPath(workPath, pageFilePath, src),
+      workPath
+    );
+  }
+  return npmResolver.resolveComponentPath(src, pageFilePath);
+}
+function resolveAppAlias(src) {
+  const resolveAlias = configInfo.appInfo?.resolveAlias;
+  if (!resolveAlias || typeof src !== "string") {
+    return null;
+  }
+  for (const [alias, target] of Object.entries(resolveAlias)) {
+    if (alias.endsWith("/*") && target.endsWith("/*")) {
+      const aliasPrefix = alias.slice(0, -1);
+      const targetPrefix = target.slice(0, -1);
+      if (src.startsWith(aliasPrefix)) {
+        return src.replace(aliasPrefix, targetPrefix);
+      }
+    } else if (src === alias) {
+      return target;
+    }
+  }
+  return null;
+}
+function getTargetPath() {
+  return pathInfo.targetPath;
+}
+function getComponent(src) {
+  return configInfo.componentInfo[src];
+}
+function getPageConfigInfo() {
+  return configInfo.pageInfo;
+}
+function getAppConfigInfo() {
+  return configInfo.appInfo;
+}
+function getWorkPath() {
+  return pathInfo.workPath;
+}
+function getNpmResolver() {
+  return npmResolver;
+}
+function getAppId() {
+  return configInfo.projectInfo.appid;
+}
+function getAppName() {
+  if (configInfo.projectInfo.projectname) {
+    return decodeURIComponent(configInfo.projectInfo.projectname);
+  }
+  return getAppId();
+}
+function transSubDir(name) {
+  return `sub_${name.replace(/\/$/, "")}`;
+}
+function getPages() {
+  const { pages, subPackages = [], usingComponents: globalComponents = {} } = getAppConfigInfo();
+  const pageInfo = getPageConfigInfo();
+  const mainPages = pages.map((path9) => {
+    const pageComponents = pageInfo[path9]?.usingComponents || {};
+    const mergedComponents = { ...globalComponents, ...pageComponents };
+    return {
+      id: uuid(),
+      path: path9,
+      usingComponents: mergedComponents
+    };
+  });
+  const subPages = {};
+  subPackages.forEach((subPkg) => {
+    const rootPath = subPkg.root.endsWith("/") ? subPkg.root : `${subPkg.root}/`;
+    const independent = subPkg.independent ? subPkg.independent : false;
+    subPages[transSubDir(rootPath)] = {
+      independent,
+      info: subPkg.pages.map((path9) => {
+        const fullPath = rootPath + path9;
+        const pageComponents = pageInfo[fullPath]?.usingComponents || {};
+        const mergedComponents = { ...globalComponents, ...pageComponents };
+        return {
+          id: uuid(),
+          path: fullPath,
+          usingComponents: mergedComponents
+        };
+      })
+    };
+  });
+  return {
+    mainPages,
+    subPages
+  };
+}
+
+// ../../dimina/fe/packages/compiler/src/common/publish.js
+import path5 from "node:path";
+import process3 from "node:process";
+import fs4 from "node:fs";
+function createDist() {
+  const distPath = getTargetPath();
+  if (fs4.existsSync(distPath)) {
+    fs4.rmSync(distPath, { recursive: true, force: true });
+  }
+  fs4.mkdirSync(distPath, { recursive: true });
+}
+function publishToDist(dist, useAppIdDir = true) {
+  const distPath = getTargetPath();
+  const appId = getAppId();
+  const absolutePath = useAppIdDir ? `${path5.resolve(process3.cwd(), dist)}${path5.sep}${appId}` : `${path5.resolve(process3.cwd(), dist)}`;
+  if (fs4.existsSync(absolutePath)) {
+    fs4.rmSync(absolutePath, { recursive: true, force: true });
+  }
+  fs4.mkdirSync(absolutePath, { recursive: true });
+  function copyDir(src, dest) {
+    fs4.mkdirSync(dest, { recursive: true });
+    const entries = fs4.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path5.join(src, entry.name);
+      const destPath = path5.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        copyDir(srcPath, destPath);
+      } else {
+        fs4.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+  copyDir(distPath, absolutePath);
+}
+
+// ../../dimina/fe/packages/compiler/src/core/config-compiler.js
+import fs5 from "node:fs";
+function processTabBarIcons(app) {
+  const list = app?.tabBar?.list;
+  if (!Array.isArray(list) || list.length === 0) {
+    return;
+  }
+  const workPath = getWorkPath();
+  const targetPath = getTargetPath();
+  const appId = getAppId();
+  for (const item of list) {
+    if (item.iconPath) {
+      item.iconPath = collectAssets(workPath, "", item.iconPath, targetPath, appId);
+    }
+    if (item.selectedIconPath) {
+      item.selectedIconPath = collectAssets(workPath, "", item.selectedIconPath, targetPath, appId);
+    }
+  }
+}
+function compileConfig() {
+  const app = getAppConfigInfo();
+  processTabBarIcons(app);
+  const compileResInfo = {
+    app,
+    modules: getPageConfigInfo(),
+    projectName: getAppName()
+  };
+  const json = JSON.stringify(compileResInfo, null, 4);
+  const mainDir = `${getTargetPath()}/main`;
+  if (!fs5.existsSync(mainDir)) {
+    fs5.mkdirSync(mainDir, { recursive: true });
+  }
+  fs5.writeFileSync(`${mainDir}/app-config.json`, json);
+}
+var config_compiler_default = compileConfig;
+
+// ../../dimina/fe/packages/compiler/src/common/npm-builder.js
+import fs6 from "node:fs";
+import path6 from "node:path";
+var NpmBuilder = class {
+  constructor(workPath, targetPath) {
+    this.workPath = workPath;
+    this.targetPath = targetPath;
+    this.builtPackages = /* @__PURE__ */ new Set();
+    this.packageDependencies = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 构建 npm 包
+   * 扫描 miniprogram_npm 目录并构建相关包
+   */
+  async buildNpmPackages() {
+    const miniprogramNpmPaths = this.findMiniprogramNpmDirs();
+    for (const npmPath of miniprogramNpmPaths) {
+      await this.buildNpmDir(npmPath);
+    }
+  }
+  /**
+   * 查找所有 miniprogram_npm 目录
+   * @returns {string[]} miniprogram_npm 目录路径数组
+   */
+  findMiniprogramNpmDirs() {
+    const npmDirs = [];
+    const scanDir = (dir, relativePath = "") => {
+      if (!fs6.existsSync(dir)) {
+        return;
+      }
+      const items = fs6.readdirSync(dir, { withFileTypes: true });
+      for (const item of items) {
+        if (item.isDirectory()) {
+          const itemPath = path6.join(dir, item.name);
+          const itemRelativePath = relativePath ? `${relativePath}/${item.name}` : item.name;
+          if (item.name === "miniprogram_npm") {
+            npmDirs.push(itemRelativePath);
+          } else {
+            scanDir(itemPath, itemRelativePath);
+          }
+        }
+      }
+    };
+    scanDir(this.workPath);
+    return npmDirs;
+  }
+  /**
+   * 构建指定的 miniprogram_npm 目录
+   * @param {string} npmDirPath miniprogram_npm 目录路径
+   */
+  async buildNpmDir(npmDirPath) {
+    const fullNpmPath = path6.join(this.workPath, npmDirPath);
+    if (!fs6.existsSync(fullNpmPath)) {
+      return;
+    }
+    const packages = fs6.readdirSync(fullNpmPath, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name);
+    for (const packageName of packages) {
+      await this.buildPackage(packageName, npmDirPath);
+    }
+  }
+  /**
+   * 构建单个 npm 包
+   * @param {string} packageName 包名
+   * @param {string} npmDirPath miniprogram_npm 目录路径
+   */
+  async buildPackage(packageName, npmDirPath) {
+    const packageKey = `${npmDirPath}/${packageName}`;
+    if (this.builtPackages.has(packageKey)) {
+      return;
+    }
+    const packagePath = path6.join(this.workPath, npmDirPath, packageName);
+    const targetPackagePath = path6.join(this.targetPath, npmDirPath, packageName);
+    if (!fs6.existsSync(path6.dirname(targetPackagePath))) {
+      fs6.mkdirSync(path6.dirname(targetPackagePath), { recursive: true });
+    }
+    await this.copyPackageFiles(packagePath, targetPackagePath);
+    await this.processDependencies(packageName, packagePath, npmDirPath);
+    this.builtPackages.add(packageKey);
+  }
+  /**
+   * 复制包文件
+   * @param {string} sourcePath 源路径
+   * @param {string} targetPath 目标路径
+   */
+  async copyPackageFiles(sourcePath, targetPath) {
+    if (!fs6.existsSync(sourcePath)) {
+      return;
+    }
+    if (!fs6.existsSync(targetPath)) {
+      fs6.mkdirSync(targetPath, { recursive: true });
+    }
+    const items = fs6.readdirSync(sourcePath, { withFileTypes: true });
+    for (const item of items) {
+      const sourceItemPath = path6.join(sourcePath, item.name);
+      const targetItemPath = path6.join(targetPath, item.name);
+      if (item.isDirectory()) {
+        await this.copyPackageFiles(sourceItemPath, targetItemPath);
+      } else {
+        if (this.isMiniprogramFile(item.name)) {
+          fs6.copyFileSync(sourceItemPath, targetItemPath);
+        }
+      }
+    }
+  }
+  /**
+   * 检查是否为小程序相关文件
+   * @param {string} filename 文件名
+   * @returns {boolean} 是否为小程序文件
+   */
+  isMiniprogramFile(filename) {
+    const miniprogramExts = [".js", ".json", ".ts", ...getTemplateExts(), ...getStyleExts(), ...getViewScriptExts()];
+    const ext = path6.extname(filename).toLowerCase();
+    return miniprogramExts.includes(ext) || filename === "package.json" || filename === "README.md" || filename.startsWith(".");
+  }
+  /**
+   * 处理包依赖
+   * @param {string} packageName 包名
+   * @param {string} packagePath 包路径
+   * @param {string} npmDirPath npm 目录路径
+   */
+  async processDependencies(packageName, packagePath, npmDirPath) {
+    const packageJsonPath = path6.join(packagePath, "package.json");
+    if (!fs6.existsSync(packageJsonPath)) {
+      return;
+    }
+    try {
+      const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+      const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.peerDependencies
+      };
+      if (dependencies && Object.keys(dependencies).length > 0) {
+        this.packageDependencies.set(packageName, dependencies);
+        for (const depName of Object.keys(dependencies)) {
+          await this.buildPackage(depName, npmDirPath);
+        }
+      }
+    } catch (e) {
+      console.warn(`[npm-builder] \u89E3\u6790 package.json \u5931\u8D25: ${packageJsonPath}`, e.message);
+    }
+  }
+  /**
+   * 验证 npm 包的完整性
+   * @param {string} packageName 包名
+   * @param {string} packagePath 包路径
+   * @returns {boolean} 是否有效
+   */
+  validatePackage(packageName, packagePath) {
+    const requiredFiles = ["package.json"];
+    for (const file of requiredFiles) {
+      if (!fs6.existsSync(path6.join(packagePath, file))) {
+        console.warn(`[npm-builder] \u5305 ${packageName} \u7F3A\u5C11\u5FC5\u8981\u6587\u4EF6: ${file}`);
+        return false;
+      }
+    }
+    try {
+      const packageJsonPath = path6.join(packagePath, "package.json");
+      const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+      if (!packageJson.name || !packageJson.version) {
+        console.warn(`[npm-builder] \u5305 ${packageName} \u7684 package.json \u683C\u5F0F\u4E0D\u6B63\u786E`);
+        return false;
+      }
+    } catch (e) {
+      console.warn(`[npm-builder] \u5305 ${packageName} \u7684 package.json \u89E3\u6790\u5931\u8D25:`, e.message);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 获取已构建的包列表
+   * @returns {string[]} 已构建的包列表
+   */
+  getBuiltPackages() {
+    return Array.from(this.builtPackages);
+  }
+  /**
+   * 获取包依赖关系
+   * @returns {Map} 包依赖关系映射
+   */
+  getPackageDependencies() {
+    return this.packageDependencies;
+  }
+  /**
+   * 清理构建缓存
+   */
+  clearCache() {
+    this.builtPackages.clear();
+    this.packageDependencies.clear();
+  }
+};
+
+// ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
+import fs7 from "node:fs";
+import { resolve, sep } from "node:path";
+
+// src/shims/worker_threads.js
+var isMainThread = true;
+var parentPort = null;
+
+// ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
+import { parseSync } from "oxc-parser";
+import { walk } from "oxc-walker";
+import MagicString from "magic-string";
+import { transform } from "esbuild";
+
+// ../../dimina/fe/packages/compiler/src/common/compatibility.js
+import { Parser } from "htmlparser2";
+
+// ../../dimina/fe/packages/compiler/src/common/compatibility-reference.js
+var supportedBuiltinComponents = [
+  "block",
+  "button",
+  "canvas",
+  "checkbox",
+  "checkbox-group",
+  "cover-image",
+  "cover-view",
+  "form",
+  "icon",
+  "image",
+  "input",
+  "label",
+  "movable-area",
+  "movable-view",
+  "navigation-bar",
+  "navigator",
+  "picker",
+  "picker-view",
+  "picker-view-column",
+  "progress",
+  "radio",
+  "radio-group",
+  "rich-text",
+  "scroll-view",
+  "slider",
+  "slot",
+  "swiper",
+  "swiper-item",
+  "switch",
+  "template",
+  "text",
+  "textarea",
+  "video",
+  "view",
+  "web-view",
+  "wxs",
+  "include",
+  "import"
+];
+var supportedWxApis = [
+  "env",
+  "canIUse",
+  "getUpdateManager",
+  "openSystemBluetoothSetting",
+  "getWindowInfo",
+  "getSystemSetting",
+  "getSystemInfoSync",
+  "getSystemInfoAsync",
+  "getSystemInfo",
+  "reLaunch",
+  "redirectTo",
+  "navigateTo",
+  "navigateBack",
+  "showToast",
+  "showModal",
+  "showLoading",
+  "showActionSheet",
+  "hideToast",
+  "hideLoading",
+  "setNavigationBarTitle",
+  "setNavigationBarColor",
+  "pageScrollTo",
+  "getMenuButtonBoundingClientRect",
+  "createAnimation",
+  "createCanvasContext",
+  "createOffscreenCanvas",
+  "canvasToTempFilePath",
+  "createSelectorQuery",
+  "createIntersectionObserver",
+  "request",
+  "downloadFile",
+  "uploadFile",
+  "setStorageSync",
+  "getStorageSync",
+  "removeStorageSync",
+  "clearStorageSync",
+  "setStorage",
+  "getStorage",
+  "removeStorage",
+  "clearStorage",
+  "getStorageInfoSync",
+  "getStorageInfo",
+  "saveImageToPhotosAlbum",
+  "previewImage",
+  "compressImage",
+  "chooseImage",
+  "chooseMedia",
+  "chooseContact",
+  "addPhoneContact",
+  "setClipboardData",
+  "getClipboardData",
+  "vibrateShort",
+  "vibrateLong",
+  "hideKeyboard",
+  "getNetworkType",
+  "makePhoneCall",
+  "extBridge",
+  "extOnBridge",
+  "extOffBridge"
+];
+
+// ../../dimina/fe/packages/compiler/src/common/compatibility.js
+var cachedReference = null;
+var warnedItems = /* @__PURE__ */ new Set();
+function loadReference() {
+  if (cachedReference) {
+    return cachedReference;
+  }
+  cachedReference = {
+    supportedBuiltinComponents: new Set(supportedBuiltinComponents),
+    supportedWxApis: new Set(supportedWxApis)
+  };
+  return cachedReference;
+}
+function getWxMemberName(node) {
+  if (node?.type !== "MemberExpression") {
+    return null;
+  }
+  if (node.object?.type !== "Identifier" || node.object.name !== "wx") {
+    return null;
+  }
+  if (!node.computed && node.property?.type === "Identifier") {
+    return node.property.name;
+  }
+  if (node.computed && (node.property?.type === "StringLiteral" || node.property?.type === "Literal") && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return null;
+}
+function warnUnsupportedWxApi(apiName, filePath, line) {
+  const { supportedWxApis: supportedWxApis2 } = loadReference();
+  if (!apiName || supportedWxApis2.has(apiName)) {
+    return;
+  }
+  const location = formatLocation(filePath, line);
+  warnOnce("api", apiName, location, `[compat] Unsupported wx API: wx.${apiName}${location}`);
+}
+function warnUnsupportedComponent(tagName, filePath, line) {
+  const { supportedBuiltinComponents: supportedBuiltinComponents2 } = loadReference();
+  if (!tagName || supportedBuiltinComponents2.has(tagName) || getViewScriptTags().includes(tagName)) {
+    return;
+  }
+  const location = formatLocation(filePath, line);
+  warnOnce("component", tagName, location, `[compat] Unsupported or undeclared component: <${tagName}>${location}`);
+}
+function checkTemplateCompatibility(content, filePath, components = {}) {
+  let parser;
+  parser = new Parser(
+    {
+      onopentag(tagName) {
+        if (components?.[tagName]) {
+          return;
+        }
+        const line = getLineByIndex(content, parser.startIndex);
+        warnUnsupportedComponent(tagName, filePath, line);
+      },
+      onerror(error) {
+        console.warn("[compat]", `Failed to parse template for compatibility diagnostics: ${filePath}`, error.message);
+      }
+    },
+    {
+      xmlMode: true,
+      lowerCaseTags: false,
+      lowerCaseAttributeNames: false,
+      withStartIndices: true
+    }
+  );
+  parser.write(content);
+  parser.end();
+}
+function getLineByIndex(content, index) {
+  if (typeof index !== "number" || index < 0) {
+    return null;
+  }
+  let line = 1;
+  for (let i = 0; i < index; i++) {
+    if (content.charCodeAt(i) === 10) {
+      line++;
+    }
+  }
+  return line;
+}
+function formatLocation(filePath, line) {
+  if (!filePath) {
+    return "";
+  }
+  return line ? ` (${filePath}:${line})` : ` (${filePath})`;
+}
+function warnOnce(type, name, location, message) {
+  const key = `${type}:${name}:${location}`;
+  if (warnedItems.has(key)) {
+    return;
+  }
+  warnedItems.add(key);
+  console.warn(message);
+}
+
+// ../../dimina/fe/packages/compiler/src/core/sourcemap.js
+import { SourceMapConsumer, SourceMapGenerator } from "source-map-js";
+function wrapModDefine(module) {
+  const code = module.code.endsWith("\n") ? module.code : module.code + "\n";
+  const extraLine = module.extraInfoCode || "";
+  const header = `modDefine('${module.path}', function(require, module, exports) {
+${extraLine}`;
+  const footer = "});\n";
+  return { header, code, footer };
+}
+function mergeSourcemap(compileRes2) {
+  const smg = new SourceMapGenerator({ file: "logic.js" });
+  let bundleCode = "";
+  let lineOffset = 0;
+  for (const module of compileRes2) {
+    const { header, code, footer } = wrapModDefine(module);
+    bundleCode += header;
+    const headerLineCount = header.split("\n").length - 1;
+    lineOffset += headerLineCount;
+    if (module.map) {
+      const moduleMap = JSON.parse(module.map);
+      const smc = new SourceMapConsumer(moduleMap);
+      smc.eachMapping((mapping) => {
+        if (mapping.source == null) return;
+        smg.addMapping({
+          generated: {
+            line: mapping.generatedLine + lineOffset,
+            column: mapping.generatedColumn
+          },
+          original: {
+            line: mapping.originalLine,
+            column: mapping.originalColumn
+          },
+          source: mapping.source,
+          name: mapping.name
+        });
+      });
+      if (moduleMap.sourcesContent) {
+        moduleMap.sources.forEach((src, i) => {
+          smg.setSourceContent(src, moduleMap.sourcesContent[i]);
+        });
+      }
+    }
+    bundleCode += code;
+    lineOffset += code.split("\n").length - 1;
+    bundleCode += footer;
+    lineOffset += footer.split("\n").length - 1;
+  }
+  return { bundleCode, sourcemap: smg.toString() };
+}
+function remapSourcemap(nextMap, prevMap) {
+  if (!nextMap) {
+    return prevMap;
+  }
+  if (!prevMap) {
+    return nextMap;
+  }
+  const nextMapObj = typeof nextMap === "string" ? JSON.parse(nextMap) : nextMap;
+  const prevMapObj = typeof prevMap === "string" ? JSON.parse(prevMap) : prevMap;
+  const smg = new SourceMapGenerator({ file: nextMapObj.file || prevMapObj.file || "" });
+  const prevSmc = new SourceMapConsumer(prevMapObj);
+  const nextSmc = new SourceMapConsumer(nextMapObj);
+  nextSmc.eachMapping((mapping) => {
+    if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {
+      return;
+    }
+    const original = prevSmc.originalPositionFor({
+      line: mapping.originalLine,
+      column: mapping.originalColumn
+    });
+    if (original.source == null || original.line == null || original.column == null) {
+      return;
+    }
+    smg.addMapping({
+      generated: {
+        line: mapping.generatedLine,
+        column: mapping.generatedColumn
+      },
+      original: {
+        line: original.line,
+        column: original.column
+      },
+      source: original.source,
+      name: original.name || mapping.name
+    });
+  });
+  if (prevMapObj.sourcesContent) {
+    prevMapObj.sources.forEach((src, i) => {
+      smg.setSourceContent(src, prevMapObj.sourcesContent[i]);
+    });
+  }
+  return smg.toString();
+}
+
+// ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
+var processedModules = /* @__PURE__ */ new Set();
+var enableSourcemap = false;
+if (!isMainThread) {
+  parentPort.on("message", async ({ pages, storeInfo: storeInfo2, sourcemap }) => {
+    try {
+      resetStoreInfo(storeInfo2);
+      enableSourcemap = !!sourcemap;
+      const progress = {
+        _completedTasks: 0,
+        get completedTasks() {
+          return this._completedTasks;
+        },
+        set completedTasks(value) {
+          this._completedTasks = value;
+          parentPort.postMessage({ completedTasks: this.completedTasks });
+        }
+      };
+      const mainCompileRes = await compileJS(pages.mainPages, null, null, progress);
+      for (const [root, subPages] of Object.entries(pages.subPages)) {
+        try {
+          const subCompileRes = await compileJS(
+            subPages.info,
+            root,
+            subPages.independent ? [] : mainCompileRes,
+            progress
+          );
+          await writeCompileRes(subCompileRes, root);
+        } catch (error) {
+          throw new Error(`Error processing subpackage ${root}: ${error.message}
+${error.stack}`);
+        }
+      }
+      await writeCompileRes(mainCompileRes, null);
+      processedModules.clear();
+      parentPort.postMessage({ success: true });
+    } catch (error) {
+      processedModules.clear();
+      parentPort.postMessage({
+        success: false,
+        error: {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        }
+      });
+    }
+  });
+}
+async function writeCompileRes(compileRes2, root) {
+  const outputDir = root ? `${getTargetPath()}/${root}` : `${getTargetPath()}/main`;
+  if (!fs7.existsSync(outputDir)) {
+    fs7.mkdirSync(outputDir, { recursive: true });
+  }
+  if (enableSourcemap) {
+    const { bundleCode, sourcemap } = mergeSourcemap(compileRes2);
+    const sourcemapFileName = "logic.js.map";
+    fs7.writeFileSync(`${outputDir}/logic.js`, `${bundleCode}//# sourceMappingURL=${sourcemapFileName}
+`);
+    fs7.writeFileSync(`${outputDir}/${sourcemapFileName}`, sourcemap);
+  } else {
+    let mergeCode = "";
+    for (const module of compileRes2) {
+      const amdFormat = `modDefine('${module.path}', function(require, module, exports) {
+${module.code}
+});`;
+      const { code: minifiedCode } = await transform(amdFormat, {
+        minify: true,
+        target: ["es2023"],
+        // quickjs 支持版本
+        platform: "neutral"
+      });
+      mergeCode += minifiedCode;
+    }
+    fs7.writeFileSync(`${outputDir}/logic.js`, mergeCode);
+  }
+}
+async function compileJS(pages, root, mainCompileRes, progress) {
+  const compileRes2 = [];
+  if (!root) {
+    await buildJSByPath(root, { path: "app" }, compileRes2, mainCompileRes, false);
+  }
+  for (const page of pages) {
+    await buildJSByPath(root, page, compileRes2, mainCompileRes, true);
+    progress.completedTasks++;
+  }
+  return compileRes2;
+}
+async function buildJSByPath(packageName, module, compileRes2, mainCompileRes, addExtra, depthChain = [], putMain = false) {
+  const currentPath = module.path;
+  if (depthChain.includes(currentPath)) {
+    console.warn("[logic]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return;
+  }
+  if (depthChain.length > 20) {
+    console.warn("[logic]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return;
+  }
+  depthChain = [...depthChain, currentPath];
+  if (!module.path) {
+    return;
+  }
+  if (hasCompileInfo(module.path, compileRes2, mainCompileRes)) {
+    return;
+  }
+  const compileInfo = {
+    path: module.path,
+    code: "",
+    sourceFile: null
+  };
+  const src = module.path.startsWith("/") ? module.path : `/${module.path}`;
+  const modulePath = getJSAbsolutePath(src);
+  if (!modulePath) {
+    console.warn("[logic]", `\u627E\u4E0D\u5230\u6A21\u5757\u6587\u4EF6: ${src}`);
+    return;
+  }
+  const diagnosticSource = modulePath.startsWith(getWorkPath()) ? modulePath.slice(getWorkPath().length) : src;
+  const sourceCode = getContentByPath(modulePath);
+  if (!sourceCode) {
+    console.warn("[logic]", `\u65E0\u6CD5\u8BFB\u53D6\u6A21\u5757\u6587\u4EF6: ${modulePath}`);
+    return;
+  }
+  const isTypeScript = modulePath.endsWith(".ts");
+  if (enableSourcemap) {
+    const workPath = getWorkPath();
+    compileInfo.sourceFile = modulePath.startsWith(workPath) ? modulePath.slice(workPath.length) : src;
+  }
+  const parseResult = parseSync(modulePath, sourceCode, {
+    sourceType: "module",
+    lang: isTypeScript ? "ts" : "js"
+  });
+  const ast = parseResult.program;
+  const s = new MagicString(sourceCode);
+  const extraInfo = {
+    path: module.path
+  };
+  if (module.component) {
+    extraInfo.component = true;
+  }
+  if (module.usingComponents) {
+    const componentsObj = {};
+    const allSubPackages = getAppConfigInfo().subPackages;
+    for (const [name, path9] of Object.entries(module.usingComponents)) {
+      let toMainSubPackage = true;
+      if (packageName) {
+        const normalizedPath = path9.startsWith("/") ? path9.substring(1) : path9;
+        for (const subPackage of allSubPackages) {
+          if (normalizedPath.startsWith(`${subPackage.root}/`)) {
+            toMainSubPackage = false;
+            break;
+          }
+        }
+      } else {
+        toMainSubPackage = false;
+      }
+      const componentModule = getComponent(path9);
+      if (!componentModule) {
+        continue;
+      }
+      await buildJSByPath(packageName, componentModule, compileRes2, mainCompileRes, true, depthChain, putMain || toMainSubPackage);
+      componentsObj[name] = path9;
+    }
+    extraInfo.usingComponents = componentsObj;
+  }
+  if (addExtra) {
+    const extraInfoCode = `globalThis.__extraInfo = ${JSON.stringify(extraInfo)};
+`;
+    if (enableSourcemap) {
+      compileInfo.extraInfoCode = extraInfoCode;
+    } else {
+      s.prepend(extraInfoCode);
+    }
+  }
+  if (putMain) {
+    mainCompileRes.push(compileInfo);
+  } else {
+    compileRes2.push(compileInfo);
+  }
+  const pathReplacements = [];
+  const dependenciesToProcess = [];
+  walk(ast, {
+    enter(node, parent) {
+      const wxMemberName = getWxMemberName(node);
+      if (wxMemberName) {
+        warnUnsupportedWxApi(
+          wxMemberName,
+          compileInfo.sourceFile || diagnosticSource,
+          node.loc?.start?.line || getLineByIndex2(sourceCode, node.start)
+        );
+      }
+      if ((node.type === "StringLiteral" || node.type === "Literal") && isLocalAssetString(node.value)) {
+        pathReplacements.push({
+          start: node.start,
+          end: node.end,
+          newValue: collectAssets(getWorkPath(), modulePath, node.value, getTargetPath(), getAppId())
+        });
+      }
+      if (node.type === "CallExpression") {
+        const isRequire = node.callee.type === "Identifier" && node.callee.name === "require";
+        const isRequireProperty = node.callee.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object?.name === "require";
+        if ((isRequire || isRequireProperty) && node.arguments.length > 0 && (node.arguments[0].type === "StringLiteral" || node.arguments[0].type === "Literal")) {
+          const arg = node.arguments[0];
+          const requirePath = arg.value;
+          if (requirePath) {
+            const { id, shouldProcess } = resolveDependencyId(requirePath, modulePath, false);
+            if (shouldProcess) {
+              pathReplacements.push({
+                start: arg.start,
+                end: arg.end,
+                newValue: id
+              });
+              if (!processedModules.has(packageName + id)) {
+                dependenciesToProcess.push(id);
+              }
+            }
+          }
+        }
+      }
+      if (node.type === "ImportDeclaration") {
+        const importPath = node.source.value;
+        if (importPath) {
+          const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, true);
+          if (shouldProcess) {
+            pathReplacements.push({
+              start: node.source.start,
+              end: node.source.end,
+              newValue: id
+            });
+            if (!processedModules.has(packageName + id)) {
+              dependenciesToProcess.push(id);
+            }
+          }
+        }
+      }
+      if (node.type === "TSImportEqualsDeclaration" && node.moduleReference?.type === "TSExternalModuleReference") {
+        const importPathNode = node.moduleReference.expression;
+        const importPath = importPathNode?.value;
+        if (importPath) {
+          const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, false);
+          if (shouldProcess) {
+            pathReplacements.push({
+              start: importPathNode.start,
+              end: importPathNode.end,
+              newValue: id
+            });
+            if (!processedModules.has(packageName + id)) {
+              dependenciesToProcess.push(id);
+            }
+          }
+        }
+      }
+      if ((node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") && node.source) {
+        const exportPath = node.source.value;
+        if (exportPath) {
+          const { id, shouldProcess } = resolveDependencyId(exportPath, modulePath, true);
+          if (shouldProcess) {
+            pathReplacements.push({
+              start: node.source.start,
+              end: node.source.end,
+              newValue: id
+            });
+            if (!processedModules.has(packageName + id)) {
+              dependenciesToProcess.push(id);
+            }
+          }
+        }
+      }
+    }
+  });
+  for (const depId of dependenciesToProcess) {
+    await buildJSByPath(packageName, { path: depId }, compileRes2, mainCompileRes, false, depthChain, putMain);
+  }
+  for (const replacement of pathReplacements.reverse()) {
+    s.overwrite(replacement.start, replacement.end, `'${replacement.newValue}'`);
+  }
+  const modifiedCode = s.toString();
+  let preEsbuildMap = null;
+  if (enableSourcemap && compileInfo.sourceFile) {
+    const generatedMap = JSON.parse(s.generateMap({
+      file: compileInfo.sourceFile,
+      source: compileInfo.sourceFile,
+      includeContent: true,
+      hires: true
+    }).toString());
+    generatedMap.file = compileInfo.sourceFile;
+    generatedMap.sources = [compileInfo.sourceFile];
+    generatedMap.sourcesContent = [sourceCode];
+    preEsbuildMap = JSON.stringify(generatedMap);
+  }
+  try {
+    const esbuildOpts = {
+      format: "cjs",
+      target: "es2020",
+      platform: "neutral",
+      loader: isTypeScript ? "ts" : "js"
+    };
+    if (enableSourcemap && compileInfo.sourceFile) {
+      esbuildOpts.sourcemap = true;
+      esbuildOpts.sourcefile = compileInfo.sourceFile;
+      esbuildOpts.sourcesContent = true;
+    }
+    const esbuildResult = await transform(modifiedCode, esbuildOpts);
+    if (enableSourcemap && esbuildResult.map) {
+      compileInfo.map = preEsbuildMap ? remapSourcemap(esbuildResult.map, preEsbuildMap) : esbuildResult.map;
+    }
+    compileInfo.code = esbuildResult.code;
+  } catch (error) {
+    console.error(`[logic] esbuild \u8F6C\u6362\u5931\u8D25 ${modulePath}:`, error.message);
+    compileInfo.code = modifiedCode;
+  }
+  processedModules.add(packageName + currentPath);
+}
+function isLocalAssetString(value) {
+  return typeof value === "string" && !value.startsWith("http") && !value.startsWith("//") && (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) && /\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(value);
+}
+function getLineByIndex2(content, index) {
+  if (typeof index !== "number" || index < 0) {
+    return null;
+  }
+  let line = 1;
+  for (let i = 0; i < index; i++) {
+    if (content.charCodeAt(i) === 10) {
+      line++;
+    }
+  }
+  return line;
+}
+function getJSAbsolutePath(modulePath) {
+  const workPath = getWorkPath();
+  const resolvedModuleId = resolveModuleIdToExistingPath(modulePath);
+  if (!resolvedModuleId) {
+    return null;
+  }
+  const fileTypes = [".js", ".ts"];
+  for (const ext of fileTypes) {
+    const fullPath = `${workPath}${resolvedModuleId}${ext}`;
+    if (fs7.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function resolveDependencyId(specifier, modulePath, allowAbsolute) {
+  if (!specifier) {
+    return { id: specifier, shouldProcess: false };
+  }
+  if (specifier.startsWith("miniprogram_npm/")) {
+    const npmModuleId = normalizeModuleId(`/${specifier}`);
+    return {
+      id: resolveModuleIdToExistingPath(npmModuleId) || npmModuleId,
+      shouldProcess: true
+    };
+  }
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    return {
+      id: resolveRelativeModuleId(specifier, modulePath),
+      shouldProcess: true
+    };
+  }
+  if (specifier.startsWith("/")) {
+    return {
+      id: allowAbsolute ? normalizeModuleId(specifier) : resolveRelativeModuleId(specifier, modulePath),
+      shouldProcess: true
+    };
+  }
+  const aliasResolved = resolveAppAlias(specifier);
+  if (aliasResolved) {
+    return {
+      id: normalizeModuleId(aliasResolved),
+      shouldProcess: true
+    };
+  }
+  if (specifier.startsWith("@") || isBareModuleSpecifier(specifier)) {
+    const npmModuleId = resolveNpmModuleId(specifier, modulePath);
+    if (npmModuleId) {
+      return {
+        id: npmModuleId,
+        shouldProcess: true
+      };
+    }
+    const siblingModuleId = resolveBareSiblingModuleId(specifier, modulePath);
+    return {
+      id: siblingModuleId || specifier,
+      shouldProcess: Boolean(siblingModuleId)
+    };
+  }
+  return { id: specifier, shouldProcess: false };
+}
+function isBareModuleSpecifier(specifier) {
+  return !specifier.startsWith(".") && !specifier.startsWith("/");
+}
+function resolveRelativeModuleId(specifier, modulePath) {
+  const requireFullPath = resolve(modulePath, `../${specifier}`);
+  const relativeId = requireFullPath.split(`${getWorkPath()}${sep}`)[1];
+  return normalizeModuleId(relativeId);
+}
+function resolveBareSiblingModuleId(specifier, modulePath) {
+  const siblingModuleId = resolveRelativeModuleId(`./${specifier}`, modulePath);
+  return resolveModuleIdToExistingPath(siblingModuleId);
+}
+function normalizeModuleId(moduleId) {
+  let normalized = moduleId.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
+  }
+  return normalized;
+}
+function resolveNpmModuleId(specifier, modulePath) {
+  const npmResolver2 = getNpmResolver();
+  if (!npmResolver2) {
+    return null;
+  }
+  return npmResolver2.resolveScriptModule(specifier, modulePath, resolveModuleIdToExistingPath);
+}
+function resolveModuleIdToExistingPath(moduleId) {
+  const normalizedModuleId = normalizeModuleId(moduleId);
+  const workPath = getWorkPath();
+  for (const ext of [".js", ".ts"]) {
+    if (fs7.existsSync(`${workPath}${normalizedModuleId}${ext}`)) {
+      return normalizedModuleId;
+    }
+  }
+  for (const ext of [".js", ".ts"]) {
+    if (fs7.existsSync(`${workPath}${normalizedModuleId}/index${ext}`)) {
+      return `${normalizedModuleId}/index`;
+    }
+  }
+  const packageJsonPath = `${workPath}${normalizedModuleId}/package.json`;
+  if (fs7.existsSync(packageJsonPath)) {
+    try {
+      const packageInfo = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
+      for (const entryField of ["miniprogram", "main"]) {
+        if (typeof packageInfo[entryField] === "string" && packageInfo[entryField]) {
+          const entryModuleId = normalizeModuleId(resolve(normalizedModuleId, packageInfo[entryField]));
+          const resolvedEntry = resolveModuleIdToExistingPath(entryModuleId);
+          if (resolvedEntry) {
+            return resolvedEntry;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("[logic]", `\u89E3\u6790 package.json \u5931\u8D25: ${packageJsonPath}`, error.message);
+    }
+  }
+  return null;
+}
+function __resetLogicState() {
+  processedModules.clear();
+}
+
+// ../../dimina/fe/packages/compiler/src/core/view-compiler.js
+import fs8 from "node:fs";
+import path7 from "node:path";
+import { parseSync as parseSync3 } from "oxc-parser";
+import { walk as walk2 } from "oxc-walker";
+import MagicString2 from "magic-string";
+import { compileTemplate } from "@vue/compiler-sfc";
+import * as cheerio from "cheerio";
+import { transform as transform2 } from "esbuild";
+import * as htmlparser2 from "htmlparser2";
+
+// ../../dimina/fe/packages/compiler/src/common/expression-parser.js
+import { parseSync as parseSync2 } from "oxc-parser";
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity",
+  "this",
+  "arguments",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Math",
+  "Date",
+  "RegExp",
+  "Error",
+  "JSON",
+  "console",
+  "window",
+  "document",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURI",
+  "encodeURIComponent",
+  "decodeURI",
+  "decodeURIComponent"
+]);
+function extractDependencies(expression) {
+  if (!expression || typeof expression !== "string") {
+    return [];
+  }
+  const dependencies = /* @__PURE__ */ new Set();
+  try {
+    const code = `(${expression})`;
+    const ast = parseSync2("expression.js", code, {
+      sourceType: "module",
+      lang: "js"
+    }).program;
+    visitExpressionAst(ast, null, dependencies);
+  } catch (error) {
+    console.warn("[expression-parser] AST \u89E3\u6790\u5931\u8D25\uFF0C\u8868\u8FBE\u5F0F:", expression, "\u9519\u8BEF:", error.message);
+    return [];
+  }
+  return Array.from(dependencies);
+}
+function visitExpressionAst(node, parent, dependencies) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  if (node.type === "Identifier") {
+    collectIdentifier(node, parent, dependencies);
+    return;
+  }
+  if (node.type === "MemberExpression") {
+    let root = node.object;
+    while (root?.type === "MemberExpression" || root?.type === "ChainExpression") {
+      root = root.type === "ChainExpression" ? root.expression : root.object;
+    }
+    if (root?.type === "Identifier" && !KEYWORDS.has(root.name)) {
+      dependencies.add(root.name);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        visitExpressionAst(child, node, dependencies);
+      }
+    } else {
+      visitExpressionAst(value, node, dependencies);
+    }
+  }
+}
+function collectIdentifier(node, parent, dependencies) {
+  const name = node.name;
+  if (KEYWORDS.has(name)) {
+    return;
+  }
+  if (parent?.type === "MemberExpression" && parent.property === node && !parent.computed) {
+    return;
+  }
+  if (parent?.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand) {
+    return;
+  }
+  dependencies.add(name);
+}
+function parseExpression(expression) {
+  if (!expression || typeof expression !== "string") {
+    return {
+      expression: "",
+      dependencies: [],
+      isSimple: true
+    };
+  }
+  const dependencies = extractDependencies(expression);
+  const isSimple = dependencies.length === 1 && expression.trim() === dependencies[0];
+  return {
+    expression: expression.trim(),
+    dependencies,
+    isSimple
+  };
+}
+function parseBindings(bindings) {
+  if (!bindings || typeof bindings !== "object") {
+    return {};
+  }
+  const parsed = {};
+  for (const [propName, expression] of Object.entries(bindings)) {
+    parsed[propName] = parseExpression(expression);
+  }
+  return parsed;
+}
+
+// ../../dimina/fe/packages/compiler/src/core/view-compiler.js
+function buildExtStripRegex(exts) {
+  const alt = exts.map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return new RegExp(`(${alt})$`);
+}
+function stripViewScriptExt(p) {
+  return p.replace(buildExtStripRegex(getViewScriptExts()), "");
+}
+function parseJs(code, filename = "view-compiler.js", sourceType = "module") {
+  return parseSync3(filename, code, {
+    sourceType,
+    lang: "js"
+  }).program;
+}
+function getProgramCode(code, ast) {
+  const statement = ast.body?.[0];
+  if (ast.body?.length === 1 && statement?.type === "ExpressionStatement") {
+    return code.slice(statement.expression.start, statement.expression.end);
+  }
+  return code;
+}
+function isStringLiteral(node) {
+  return node?.type === "StringLiteral" || node?.type === "Literal" && typeof node.value === "string";
+}
+function getStringLiteralRawValue(node) {
+  if (!isStringLiteral(node)) {
+    return "";
+  }
+  if (typeof node.raw === "string") {
+    return node.raw.slice(1, -1);
+  }
+  return String(node.value);
+}
+function getSource(code, node) {
+  return code.slice(node.start, node.end);
+}
+function applyCodeReplacements(source, replacements) {
+  if (replacements.length === 0) {
+    return source;
+  }
+  const selected = [];
+  const byLargestRange = [...replacements].sort((a, b) => {
+    const lengthDiff = b.end - b.start - (a.end - a.start);
+    return lengthDiff || b.start - a.start;
+  });
+  for (const replacement of byLargestRange) {
+    const overlaps = selected.some(
+      (item) => replacement.start < item.end && item.start < replacement.end
+    );
+    if (!overlaps) {
+      selected.push(replacement);
+    }
+  }
+  const s = new MagicString2(source);
+  for (const replacement of selected.sort((a, b) => b.start - a.start)) {
+    if (replacement.type === "insert") {
+      s.appendLeft(replacement.start, replacement.value);
+    } else {
+      s.overwrite(replacement.start, replacement.end, replacement.value);
+    }
+  }
+  return s.toString();
+}
+function addOptionalChaining(expression) {
+  if (!expression || typeof expression !== "string") {
+    return expression;
+  }
+  try {
+    const code = `(${expression})`;
+    const ast = parseJs(code);
+    const insertions = [];
+    walk2(ast, {
+      enter(node) {
+        if (node.type !== "MemberExpression" || node.optional) {
+          return;
+        }
+        if (node.computed) {
+          const bracketIndex = code.lastIndexOf("[", node.property.start);
+          if (bracketIndex >= 0) {
+            insertions.push({
+              type: "insert",
+              start: bracketIndex,
+              end: bracketIndex,
+              value: "?."
+            });
+          }
+        } else {
+          const dotIndex = code.lastIndexOf(".", node.property.start);
+          if (dotIndex >= 0) {
+            insertions.push({
+              type: "insert",
+              start: dotIndex,
+              end: dotIndex,
+              value: "?"
+            });
+          }
+        }
+      }
+    });
+    return applyCodeReplacements(code, insertions).slice(1, -1);
+  } catch (error) {
+    return expression;
+  }
+}
+function parseSafeBraceExp(exp) {
+  return addOptionalChaining(parseBraceExp(exp));
+}
+function transformTextInterpolation(text) {
+  if (!text || typeof text !== "string" || !isWrappedByBraces(text)) {
+    return text;
+  }
+  return text.replace(braceRegex, (match, bracePart) => {
+    if (!bracePart) {
+      return match;
+    }
+    const matchResult = bracePart.match(noBraceRegex);
+    if (!matchResult) {
+      return match;
+    }
+    return `{{${addOptionalChaining(matchResult[1].trim())}}}`;
+  });
+}
+var compileResCache = /* @__PURE__ */ new Map();
+var wxsModuleRegistry = /* @__PURE__ */ new Set();
+var wxsFilePathMap = /* @__PURE__ */ new Map();
+if (!isMainThread) {
+  parentPort.on("message", async ({ pages, storeInfo: storeInfo2 }) => {
+    try {
+      resetStoreInfo(storeInfo2);
+      const progress = {
+        _completedTasks: 0,
+        get completedTasks() {
+          return this._completedTasks;
+        },
+        set completedTasks(value) {
+          this._completedTasks = value;
+          parentPort.postMessage({ completedTasks: this._completedTasks });
+        }
+      };
+      await compileML(pages.mainPages, null, progress);
+      for (const [root, subPages] of Object.entries(pages.subPages)) {
+        await compileML(subPages.info, root, progress);
+      }
+      compileResCache.clear();
+      wxsModuleRegistry.clear();
+      wxsFilePathMap.clear();
+      parentPort.postMessage({ success: true });
+    } catch (error) {
+      compileResCache.clear();
+      wxsModuleRegistry.clear();
+      wxsFilePathMap.clear();
+      parentPort.postMessage({
+        success: false,
+        error: {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        }
+      });
+    }
+  });
+}
+async function compileML(pages, root, progress) {
+  const workPath = getWorkPath();
+  initWxsFilePathMap(workPath);
+  for (const page of pages) {
+    const scriptRes = /* @__PURE__ */ new Map();
+    buildCompileView(page, false, scriptRes, [], /* @__PURE__ */ new Set());
+    let mergeRender = "";
+    for (const [key, value] of scriptRes.entries()) {
+      const amdFormat = `modDefine('${key}', function(require, module, exports) {
+		${value}
+		});`;
+      const { code: minifiedCode } = await transform2(amdFormat, {
+        minify: true,
+        target: ["es2020"],
+        platform: "browser"
+      });
+      mergeRender += minifiedCode;
+    }
+    scriptRes.clear();
+    const filename = `${page.path.replace(/\//g, "_")}`;
+    if (root) {
+      const subDir = `${getTargetPath()}/${root}`;
+      if (!fs8.existsSync(subDir)) {
+        fs8.mkdirSync(subDir, { recursive: true });
+      }
+      fs8.writeFileSync(`${subDir}/${filename}.js`, mergeRender);
+    } else {
+      const mainDir = `${getTargetPath()}/main`;
+      if (!fs8.existsSync(mainDir)) {
+        fs8.mkdirSync(mainDir, { recursive: true });
+      }
+      fs8.writeFileSync(`${mainDir}/${filename}.js`, mergeRender);
+    }
+    progress.completedTasks++;
+  }
+}
+function initWxsFilePathMap(workPath) {
+  wxsFilePathMap.clear();
+  const npmDir = path7.join(workPath, "miniprogram_npm");
+  if (fs8.existsSync(npmDir)) {
+    scanWxsFiles(npmDir, workPath);
+  }
+}
+function scanWxsFiles(dir, workPath) {
+  try {
+    const items = fs8.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path7.join(dir, item);
+      const stat = fs8.statSync(fullPath);
+      if (stat.isDirectory()) {
+        scanWxsFiles(fullPath, workPath);
+      } else if (stat.isFile() && getViewScriptExts().some((ext) => item.endsWith(ext))) {
+        const relativePath = stripViewScriptExt(fullPath.replace(workPath, ""));
+        const moduleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+        wxsFilePathMap.set(moduleName, fullPath);
+      }
+    }
+  } catch (error) {
+  }
+}
+function registerWxsModule(modulePath) {
+  wxsModuleRegistry.add(modulePath);
+}
+function isRegisteredWxsModule(modulePath) {
+  return wxsModuleRegistry.has(modulePath);
+}
+function buildCompileView(module, isComponent = false, scriptRes, depthChain = [], inheritedTemplatePaths = /* @__PURE__ */ new Set()) {
+  const currentPath = module.path;
+  if (depthChain.includes(currentPath)) {
+    console.warn("[view]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return;
+  }
+  if (depthChain.length > 20) {
+    console.warn("[view]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return;
+  }
+  depthChain = [...depthChain, currentPath];
+  const allScriptModules = [];
+  const currentInstruction = compileModule(module, isComponent, scriptRes, {
+    skipTemplatePaths: isComponent ? inheritedTemplatePaths : /* @__PURE__ */ new Set()
+  });
+  if (currentInstruction && currentInstruction.scriptModule) {
+    allScriptModules.push(...currentInstruction.scriptModule);
+  }
+  const childInheritedTemplatePaths = new Set(inheritedTemplatePaths);
+  for (const tm of currentInstruction?.templateModule || []) {
+    childInheritedTemplatePaths.add(tm.path);
+  }
+  if (module.usingComponents) {
+    for (const componentInfo of Object.values(module.usingComponents)) {
+      const componentModule = getComponent(componentInfo);
+      if (!componentModule) {
+        continue;
+      }
+      if (componentModule.path === module.path) {
+        console.warn("[view]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56\uFF0C\u8DF3\u8FC7\u5904\u7406: ${module.path}`);
+        continue;
+      }
+      const componentInstruction = buildCompileView(componentModule, true, scriptRes, depthChain, childInheritedTemplatePaths);
+      if (componentInstruction && componentInstruction.scriptModule) {
+        for (const sm of componentInstruction.scriptModule) {
+          if (!allScriptModules.find((existing) => existing.path === sm.path)) {
+            allScriptModules.push(sm);
+          }
+        }
+      }
+    }
+  }
+  if (!isComponent && allScriptModules.length > 0) {
+    for (const sm of allScriptModules) {
+      if (!scriptRes.has(sm.path)) {
+        scriptRes.set(sm.path, sm.code);
+      }
+    }
+    compileModuleWithAllWxs(module, scriptRes, allScriptModules);
+  }
+  return { scriptModule: allScriptModules, templateModule: currentInstruction?.templateModule || [] };
+}
+function compileModule(module, isComponent, scriptRes, options = {}) {
+  const skipTemplatePaths = options.skipTemplatePaths || /* @__PURE__ */ new Set();
+  const { tpl, instruction } = toCompileTemplate(isComponent, module.path, module.usingComponents, module.componentPlaceholder);
+  if (!tpl) {
+    return null;
+  }
+  const templateModule = instruction.templateModule || [];
+  const templateModuleForCompile = templateModule.filter((tm) => !skipTemplatePaths.has(tm.path));
+  const compileInstruction = {
+    ...instruction,
+    templateModule: templateModuleForCompile
+  };
+  let useCache = false;
+  let cachedCode = null;
+  const canUseCache = skipTemplatePaths.size === 0;
+  if (canUseCache && !scriptRes.has(module.path) && compileResCache.has(module.path)) {
+    const cacheData2 = compileResCache.get(module.path);
+    if (cacheData2 && typeof cacheData2 === "object" && cacheData2.code && cacheData2.instruction) {
+      cachedCode = cacheData2.code;
+      useCache = true;
+      for (const sm of cacheData2.instruction.scriptModule) {
+        if (!scriptRes.has(sm.path)) {
+          scriptRes.set(sm.path, sm.code);
+        }
+      }
+    } else if (typeof cacheData2 === "string") {
+      cachedCode = cacheData2;
+      useCache = true;
+    }
+  }
+  if (useCache && cachedCode) {
+    scriptRes.set(module.path, cachedCode);
+    const allWxsModules2 = collectAllWxsModules(scriptRes, /* @__PURE__ */ new Set(), instruction.scriptModule || []);
+    if (allWxsModules2.length > 0) {
+      const existingModules = instruction.scriptModule || [];
+      const mergedModules = [...existingModules];
+      for (const wxsModule of allWxsModules2) {
+        if (!mergedModules.find((existing) => existing.path === wxsModule.path)) {
+          mergedModules.push(wxsModule);
+        }
+      }
+      instruction.scriptModule = mergedModules;
+    }
+    return {
+      ...instruction,
+      scriptModule: allWxsModules2
+    };
+  }
+  const processedTpl = tpl.replace(/\bthis\./g, "_ctx.");
+  const tplCode = compileTemplate({
+    source: processedTpl,
+    filename: module.path,
+    // 用于错误提示
+    id: `data-v-${module.id}`,
+    scoped: true,
+    compilerOptions: {
+      // https://template-explorer.vuejs.org/
+      prefixIdentifiers: true,
+      hoistStatic: false,
+      cacheHandlers: true,
+      scopeId: `data-v-${module.id}`,
+      mode: "function",
+      inline: true
+    }
+  });
+  let tplComponents = "{";
+  for (const tm of compileInstruction.templateModule) {
+    let { code: code2 } = compileTemplate({
+      source: tm.tpl,
+      filename: tm.path,
+      id: `data-v-${module.id}`,
+      scoped: true,
+      compilerOptions: {
+        prefixIdentifiers: true,
+        hoistStatic: false,
+        cacheHandlers: true,
+        scopeId: `data-v-${module.id}`,
+        mode: "function",
+        inline: true
+      }
+    });
+    code2 = insertWxsToRenderCode(code2, compileInstruction.scriptModule, scriptRes, tm.path);
+    tplComponents += `'${tm.path}':${code2},`;
+  }
+  tplComponents += "}";
+  const transCode = insertWxsToRenderCode(tplCode.code, compileInstruction.scriptModule, scriptRes, module.path);
+  const code = `Module({
+		path: '${module.path}',
+		id: '${module.id}',
+		render: ${transCode},
+		usingComponents: ${JSON.stringify(module.usingComponents)},
+		tplComponents: ${tplComponents},
+		});`;
+  const allWxsModules = collectAllWxsModules(scriptRes, /* @__PURE__ */ new Set(), compileInstruction.scriptModule || []);
+  if (allWxsModules.length > 0) {
+    const existingModules = compileInstruction.scriptModule || [];
+    const mergedModules = [...existingModules];
+    for (const wxsModule of allWxsModules) {
+      if (!mergedModules.find((existing) => existing.path === wxsModule.path)) {
+        mergedModules.push(wxsModule);
+      }
+    }
+    compileInstruction.scriptModule = mergedModules;
+  }
+  const cacheData = {
+    code,
+    instruction: compileInstruction
+  };
+  if (canUseCache) {
+    compileResCache.set(module.path, cacheData);
+  }
+  scriptRes.set(module.path, code);
+  return {
+    ...compileInstruction,
+    templateModule
+  };
+}
+function processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, filePath) {
+  let wxsAst;
+  try {
+    wxsAst = parseJs(wxsContent, wxsFilePath || "inline.wxs", "script");
+  } catch (error) {
+    console.error(`[view] \u89E3\u6790 wxs \u6587\u4EF6\u5931\u8D25: ${wxsFilePath}`, error.message);
+    return wxsContent;
+  }
+  const replacements = [];
+  walk2(wxsAst, {
+    enter(node) {
+      if (node.type === "CallExpression") {
+        const calleeName = node.callee?.name;
+        if (calleeName === "getRegExp") {
+          const args = node.arguments;
+          if (args.length > 0) {
+            if (isStringLiteral(args[0]) && (!args[1] || isStringLiteral(args[1]))) {
+              const pattern = getStringLiteralRawValue(args[0]);
+              const flags = args.length > 1 ? getStringLiteralRawValue(args[1]) : "";
+              replacements.push({
+                start: node.start,
+                end: node.end,
+                value: `/${pattern}/${flags}`
+              });
+            } else {
+              const newRegExpArgs = args.map((arg) => getSource(wxsContent, arg)).join(", ");
+              replacements.push({
+                start: node.start,
+                end: node.end,
+                value: `new RegExp(${newRegExpArgs})`
+              });
+            }
+          }
+        } else if (calleeName === "getDate") {
+          const args = node.arguments.map((arg) => getSource(wxsContent, arg)).join(", ");
+          replacements.push({
+            start: node.start,
+            end: node.end,
+            value: `new Date(${args})`
+          });
+        } else if (calleeName === "require" && node.arguments.length > 0 && wxsFilePath) {
+          const requirePath = node.arguments[0].value;
+          if (requirePath && typeof requirePath === "string") {
+            let resolvedWxsPath;
+            if (filePath && filePath.includes("/miniprogram_npm/")) {
+              const currentWxsDir = path7.dirname(wxsFilePath);
+              resolvedWxsPath = path7.resolve(currentWxsDir, requirePath);
+              const relativePath = stripViewScriptExt(resolvedWxsPath.replace(workPath, ""));
+              const moduleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+              processWxsDependency(resolvedWxsPath, moduleName, scriptModule, workPath, filePath);
+              replacements.push({
+                start: node.arguments[0].start,
+                end: node.arguments[0].end,
+                value: JSON.stringify(moduleName)
+              });
+            } else {
+              const currentWxsDir = path7.dirname(wxsFilePath);
+              resolvedWxsPath = path7.resolve(currentWxsDir, requirePath);
+              const relativePath = stripViewScriptExt(resolvedWxsPath.replace(workPath, ""));
+              const depModuleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+              processWxsDependency(resolvedWxsPath, depModuleName, scriptModule, workPath, filePath);
+              replacements.push({
+                start: node.arguments[0].start,
+                end: node.arguments[0].end,
+                value: JSON.stringify(depModuleName)
+              });
+            }
+          }
+        }
+      }
+      if (node.type === "MemberExpression") {
+        if (node.property?.name === "constructor" && !node.computed) {
+          const objectCode = getSource(wxsContent, node.object);
+          replacements.push({
+            start: node.start,
+            end: node.end,
+            value: `Object.prototype.toString.call(${objectCode}).slice(8, -1)`
+          });
+        }
+      }
+    }
+  });
+  return applyCodeReplacements(wxsContent, replacements);
+}
+function isWxsModuleByContent(moduleCode, modulePath = "") {
+  if (!moduleCode || typeof moduleCode !== "string") {
+    return false;
+  }
+  if (modulePath && isRegisteredWxsModule(modulePath)) {
+    return true;
+  }
+  return false;
+}
+function processWxsDependency(wxsFilePath, moduleName, scriptModule, workPath, filePath) {
+  if (!fs8.existsSync(wxsFilePath)) {
+    console.warn(`[view] wxs \u4F9D\u8D56\u6587\u4EF6\u4E0D\u5B58\u5728: ${wxsFilePath}`);
+    return;
+  }
+  if (scriptModule.find((sm) => sm.path === moduleName)) {
+    return;
+  }
+  const wxsContent = getContentByPath(wxsFilePath).trim();
+  if (!wxsContent) {
+    return;
+  }
+  const wxsCode = processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, filePath);
+  registerWxsModule(moduleName);
+  scriptModule.push({
+    path: moduleName,
+    code: wxsCode
+  });
+}
+function compileModuleWithAllWxs(module, scriptRes, allScriptModules) {
+  const { tpl, instruction } = toCompileTemplate(false, module.path, module.usingComponents, module.componentPlaceholder);
+  if (!tpl) {
+    return;
+  }
+  const mergedInstruction = {
+    ...instruction,
+    scriptModule: allScriptModules
+  };
+  const processedTpl = tpl.replace(/\bthis\./g, "_ctx.");
+  const tplCode = compileTemplate({
+    source: processedTpl,
+    filename: module.path,
+    id: `data-v-${module.id}`,
+    scoped: true,
+    compilerOptions: {
+      prefixIdentifiers: true,
+      hoistStatic: false,
+      cacheHandlers: true,
+      scopeId: `data-v-${module.id}`,
+      mode: "function",
+      inline: true
+    }
+  });
+  let tplComponents = "{";
+  for (const tm of mergedInstruction.templateModule) {
+    let { code: code2 } = compileTemplate({
+      source: tm.tpl,
+      filename: tm.path,
+      id: `data-v-${module.id}`,
+      scoped: true,
+      compilerOptions: {
+        prefixIdentifiers: true,
+        hoistStatic: false,
+        cacheHandlers: true,
+        scopeId: `data-v-${module.id}`,
+        mode: "function",
+        inline: true
+      }
+    });
+    code2 = insertWxsToRenderCode(code2, allScriptModules, scriptRes, tm.path);
+    tplComponents += `'${tm.path}':${code2},`;
+  }
+  tplComponents += "}";
+  const transCode = insertWxsToRenderCode(tplCode.code, allScriptModules, scriptRes, module.path);
+  const code = `Module({
+		path: '${module.path}',
+		id: '${module.id}',
+		render: ${transCode},
+		usingComponents: ${JSON.stringify(module.usingComponents)},
+		tplComponents: ${tplComponents},
+		});`;
+  const cacheData = {
+    code,
+    instruction: mergedInstruction
+  };
+  compileResCache.set(module.path, cacheData);
+  scriptRes.set(module.path, code);
+}
+function processIncludeConditionalAttrs($, elem, includeContent) {
+  const allAttrs = $(elem).attr();
+  const conditionAttrs = {};
+  let hasCondition = false;
+  for (const attrName in allAttrs) {
+    if (attrName.endsWith(":if") || attrName.endsWith(":elif") || attrName.endsWith(":else")) {
+      conditionAttrs[attrName] = allAttrs[attrName];
+      hasCondition = true;
+    }
+  }
+  if (hasCondition) {
+    let blockAttrs = "";
+    for (const attrName in conditionAttrs) {
+      const attrValue = conditionAttrs[attrName];
+      if (attrValue !== void 0 && attrValue !== "") {
+        blockAttrs += ` ${attrName}="${attrValue}"`;
+      } else {
+        blockAttrs += ` ${attrName}`;
+      }
+    }
+    return `<block${blockAttrs}>${includeContent}</block>`;
+  } else {
+    return includeContent;
+  }
+}
+function processIncludedFileWxsDependencies(content, includePath, scriptModule, components, processedPaths = /* @__PURE__ */ new Set()) {
+  if (processedPaths.has(includePath)) {
+    return;
+  }
+  processedPaths.add(includePath);
+  const $ = cheerio.load(content, {
+    xmlMode: true,
+    decodeEntities: false,
+    _useHtmlParser2: true,
+    // 减少内存占用的配置
+    lowerCaseTags: false,
+    lowerCaseAttributeNames: false
+  });
+  const componentTags = /* @__PURE__ */ new Set();
+  $("*").each((_, elem) => {
+    const tagName = elem.tagName;
+    if (components && components[tagName]) {
+      componentTags.add(tagName);
+    }
+  });
+  for (const tagName of componentTags) {
+    const componentPath = components[tagName];
+    const componentModule = getComponent(componentPath);
+    if (componentModule) {
+      if (processedPaths.has(componentModule.path)) {
+        continue;
+      }
+      const componentTemplate = toCompileTemplate(true, componentModule.path, componentModule.usingComponents, componentModule.componentPlaceholder, processedPaths);
+      if (componentTemplate && componentTemplate.instruction && componentTemplate.instruction.scriptModule) {
+        for (const sm of componentTemplate.instruction.scriptModule) {
+          if (!scriptModule.find((existing) => existing.path === sm.path)) {
+            scriptModule.push(sm);
+          }
+        }
+      }
+    }
+  }
+}
+function toCompileTemplate(isComponent, path9, components, componentPlaceholder, processedPaths = /* @__PURE__ */ new Set()) {
+  const workPath = getWorkPath();
+  const fullPath = getViewPath(workPath, path9);
+  if (!fullPath) {
+    return { tpl: void 0 };
+  }
+  const diagnosticSource = fullPath.startsWith(workPath) ? fullPath.slice(workPath.length) : path9;
+  let content = getContentByPath(fullPath).trim();
+  if (!content) {
+    content = "<block></block>";
+  } else {
+    checkTemplateCompatibility(content, diagnosticSource, components);
+    if (isComponent) {
+      content = `<wrapper name="${path9}">${content}</wrapper>`;
+    } else {
+      const tempRoot = cheerio.load(content, {
+        xmlMode: true,
+        decodeEntities: false
+      });
+      const rootNodes = tempRoot.root().children().toArray().filter((node) => node.type !== "comment");
+      if (rootNodes.length > 1) {
+        content = `<view>${content}</view>`;
+      }
+    }
+  }
+  const templateModule = [];
+  const scriptModule = [];
+  const $ = cheerio.load(content, {
+    xmlMode: true,
+    decodeEntities: false,
+    _useHtmlParser2: true,
+    // 减少内存占用的配置
+    lowerCaseTags: false,
+    lowerCaseAttributeNames: false
+  });
+  const includeNodes = $("include");
+  includeNodes.each((_, elem) => {
+    const src = $(elem).attr("src");
+    if (src) {
+      const includeFullPath = getAbsolutePath(workPath, path9, src);
+      let includePath = includeFullPath.replace(workPath, "").replace(buildExtStripRegex(getTemplateExts()), "");
+      const includeDiagnosticSource = includeFullPath.startsWith(workPath) ? includeFullPath.slice(workPath.length) : includePath;
+      if (!includePath.startsWith("/")) {
+        includePath = "/" + includePath;
+      }
+      const includeContent = getContentByPath(includeFullPath).trim();
+      if (includeContent) {
+        checkTemplateCompatibility(includeContent, includeDiagnosticSource, components);
+        const $includeContent = cheerio.load(includeContent, {
+          xmlMode: true,
+          decodeEntities: false
+        });
+        transTagTemplate(
+          $includeContent,
+          templateModule,
+          includePath,
+          components,
+          componentPlaceholder
+        );
+        transTagWxs(
+          $includeContent,
+          scriptModule,
+          includePath
+        );
+        processIncludedFileWxsDependencies(includeContent, includePath, scriptModule, components, processedPaths);
+        $includeContent("template").remove();
+        $includeContent(getViewScriptTags().join(",")).remove();
+        const processedContent = processIncludeConditionalAttrs($, elem, $includeContent.html());
+        $(elem).replaceWith(processedContent);
+      } else {
+        $(elem).remove();
+      }
+    } else {
+      $(elem).remove();
+    }
+  });
+  transTagTemplate($, templateModule, path9, components, componentPlaceholder);
+  transTagWxs($, scriptModule, path9);
+  const importNodes = $("import");
+  importNodes.each((_, elem) => {
+    const src = $(elem).attr("src");
+    if (src) {
+      const importFullPath = getAbsolutePath(workPath, path9, src);
+      let importPath = importFullPath.replace(workPath, "").replace(buildExtStripRegex(getTemplateExts()), "");
+      const importDiagnosticSource = importFullPath.startsWith(workPath) ? importFullPath.slice(workPath.length) : importPath;
+      if (!importPath.startsWith("/")) {
+        importPath = "/" + importPath;
+      }
+      const importContent = getContentByPath(importFullPath).trim();
+      if (importContent) {
+        checkTemplateCompatibility(importContent, importDiagnosticSource, components);
+        const $$ = cheerio.load(importContent, {
+          xmlMode: true,
+          decodeEntities: false
+        });
+        transTagTemplate(
+          $$,
+          templateModule,
+          path9,
+          components,
+          componentPlaceholder
+        );
+        transTagWxs(
+          $$,
+          scriptModule,
+          importPath
+        );
+        processIncludedFileWxsDependencies(importContent, importPath, scriptModule, components, processedPaths);
+      }
+    }
+  });
+  importNodes.remove();
+  transAsses($, $("image"), path9);
+  const res = [];
+  transHtmlTag($.html(), res, components, componentPlaceholder);
+  return {
+    tpl: res.join(""),
+    instruction: {
+      templateModule,
+      scriptModule
+    }
+  };
+}
+function transTagTemplate($, templateModule, path9, components, componentPlaceholder) {
+  const templateNodes = $("template[name]");
+  templateNodes.each((_, elem) => {
+    const name = $(elem).attr("name");
+    const templateContent = $(elem);
+    templateContent.find("import").remove();
+    templateContent.find("include").remove();
+    templateContent.find(getViewScriptTags().join(",")).remove();
+    transAsses($, templateContent.find("image"), path9);
+    const res = [];
+    transHtmlTag(templateContent.html(), res, components, componentPlaceholder);
+    templateModule.push({
+      path: `tpl-${name}`,
+      tpl: res.join("")
+    });
+  });
+  templateNodes.remove();
+}
+function transAsses($, imageNodes, path9) {
+  imageNodes.each((_, elem) => {
+    const imgSrc = $(elem).attr("src").trim();
+    if (!imgSrc.startsWith("{{")) {
+      $(elem).attr("src", collectAssets(getWorkPath(), path9, imgSrc, getTargetPath(), getAppId()));
+    }
+  });
+}
+function transHtmlTag(html, res, components, componentPlaceholder) {
+  const attrsList = [];
+  const parser = new htmlparser2.Parser(
+    {
+      onopentag(tag, attrs) {
+        attrsList.push(attrs);
+        res.push(transTag({ isStart: true, tag, attrs, components, componentPlaceholder }));
+      },
+      ontext(text) {
+        res.push(transformTextInterpolation(text));
+      },
+      onclosetag(tag) {
+        res.push(transTag({ tag, attrs: attrsList.pop(), components }));
+      },
+      onerror(error) {
+        console.error(error);
+      }
+    },
+    { xmlMode: true }
+  );
+  parser.write(html);
+  parser.end();
+}
+function transTag(opts) {
+  const { isStart, tag, attrs, components } = opts;
+  let res;
+  if (tag === "slot") {
+    res = tag;
+  } else if (components && components[tag]) {
+    res = `dd-${tag}`;
+  } else if (tag === "component" || tag === "canvas") {
+    res = tag;
+  } else if (!tagWhiteList.includes(tag)) {
+    res = "dd-text";
+  } else {
+    res = `dd-${tag}`;
+  }
+  let tagRes;
+  const propsAry = isStart ? getProps(attrs, tag, components) : [];
+  const multipleSlots = attrs?.slot;
+  if (attrs?.slot) {
+    const isDynamicSlot = isWrappedByBraces(multipleSlots);
+    if (isStart) {
+      const withVIf = [];
+      const withoutVIf = [];
+      for (let i = 0; i < propsAry.length; i++) {
+        const prop = propsAry[i];
+        if (prop.includes("v-if") || prop.includes("v-else-if") || prop.includes("v-else")) {
+          withVIf.push(prop);
+        } else if (!prop.includes("slot")) {
+          withoutVIf.push(prop);
+        }
+      }
+      const vIfProps = withVIf.length > 0 ? `${withVIf.join(" ")} ` : "";
+      const vOtherProps = withoutVIf.length > 0 ? ` ${withoutVIf.join(" ")}` : "";
+      const templateContent = `<template ${vIfProps}${generateSlotDirective(multipleSlots)}><${res}${vOtherProps}>`;
+      if (isDynamicSlot) {
+        tagRes = `<dd-block>${templateContent}`;
+      } else {
+        tagRes = templateContent;
+      }
+    } else {
+      if (isDynamicSlot) {
+        tagRes = `</${res}></template></dd-block>`;
+      } else {
+        tagRes = `</${res}></template>`;
+      }
+    }
+  } else {
+    if (isStart) {
+      const props = propsAry.join(" ");
+      tagRes = props ? `<${res} ${props}>` : `<${res}>`;
+    } else {
+      tagRes = `</${res}>`;
+    }
+  }
+  return tagRes;
+}
+function generateSlotDirective(slotValue) {
+  if (isWrappedByBraces(slotValue)) {
+    const slotExpression = parseBraceExp(slotValue);
+    return `#[${slotExpression}]`;
+  } else {
+    return `#${slotValue}`;
+  }
+}
+function getProps(attrs, tag, components) {
+  const attrsList = [];
+  const propBindings = {};
+  Object.entries(attrs).forEach(([name, value]) => {
+    if (name.endsWith(":if")) {
+      attrsList.push({
+        name: "v-if",
+        value: parseSafeBraceExp(value)
+      });
+    } else if (name.endsWith(":elif")) {
+      attrsList.push({
+        name: "v-else-if",
+        value: parseSafeBraceExp(value)
+      });
+    } else if (name.endsWith(":else")) {
+      attrsList.push({
+        name: "v-else",
+        value: ""
+      });
+    } else if (name.endsWith(":for") || name.endsWith(":for-items")) {
+      attrsList.push({
+        name: "v-for",
+        value: parseForExp(value, attrs)
+      });
+    } else if (name.endsWith(":for-item") || name.endsWith(":for-index")) {
+    } else if (name.endsWith(":key")) {
+      const tranValue = parseKeyExpression(value, getForItemName(attrs), getForIndexName(attrs));
+      attrsList.push({
+        name: ":key",
+        value: tranValue
+      });
+    } else if (name === "style") {
+      attrsList.push({
+        name: "v-c-style",
+        value: transformRpx(parseSafeBraceExp(value))
+      });
+    } else if (name === "class") {
+      if (isWrappedByBraces(value)) {
+        attrsList.push({
+          name: ":class",
+          value: parseClassRules(value)
+        });
+      } else {
+        attrsList.push({
+          name: "class",
+          value
+        });
+      }
+      attrsList.push({
+        name: "v-c-class",
+        value: ""
+      });
+    } else if (name === "is" && tag === "component") {
+      attrsList.push({
+        name: ":is",
+        value: `'dd-'+${parseSafeBraceExp(value)}`
+      });
+    } else if (name === "animation" && (tag !== "movable-view" && tagWhiteList.includes(tag))) {
+      attrsList.push({
+        name: "v-c-animation",
+        value: parseSafeBraceExp(value)
+      });
+    } else if (name === "value" && (tag === "input" || tag === "textarea") || (name === "x" || name === "y") && tag === "movable-view") {
+      const parsedValue = parseSafeBraceExp(value);
+      const conditionExp = generateVModelTemplate(parsedValue);
+      if (conditionExp) {
+        attrsList.push({
+          name: `:${name}`,
+          value: parsedValue
+        });
+        attrsList.push({
+          name: `update:${name}`,
+          value: conditionExp
+        });
+      } else {
+        attrsList.push({
+          name: `v-model:${name}`,
+          value: parsedValue
+        });
+      }
+    } else if (name.startsWith("data-")) {
+      if (isWrappedByBraces(value)) {
+        attrsList.push({
+          name: "v-c-data",
+          value: ""
+        });
+        attrsList.push({
+          name: `:${name}`,
+          value: parseSafeBraceExp(value)
+        });
+      } else {
+        attrsList.push({
+          name,
+          value
+        });
+      }
+    } else if (isWrappedByBraces(value)) {
+      const pVal = tag === "template" && name === "data" ? parseTemplateDataExp(value) : parseSafeBraceExp(value);
+      if (components && components[tag]) {
+        if (pVal && typeof pVal === "string") {
+          propBindings[name] = pVal;
+        }
+      }
+      attrsList.push({
+        name: `:${name}`,
+        value: pVal
+      });
+    } else if (name !== "slot") {
+      attrsList.push({
+        name,
+        value
+      });
+    }
+  });
+  const propsRes = [];
+  attrsList.forEach((attr) => {
+    const { name, value } = attr;
+    if (value === "") {
+      propsRes.push(`${name}`);
+    } else if (/\$\{[^}]*\}/.test(value)) {
+      propsRes.push(`:${name}="\`${value}\`"`);
+    } else {
+      propsRes.push(`${name}="${escapeQuotes(value)}"`);
+    }
+  });
+  if (components && components[tag] && Object.keys(propBindings).length > 0) {
+    try {
+      const validBindings = {};
+      for (const [key, value] of Object.entries(propBindings)) {
+        if (value !== void 0 && value !== null && typeof value === "string") {
+          validBindings[key] = value;
+        }
+      }
+      if (Object.keys(validBindings).length > 0) {
+        const parsedBindings = parseBindings(validBindings);
+        const bindingsJson = JSON.stringify(parsedBindings);
+        const escapedJson = bindingsJson.replace(/"/g, "&quot;");
+        propsRes.push(`v-c-prop-bindings="${escapedJson}"`);
+      }
+    } catch (error) {
+      console.warn("[compiler] \u5E8F\u5217\u5316 propBindings \u5931\u8D25:", error.message, "\u6807\u7B7E:", tag, "\u7ED1\u5B9A\u6570\u636E:", propBindings);
+    }
+  }
+  return propsRes;
+}
+function generateVModelTemplate(expression) {
+  let var1, var2, updateExpression;
+  if (expression.includes("&&")) {
+    [var1, var2] = expression.split("&&").map((v) => v.trim());
+    updateExpression = `${var1} ? (${var2} = $event) : (${var1} = $event)`;
+  } else if (expression.includes("||")) {
+    [var1, var2] = expression.split("||").map((v) => v.trim());
+    updateExpression = `${var1} ? (${var1} = $event) : (${var2} = $event)`;
+  } else if (expression.includes("?")) {
+    const parts = expression.split(/[?:]/).map((v) => v.trim());
+    var1 = parts[0];
+    var2 = parts[2];
+    updateExpression = `${var1} ? (${var1} = $event) : (${var2} = $event)`;
+  } else {
+    return false;
+  }
+  return updateExpression;
+}
+function parseKeyExpression(exp, itemName = "item", indexName = "index") {
+  exp = exp.trim();
+  if (/\*this/.test(exp) || /\*item/.test(exp)) {
+    return `${itemName}.toString()`;
+  }
+  if (!exp.includes("{{")) {
+    if (/^-?\d+(\.\d+)?$/.test(exp)) {
+      return exp;
+    }
+    if (exp === indexName) {
+      return indexName;
+    }
+    return exp.startsWith(itemName) ? `${exp}` : `${itemName}.${exp}`;
+  }
+  if (exp.startsWith("{{") && exp.endsWith("}}")) {
+    const content = exp.slice(2, -2).trim();
+    if (content === "this") {
+      return `${itemName}.toString()`;
+    } else if (content === indexName) {
+      return indexName;
+    } else {
+      return content.startsWith(itemName) ? `${content}` : `${itemName}.${content}`;
+    }
+  }
+  const parts = exp.split(/(\{\{.*?\}\})/);
+  const result = parts.map((part) => {
+    if (part.startsWith("{{") && part.endsWith("}}")) {
+      const content = part.slice(2, -2).trim();
+      if (content === indexName) {
+        return indexName;
+      }
+      return content.startsWith(itemName) ? content : `${itemName}.${content}`;
+    }
+    return `'${part}'`;
+  }).join("+");
+  return result.endsWith("+''") ? result.slice(0, -3) : result;
+}
+function getViewPath(workPath, src) {
+  const aSrc = src.startsWith("/") ? src : `/${src}`;
+  for (const mlType of getTemplateExts()) {
+    const mlFullPath = `${workPath}${aSrc}${mlType}`;
+    if (fs8.existsSync(mlFullPath)) {
+      return mlFullPath;
+    }
+    const indexMlFullPath = `${workPath}${aSrc}/index${mlType}`;
+    if (fs8.existsSync(indexMlFullPath)) {
+      return indexMlFullPath;
+    }
+  }
+}
+function escapeQuotes(input) {
+  return input.replace(/"/g, "'");
+}
+function isWrappedByBraces(str) {
+  return /\{\{.*\}\}/.test(str);
+}
+function splitWithBraces(str) {
+  const result = [];
+  let temp = "";
+  let inBraces = false;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" && i + 1 < str.length && str[i + 1] === "{") {
+      inBraces = true;
+      temp += "{{";
+      i++;
+    } else if (char === "}" && i + 1 < str.length && str[i + 1] === "}") {
+      inBraces = false;
+      temp += "}}";
+      i++;
+    } else if (!inBraces && char === " ") {
+      if (temp) {
+        result.push(temp);
+        temp = "";
+      }
+    } else {
+      temp += char;
+    }
+  }
+  if (temp) {
+    result.push(temp);
+  }
+  return result;
+}
+function parseClassRules(cssRule) {
+  let list = splitWithBraces(cssRule);
+  list = list.map((item) => {
+    return parseBraceExp(item);
+  });
+  if (list.length === 1) {
+    return list.pop();
+  }
+  return `[${list.join(",")}]`;
+}
+function getForItemName(attrs) {
+  for (const key in attrs) {
+    if (key.endsWith(":for-item")) {
+      return attrs[key];
+    }
+  }
+  return "item";
+}
+function getForIndexName(attrs) {
+  for (const key in attrs) {
+    if (key.endsWith(":for-index")) {
+      return attrs[key];
+    }
+  }
+  return "index";
+}
+function parseForExp(exp, attrs) {
+  const item = getForItemName(attrs);
+  const index = getForIndexName(attrs);
+  const listVariableName = parseBraceExp(exp);
+  return `(${item}, ${index}) in ${listVariableName}`;
+}
+var braceRegex = /(\{\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}\})|([^{}]+)/g;
+var noBraceRegex = /\{\{((?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*)\}\}/;
+var ternaryRegex = /[^?]+\?.+:.+/;
+function parseBraceExp(exp) {
+  let result;
+  const group = [];
+  while (result = braceRegex.exec(exp)) {
+    if (result[1]) {
+      const matchResult = result[1].match(noBraceRegex);
+      if (matchResult) {
+        const statement = matchResult[1].trim();
+        if (ternaryRegex.test(statement)) {
+          group.push(`(${statement})`);
+        } else {
+          group.push(statement);
+        }
+      }
+    }
+    if (result[2]) {
+      group.push(`+'${result[2].replace(/'/g, "\\'")}'+`);
+    }
+  }
+  return group.join("").replace(/^\+|\+$/g, "");
+}
+function parseTemplateDataExp(exp) {
+  const matchResult = exp.trim().match(/^\{\{([\s\S]*)\}\}$/);
+  if (matchResult) {
+    return `{${matchResult[1].trim()}}`;
+  }
+  return `{${parseBraceExp(exp)}}`;
+}
+function transTagWxs($, scriptModule, filePath) {
+  const wxsNodes = $(getViewScriptTags().join(","));
+  wxsNodes.each((_, elem) => {
+    const smName = $(elem).attr("module");
+    if (smName) {
+      let wxsContent;
+      let uniqueModuleName = smName;
+      let cacheKey = smName;
+      const src = $(elem).attr("src");
+      let wxsFilePath = null;
+      const workPath = getWorkPath();
+      if (src) {
+        if (filePath.includes("/miniprogram_npm/")) {
+          const componentDir = filePath.split("/").slice(0, -1).join("/");
+          const componentFullPath = workPath + componentDir;
+          wxsFilePath = path7.resolve(componentFullPath, src);
+        } else {
+          wxsFilePath = getAbsolutePath(workPath, filePath, src);
+        }
+        if (wxsFilePath) {
+          const relativePath = stripViewScriptExt(wxsFilePath.replace(workPath, ""));
+          uniqueModuleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+          cacheKey = wxsFilePath;
+        }
+      }
+      if (compileResCache.has(cacheKey)) {
+        wxsContent = compileResCache.get(cacheKey);
+      } else {
+        if (src && wxsFilePath) {
+          if (fs8.existsSync(wxsFilePath)) {
+            wxsContent = getContentByPath(wxsFilePath).trim();
+          } else {
+            console.warn(`[view] wxs \u6587\u4EF6\u4E0D\u5B58\u5728: ${wxsFilePath}`);
+            return;
+          }
+        } else {
+          wxsContent = $(elem).html();
+        }
+        if (!wxsContent) {
+          return;
+        }
+        wxsContent = processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, filePath);
+        compileResCache.set(cacheKey, wxsContent);
+      }
+      if (wxsContent) {
+        registerWxsModule(uniqueModuleName);
+        scriptModule.push({
+          path: uniqueModuleName,
+          code: wxsContent,
+          originalName: smName
+          // 保存原始模块名用于模板中的引用
+        });
+      }
+    }
+  });
+  wxsNodes.remove();
+}
+function collectAllWxsModules(scriptRes, collectedPaths = /* @__PURE__ */ new Set(), scriptModule = []) {
+  const allWxsModules = [];
+  const workPath = getWorkPath();
+  for (const [modulePath, moduleCode] of scriptRes.entries()) {
+    if (collectedPaths.has(modulePath)) {
+      continue;
+    }
+    if (isWxsModuleByContent(moduleCode, modulePath)) {
+      collectedPaths.add(modulePath);
+      allWxsModules.push({
+        path: modulePath,
+        code: moduleCode
+      });
+      const dependencies = extractWxsDependencies(moduleCode);
+      for (const depPath of dependencies) {
+        if (!collectedPaths.has(depPath)) {
+          if (scriptRes.has(depPath)) {
+            const depModules = collectAllWxsModules(/* @__PURE__ */ new Map([[depPath, scriptRes.get(depPath)]]), collectedPaths, scriptModule);
+            allWxsModules.push(...depModules);
+          } else {
+            const loaded = loadWxsModule(depPath, workPath, scriptModule);
+            if (loaded) {
+              scriptRes.set(depPath, loaded.code);
+              allWxsModules.push(loaded);
+              collectedPaths.add(depPath);
+              const depModules = collectAllWxsModules(/* @__PURE__ */ new Map([[depPath, loaded.code]]), collectedPaths, scriptModule);
+              allWxsModules.push(...depModules);
+            }
+          }
+        }
+      }
+    }
+  }
+  return allWxsModules;
+}
+function loadWxsModule(modulePath, workPath, scriptModule) {
+  const wxsFilePath = wxsFilePathMap.get(modulePath);
+  if (!wxsFilePath) {
+    return null;
+  }
+  try {
+    const wxsContent = getContentByPath(wxsFilePath).trim();
+    if (!wxsContent) {
+      return null;
+    }
+    const processedContent = processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, "");
+    registerWxsModule(modulePath);
+    return {
+      path: modulePath,
+      code: processedContent
+    };
+  } catch (error) {
+    console.warn(`[view] \u52A0\u8F7D wxs \u6A21\u5757\u5931\u8D25: ${modulePath}`, error.message);
+    return null;
+  }
+}
+function extractWxsDependencies(moduleCode) {
+  const dependencies = [];
+  const requirePattern = /(?:require|_)\s*\(\s*["']([^"']+)["']\s*\)/g;
+  let match;
+  while ((match = requirePattern.exec(moduleCode)) !== null) {
+    const depPath = match[1];
+    if (depPath && !dependencies.includes(depPath)) {
+      dependencies.push(depPath);
+    }
+  }
+  return dependencies;
+}
+function insertWxsToRenderCode(code, scriptModule, scriptRes, filename = "render.js") {
+  const wxsBindings = [];
+  const codeReplacements = [];
+  const ast = parseJs(code, filename);
+  const statement = ast.body?.[0];
+  const renderExpression = statement?.type === "ExpressionStatement" ? statement.expression : null;
+  const renderBody = renderExpression?.body;
+  const declarations = [];
+  for (const [index, sm] of scriptModule.entries()) {
+    if (!scriptRes.has(sm.path)) {
+      scriptRes.set(sm.path, sm.code);
+    }
+    const templatePropertyName = sm.originalName || sm.path;
+    const requireModuleName = sm.path;
+    const localIdentifier = `__wxs_${index}`;
+    wxsBindings.push({
+      localIdentifier,
+      templatePropertyName
+    });
+    declarations.push(`const ${localIdentifier} = require(${JSON.stringify(requireModuleName)});`);
+  }
+  if (wxsBindings.length === 0) {
+    return getProgramCode(code, ast);
+  }
+  if (renderBody?.type === "BlockStatement") {
+    codeReplacements.push({
+      type: "insert",
+      start: renderBody.start + 1,
+      end: renderBody.start + 1,
+      value: `
+${declarations.join("\n")}`
+    });
+  }
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "MemberExpression" && node.object?.type === "Identifier" && node.object.name === "_ctx" && !node.computed && node.property?.type === "Identifier") {
+        const replacement = wxsBindings.find((item) => item.templatePropertyName === node.property.name);
+        if (replacement) {
+          codeReplacements.push({
+            start: node.start,
+            end: node.end,
+            value: replacement.localIdentifier
+          });
+        }
+      }
+    }
+  });
+  const transformed = applyCodeReplacements(code, codeReplacements);
+  const transformedAst = parseJs(transformed, filename);
+  return getProgramCode(transformed, transformedAst);
+}
+function __resetViewState() {
+  compileResCache.clear();
+  wxsModuleRegistry.clear();
+  wxsFilePathMap.clear();
+}
+
+// ../../dimina/fe/packages/compiler/src/core/style-compiler.js
+import fs9 from "node:fs";
+import path8 from "node:path";
+import { compileStyle } from "@vue/compiler-sfc";
+import autoprefixer from "autoprefixer";
+import cssnano from "cssnano";
+import less from "less";
+import postcss from "postcss";
+import selectorParser from "postcss-selector-parser";
+import * as sass from "sass";
+var compileRes = /* @__PURE__ */ new Map();
+if (!isMainThread) {
+  parentPort.on("message", async ({ pages, storeInfo: storeInfo2 }) => {
+    try {
+      resetStoreInfo(storeInfo2);
+      const progress = {
+        _completedTasks: 0,
+        get completedTasks() {
+          return this._completedTasks;
+        },
+        set completedTasks(value) {
+          this._completedTasks = value;
+          parentPort.postMessage({ completedTasks: this._completedTasks });
+        }
+      };
+      await compileSS(pages.mainPages, null, progress);
+      for (const [root, subPages] of Object.entries(pages.subPages)) {
+        await compileSS(subPages.info, root, progress);
+      }
+      compileRes.clear();
+      parentPort.postMessage({ success: true });
+    } catch (error) {
+      compileRes.clear();
+      parentPort.postMessage({
+        success: false,
+        error: {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        }
+      });
+    }
+  });
+}
+async function compileSS(pages, root, progress) {
+  for (const page of pages) {
+    const code = await buildCompileCss(page, [], /* @__PURE__ */ new Set()) || "";
+    const filename = `${page.path.replace(/\//g, "_")}`;
+    if (root) {
+      const subDir = `${getTargetPath()}/${root}`;
+      if (!fs9.existsSync(subDir)) {
+        fs9.mkdirSync(subDir, { recursive: true });
+      }
+      fs9.writeFileSync(`${subDir}/${filename}.css`, code);
+    } else {
+      const mainDir = `${getTargetPath()}/main`;
+      if (!fs9.existsSync(mainDir)) {
+        fs9.mkdirSync(mainDir, { recursive: true });
+      }
+      fs9.writeFileSync(`${mainDir}/${filename}.css`, code);
+    }
+    progress.completedTasks++;
+  }
+}
+async function buildCompileCss(module, depthChain = [], compiledPaths = /* @__PURE__ */ new Set()) {
+  const currentPath = module.path || module.absolutePath;
+  if (depthChain.includes(currentPath)) {
+    console.warn("[style]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return "";
+  }
+  if (depthChain.length > 20) {
+    console.warn("[style]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return "";
+  }
+  if (compiledPaths.has(currentPath)) {
+    return "";
+  }
+  compiledPaths.add(currentPath);
+  depthChain = [...depthChain, currentPath];
+  let result = await enhanceCSS(module) || "";
+  if (module.usingComponents) {
+    for (const componentInfo of Object.values(module.usingComponents)) {
+      const componentModule = getComponent(componentInfo);
+      if (!componentModule) {
+        continue;
+      }
+      result += await buildCompileCss(componentModule, depthChain, compiledPaths) || "";
+    }
+  }
+  return result;
+}
+async function enhanceCSS(module) {
+  const absolutePath = module.absolutePath ? module.absolutePath : getAbsolutePath2(module.path);
+  if (!absolutePath) {
+    return "";
+  }
+  const cacheKey = `${absolutePath}::${module.id || ""}`;
+  const inputCSS = getContentByPath(absolutePath);
+  if (!inputCSS) {
+    return "";
+  }
+  if (compileRes.has(cacheKey)) {
+    return compileRes.get(cacheKey);
+  }
+  let processedCSS = normalizeRootStyleImports(inputCSS);
+  const ext = path8.extname(absolutePath).toLowerCase();
+  try {
+    if (ext === ".less") {
+      const result2 = await less.render(processedCSS, {
+        filename: absolutePath,
+        paths: [path8.dirname(absolutePath), getWorkPath()]
+      });
+      processedCSS = result2.css;
+    } else if (ext === ".scss" || ext === ".sass") {
+      const result2 = sass.compileString(processedCSS, {
+        loadPaths: [path8.dirname(absolutePath), getWorkPath()],
+        syntax: ext === ".sass" ? "indented" : "scss"
+      });
+      processedCSS = result2.css;
+    }
+  } catch (error) {
+    console.error(`[style] \u9884\u5904\u7406\u5668\u7F16\u8BD1\u5931\u8D25 ${absolutePath}:`, error.message);
+    processedCSS = inputCSS;
+  }
+  const fixedCSS = ensureImportSemicolons(processedCSS);
+  let ast;
+  try {
+    ast = postcss.parse(fixedCSS);
+  } catch (error) {
+    console.error(`[style] PostCSS \u89E3\u6790\u5931\u8D25 ${absolutePath}:`, error.message);
+    return "";
+  }
+  const promises2 = [];
+  ast.walk(async (node) => {
+    if (node.type === "atrule" && node.name === "import") {
+      const str = node.params.replace(/^['"]|['"]$/g, "");
+      const importFullPath = resolveStyleImportPath(absolutePath, str);
+      node.remove();
+      promises2.push(buildCompileCss({ absolutePath: importFullPath, id: module.id }, [], /* @__PURE__ */ new Set()));
+    } else if (node.type === "rule") {
+      if (node.selector.includes("::v-deep")) {
+        node.selector = node.selector.replace(/::v-deep\s+(\S[^{]*)/g, ":deep($1)");
+      }
+      if (node.selector.includes(":host")) {
+        node.selector = processHostSelector(node.selector, module.id);
+      }
+      node.selector = selectorParser((selectors) => {
+        selectors.walkTags((tag) => {
+          if (tagWhiteList.includes(tag.value)) {
+            tag.value = `.dd-${tag.value}`;
+          }
+        });
+      }).processSync(node.selector);
+    } else if (node.type === "comment") {
+      node.remove();
+    }
+  });
+  ast.walkDecls((decl) => {
+    decl.value = normalizeCssUrlValue(decl.value, absolutePath);
+    decl.value = transformRpx(decl.value);
+  });
+  const cssCode = ast.toResult().css;
+  const moduleId = module.id;
+  const scopedCode = compileStyle({
+    source: cssCode,
+    id: moduleId,
+    scoped: !!moduleId
+  }).code;
+  const cleanedCode = await removeBaseComponentScope(scopedCode, moduleId);
+  const res = await postcss([
+    autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }),
+    cssnano()
+  ]).process(cleanedCode, { from: void 0 });
+  const importCss = (await Promise.all(promises2)).filter(Boolean).join("");
+  const result = importCss + res.css;
+  compileRes.set(cacheKey, result);
+  return result;
+}
+function normalizeCssUrlValue(value, absolutePath) {
+  return value.replace(/url\(([^)]+)\)/g, (fullMatch, rawUrl) => {
+    const cleanedUrl = rawUrl.trim().replace(/^['"]|['"]$/g, "");
+    if (!cleanedUrl || cleanedUrl.startsWith("data:image")) {
+      return fullMatch;
+    }
+    if (cleanedUrl.startsWith("//")) {
+      return `url(https:${cleanedUrl})`;
+    }
+    if (/^(https?:|blob:|data:)/.test(cleanedUrl)) {
+      return fullMatch;
+    }
+    const realSrc = collectAssets(getWorkPath(), absolutePath, cleanedUrl, getTargetPath(), getAppId());
+    return `url(${realSrc})`;
+  });
+}
+function getAbsolutePath2(modulePath) {
+  const workPath = getWorkPath();
+  const src = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  for (const ssType of getStyleExts()) {
+    const ssFullPath = `${workPath}${src}${ssType}`;
+    if (fs9.existsSync(ssFullPath)) {
+      return ssFullPath;
+    }
+    const indexSsFullPath = `${workPath}${src}/index${ssType}`;
+    if (fs9.existsSync(indexSsFullPath)) {
+      return indexSsFullPath;
+    }
+  }
+}
+function resolveStyleImportPath(absolutePath, importPath, workPath = getWorkPath()) {
+  if (importPath.startsWith("/")) {
+    return path8.join(workPath, importPath);
+  }
+  return path8.resolve(path8.dirname(absolutePath), importPath);
+}
+function normalizeRootStyleImports(source, workPath = getWorkPath()) {
+  return source.replace(/(@import\s+(?:\(.*?\)\s*)?(?:url\()?['"])(\/[^'")]+)(['"]\)?)/g, (_, prefix, importPath, suffix) => {
+    return `${prefix}${path8.join(workPath, importPath)}${suffix}`;
+  });
+}
+async function removeBaseComponentScope(css, moduleId) {
+  if (!moduleId) return css;
+  const ast = postcss.parse(css);
+  const scopeAttrName = `data-v-${moduleId}`;
+  ast.walkRules((rule) => {
+    const hasBaseComponent = tagWhiteList.some(
+      (tag) => rule.selector.includes(`.dd-${tag}`)
+    );
+    if (hasBaseComponent && rule.selector.includes(scopeAttrName)) {
+      rule.selector = selectorParser((selectors) => {
+        selectors.walkAttributes((attr) => {
+          if (attr.attribute === scopeAttrName) {
+            attr.remove();
+          }
+        });
+      }).processSync(rule.selector);
+    }
+  });
+  return ast.toResult().css;
+}
+function ensureImportSemicolons(css) {
+  return css.replace(/@import[^;\n]*$/gm, (match) => {
+    return match.endsWith(";") ? match : `${match};`;
+  });
+}
+function processHostSelector(selector, moduleId) {
+  return selector.replace(/^:host$/, `[data-v-${moduleId}]`).replace(/:host\(([^)]+)\)/g, `[data-v-${moduleId}]$1`).replace(/:host\s+/g, `[data-v-${moduleId}] `).replace(/:host(?=\.|#|:)/g, `[data-v-${moduleId}]`);
+}
+function __resetStyleState() {
+  compileRes.clear();
+}
+
+// src/compile-core.js
+var SYNTHETIC_APPID = "dmlocalpreview";
+function ensureAppIdFs(fs10, configPath) {
+  let config = {};
+  if (fs10.existsSync(configPath)) {
+    const raw = fs10.readFileSync(configPath, "utf8");
+    try {
+      config = JSON.parse(raw);
+    } catch {
+      throw new Error(`[compiler] ${configPath} is not valid JSON; refusing to overwrite it`);
+    }
+    if (config === null || typeof config !== "object" || Array.isArray(config)) {
+      throw new Error(`[compiler] ${configPath} must be a JSON object`);
+    }
+  }
+  const { appid } = config;
+  if (appid !== void 0 && appid !== "" && typeof appid !== "string") {
+    throw new Error(`[compiler] ${configPath} "appid" must be a non-empty string`);
+  }
+  if (!appid) {
+    config.appid = SYNTHETIC_APPID;
+    const slash = configPath.lastIndexOf("/");
+    if (slash > 0) fs10.mkdirSync(configPath.slice(0, slash), { recursive: true });
+    fs10.writeFileSync(configPath, JSON.stringify(config));
+  }
+}
+function findScopedNpmDirs(fs10, workPath, excludeRoots) {
+  const excluded = excludeRoots.filter(Boolean).map((p) => p.endsWith("/") ? p : `${p}/`);
+  const npmDirs = [];
+  const walk3 = (dir, rel) => {
+    if (!fs10.existsSync(dir)) return;
+    for (const item of fs10.readdirSync(dir, { withFileTypes: true })) {
+      if (!item.isDirectory()) continue;
+      const { name } = item;
+      if (name === "node_modules" || name.startsWith(".")) continue;
+      const full = `${dir}/${name}`;
+      if (excluded.some((ex) => `${full}/`.startsWith(ex))) continue;
+      const childRel = rel ? `${rel}/${name}` : name;
+      if (name === "miniprogram_npm") npmDirs.push(childRel);
+      else walk3(full, childRel);
+    }
+  };
+  walk3(workPath.endsWith("/") ? workPath.slice(0, -1) : workPath, "");
+  return npmDirs;
+}
+var ScopedNpmBuilder = class extends NpmBuilder {
+  constructor(workPath, targetPath, { fs: fs10, excludeRoots }) {
+    super(workPath, targetPath);
+    this._fs = fs10;
+    this._excludeRoots = excludeRoots;
+  }
+  findMiniprogramNpmDirs() {
+    return findScopedNpmDirs(this._fs, this.workPath, this._excludeRoots);
+  }
+};
+var REQUIRED_FS = [
+  "existsSync",
+  "readFileSync",
+  "readdirSync",
+  "statSync",
+  "writeFileSync",
+  "mkdirSync",
+  "copyFileSync",
+  "rmSync"
+];
+function assertFs(fs10) {
+  if (!fs10 || typeof fs10 !== "object") {
+    throw new Error("[compiler] compileMiniApp requires { fs }: inject a node:fs replacement (e.g. createFsFromVolume(memfs Volume)) seeded with the project source under workPath");
+  }
+  const missing = REQUIRED_FS.filter((m) => typeof fs10[m] !== "function");
+  if (missing.length) {
+    throw new Error(`[compiler] injected fs is missing required method(s): ${missing.join(", ")}. Needs the sync subset ${REQUIRED_FS.join("/")}, and readdirSync must support { withFileTypes: true }.`);
+  }
+}
+async function runLogicStage(pages, progress) {
+  const mainRes = await compileJS(pages.mainPages, null, null, progress);
+  for (const [root, sub] of Object.entries(pages.subPages)) {
+    const subRes = await compileJS(sub.info, root, sub.independent ? [] : mainRes, progress);
+    await writeCompileRes(subRes, root);
+  }
+  await writeCompileRes(mainRes, null);
+}
+async function runViewStage(pages, progress) {
+  await compileML(pages.mainPages, null, progress);
+  for (const [root, sub] of Object.entries(pages.subPages)) {
+    await compileML(sub.info, root, progress);
+  }
+}
+async function runStyleStage(pages, progress) {
+  const styleMain = [{ path: "app", id: "" }, ...pages.mainPages];
+  await compileSS(styleMain, null, progress);
+  for (const [root, sub] of Object.entries(pages.subPages)) {
+    await compileSS(sub.info, root, progress);
+  }
+}
+var STAGES = {
+  logic: runLogicStage,
+  view: runViewStage,
+  style: runStyleStage
+};
+var STAGE_NAMES = Object.keys(STAGES);
+async function setupCompile({ fs: fs10, workPath = "/work", options = {}, npmScanExclude = [] } = {}) {
+  assertFs(fs10);
+  ensureAppIdFs(fs10, `${workPath}/project.config.json`);
+  setFs(fs10);
+  try {
+    const store = storeInfo(workPath, options);
+    createDist();
+    config_compiler_default();
+    try {
+      await new ScopedNpmBuilder(getWorkPath(), getTargetPath(), {
+        fs: fs10,
+        excludeRoots: [getTargetPath(), ...npmScanExclude]
+      }).buildNpmPackages();
+    } catch (e) {
+      throw new Error(`[compiler] miniprogram_npm build failed: ${e.message}`);
+    }
+    return {
+      storeInfo: store,
+      pages: getPages(),
+      appId: getAppId(),
+      name: getAppName(),
+      targetPath: getTargetPath(),
+      workPath
+    };
+  } finally {
+    resetFs();
+  }
+}
+function resetCompilerState() {
+  __resetLogicState();
+  __resetStyleState();
+  __resetViewState();
+  __resetAssets();
+}
+var compileChain = Promise.resolve();
+
+// src/pool-node.js
+var { Worker } = createRequire(import.meta.url)("node:worker_threads");
+var chain = Promise.resolve();
+function createNodeCompilerPool({ stages = STAGE_NAMES } = {}) {
+  const workerURL = new URL("./stage-worker.node.js", import.meta.url);
+  let disposed = false;
+  const workers = stages.map((stage) => {
+    const slot = { stage, w: null, q: [] };
+    const spawn = () => {
+      const w = new Worker(workerURL);
+      const settle = (v) => {
+        const r = slot.q.shift();
+        if (r) r(v);
+      };
+      w.on("message", settle);
+      w.on("error", (e) => settle({ type: "error", stage, error: { message: e && e.message, stack: e && e.stack } }));
+      w.on("exit", (code) => {
+        if (slot.w === w) slot.w = null;
+        while (slot.q.length) settle({ type: "error", stage, error: { message: `stage worker "${stage}" exited (code ${code})` } });
+      });
+      return w;
+    };
+    slot.w = spawn();
+    slot.send = (m) => new Promise((res) => {
+      if (!slot.w) slot.w = spawn();
+      slot.q.push(res);
+      slot.w.postMessage(m);
+    });
+    return slot;
+  });
+  async function runBuild(outputDir, workPath, useAppIdDir, options) {
+    const { sourcemap = false, fileTypes } = options || {};
+    resetCompilerState();
+    const ctx = await setupCompile({
+      fs: nodeFs,
+      workPath,
+      options: { fileTypes },
+      npmScanExclude: [nodePath.resolve(process4.cwd(), outputDir)]
+    });
+    const { storeInfo: storeInfo2, pages } = ctx;
+    const results = await Promise.all(
+      workers.map((x) => x.send({ stage: x.stage, pages, storeInfo: storeInfo2, sourcemap }))
+    );
+    for (const r of results) {
+      if (!r || r.type === "error") {
+        const info = r && r.error;
+        const err = new Error(`[compiler] stage "${r && r.stage}" failed: ${info && info.message || "unknown error"}`);
+        if (info && info.stack) err.stack = info.stack;
+        err.stage = r && r.stage;
+        throw err;
+      }
+    }
+    publishToDist(outputDir, useAppIdDir);
+    return {
+      appId: getAppId(),
+      name: getAppName(),
+      // dmcc reads mainPages[1] only because its style task unshifts `app` into the
+      // SHARED array first, making [1] the original FIRST page. Our style stage builds
+      // a fresh array instead of mutating, so the equivalent here is mainPages[0].
+      path: getAppConfigInfo().entryPagePath || pages.mainPages[0]?.path || ""
+    };
+  }
+  function build2(outputDir, workPath, useAppIdDir = true, options = {}) {
+    if (disposed) return Promise.reject(new Error("[compiler] pool has been disposed"));
+    const result = chain.then(() => runBuild(outputDir, workPath, useAppIdDir, options));
+    chain = result.then(() => {
+    }, () => {
+    });
+    return result;
+  }
+  async function dispose() {
+    disposed = true;
+    await Promise.all(workers.map((x) => x.w ? x.w.terminate() : null));
+  }
+  return { build: build2, dispose, stages, _slots: workers };
+}
+var STAGE_TITLES = { logic: "\u7F16\u8BD1\u9875\u9762\u903B\u8F91", view: "\u7F16\u8BD1\u9875\u9762\u6587\u4EF6", style: "\u7F16\u8BD1\u6837\u5F0F\u6587\u4EF6" };
+var singleton = null;
+async function build(outputDir, workPath, useAppIdDir = true, options = {}) {
+  if (!singleton) singleton = createNodeCompilerPool();
+  try {
+    const info = await singleton.build(outputDir, workPath, useAppIdDir, options);
+    console.log("\u2714 \u8F93\u51FA\u7F16\u8BD1\u4EA7\u7269");
+    return info;
+  } catch (e) {
+    if (e && e.stage) console.error(`\u2716 ${STAGE_TITLES[e.stage] || e.stage}`);
+    console.error(`${workPath} \u7F16\u8BD1\u51FA\u9519: ${e && e.message}`);
+    return void 0;
+  }
+}
+async function disposeDefaultPool() {
+  if (singleton) {
+    await singleton.dispose();
+    singleton = null;
+  }
+}
+export {
+  createNodeCompilerPool,
+  build as default,
+  disposeDefaultPool
+};