@cmmn/tools 2.2.3 → 3.0.0-alpha-4

package/dist/bundle/index.js

@@ -0,0 +1,913 @@
+import { getPackages } from '@manypkg/get-packages';
+import path, { join, dirname, resolve, relative } from 'node:path';
+import terminalKit from 'terminal-kit';
+import fs$1, { stat, readFile } from 'node:fs/promises';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { minimatch } from 'minimatch';
+import { build } from 'vite';
+import { subtle } from 'crypto';
+import builtinModules from 'builtin-modules';
+import swc from 'unplugin-swc';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { minify } from '@swc/core';
+import { _ } from '@swc/helpers/_/_ts_add_disposable_resource';
+import { _ as _$1 } from '@swc/helpers/_/_ts_dispose_resources';
+import { crc32 } from 'node:zlib';
+import { esmExternalRequirePlugin } from 'rolldown/experimental';
+
+var define_process_default$2 = { env: { NODE_ENV: "production" } };
+class Pack extends EventTarget {
+  static async read(id, version, dir = define_process_default$2.cwd()) {
+    while (dir) {
+      try {
+        const pkgDir = join(dir, "node_modules", id);
+        if (await stat(pkgDir)) {
+          const json = JSON.parse(await readFile(join(pkgDir, "package.json"), {
+            encoding: "utf-8"
+          }));
+          return new Pack(pkgDir, json);
+        }
+      } catch {
+        dir = dirname(dir);
+      }
+    }
+  }
+  *getAllDependencies(prod) {
+    yield* Object.entries(this.packageJson.dependencies ?? {});
+    if (!prod) yield* Object.entries(this.packageJson.devDependencies ?? {});
+  }
+  constructor(rootDir, packageJson) {
+    super(), this.rootDir = rootDir, this.packageJson = packageJson, this.reactions = [];
+  }
+  init(flags, packsMap) {
+    const deps = Object.keys(this.packageJson.dependencies ?? {});
+    if (!flags.production) deps.push(...Object.keys(this.packageJson.devDependencies ?? {}));
+    this.deps = deps.map((x) => packsMap.get(x)).filter((x) => !!x);
+    this.deps.forEach((x) => x.reactions.push(this));
+    for (let dep of this.deps) {
+      dep.addEventListener("change", (e) => {
+        this.dispatchEvent(new ChangeEvent(e.payload, e.from));
+      });
+      dep.addEventListener("file", (e) => {
+        this.dispatchEvent(new FileChangeEvent([]));
+      });
+    }
+  }
+  get isServer() {
+    return !!this.packageJson.config?.server;
+  }
+  get name() {
+    return this.packageJson.name;
+  }
+  log(text) {
+    this.term ??= new terminalKit.Terminal();
+    this.term.blue(this.packageJson.name);
+    this.term.white(` ${text}
+`);
+  }
+  error(text) {
+    this.log(`^RERROR: ^w` + text.toString());
+  }
+  get entries() {
+    if (this._entries) return this._entries;
+    if (this.packageJson.exports && typeof this.packageJson.exports == "object") {
+      const result = [];
+      for (let item in this.packageJson.exports) {
+        if (!item.startsWith(".")) {
+          const exports = this.packageJson.exports;
+          const importFile2 = exports.default ?? exports.require ?? exports.import;
+          if (!importFile2 || !(typeof importFile2 === "string")) {
+            this.error(`Failed to read entry '${item}' in ${this.packageJson.name}`);
+            continue;
+          }
+          result.push(this.createEntry(".", importFile2));
+          break;
+        }
+        const importFile = this.packageJson.exports[item].default ?? this.packageJson.exports[item].import ?? this.packageJson.exports[item].require ?? this.packageJson.exports[item];
+        if (!importFile || !(typeof importFile === "string")) {
+          this.error(`Failed to read entry '${item}' in ${this.packageJson.name}`);
+          continue;
+        }
+        result.push(this.createEntry(item, importFile));
+      }
+      return this._entries = result;
+    }
+    const entry = this.packageJson.module ?? this.packageJson.main ?? this.packageJson.browser ?? this.packageJson.exports;
+    return this._entries = entry ? [
+      this.createEntry(".", entry)
+    ] : [];
+  }
+  /**
+   * @param name relative path inside pack: "", "/index.js", "/bundler"...
+   */
+  getEntry(name) {
+    return this.entries.find((x) => x.name === name);
+  }
+  createEntry(name, source) {
+    const absolute = resolve(this.rootDir, source);
+    name = name.replace(/^[.\/]+/, "");
+    return {
+      name,
+      source: absolute,
+      relative: source.replace(/^[.\/]+/, ""),
+      isExcluded: false,
+      isHTML: /\.html$/i.test(source),
+      output: this.getExport(name, source),
+      isTypeScript: /\.tsx?$/i.test(source),
+      isJavaScript: /\.jsx?$/i.test(source)
+    };
+  }
+  getExport(entry, file) {
+    const extension = file.match(/\.([^.]+)$/)[1];
+    const entryName = entry.replace(/^\.?\/?/, "").replace(/\.[^.]+$/, "") || "index";
+    const outExt = extension.replace(/^[jt]sx?$/, "js").replace(/^(less|css|sass|scss)$/, "css");
+    return `${entryName}.${outExt}`;
+  }
+  static {
+    this.ImportPrefix = "/_/";
+  }
+  get publicPath() {
+    return `${Pack.ImportPrefix}${this.name}`;
+  }
+}
+class ChangeEvent extends Event {
+  constructor(payload, from) {
+    super("change");
+    this.payload = payload;
+  }
+}
+class FileChangeEvent extends Event {
+  constructor(files) {
+    super("file"), this.files = files;
+  }
+}
+
+function getTSConfig(configPath) {
+    const result = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (result.error) {
+        return null;
+    }
+    if (result.config.extends) {
+        const extended = getTSConfig(path.resolve(path.dirname(configPath), result.config.extends)) ?? getTSConfig(fileURLToPath(import.meta.resolve(result.config.extends)));
+        const merged = merge([
+            extended,
+            result.config
+        ]);
+        return merged;
+    }
+    return result.config;
+}
+function merge(values) {
+    const keys = new Set(values.flatMap(Object.keys));
+    const result = {};
+    for (let key of keys){
+        const v = values.map((x)=>x[key]).filter((x)=>x !== undefined);
+        if (v.length === 0) result[key] = undefined;
+        else if (v.length === 1) result[key] = v[0];
+        else if (typeof v.at(-1) !== "object" || v.at(-1) === null || Array.isArray(v.at(-1))) result[key] = v.at(-1);
+        else result[key] = merge(v);
+    }
+    return result;
+}
+
+class Target extends Pack {
+    get publicPath() {
+        return this.packageJson.config?.publicPath ?? super.publicPath;
+    }
+    get tsConfig() {
+        return this._tsConfig ??= getTSConfig(join(this.rootDir, 'tsconfig.json'));
+    }
+    isExcluded(fileName, isRelative = false) {
+        if (!isRelative) fileName = relative(this.rootDir, fileName);
+        if (fileName.startsWith('./')) fileName = fileName.substring(2);
+        const check = (pattern)=>{
+            return fileName.startsWith(pattern) || minimatch(fileName, pattern);
+        };
+        const include = this.tsConfig.include ?? [];
+        if (include.length > 0) {
+            if (!include.some(check)) return true;
+        }
+        const exclude = this.tsConfig.exclude ?? [
+            'dist',
+            'node_modules'
+        ];
+        return exclude.some(check);
+    }
+    get swcConfigPath() {
+        const local = join(this.rootDir, '.swcrc');
+        if (fs.existsSync(local)) return local;
+        return fileURLToPath(import.meta.resolve('@cmmn/tools/swcrc'));
+    }
+    get swcConfig() {
+        this.swcConfigBase ??= JSON.parse(fs.readFileSync(this.swcConfigPath, {
+            encoding: 'utf-8'
+        }));
+        const tsConfig = this.tsConfig;
+        return this._swcConfig ??= {
+            ...this.swcConfigBase,
+            jsc: {
+                ...this.swcConfigBase.jsc,
+                baseUrl: this.rootDir,
+                paths: tsConfig.compilerOptions?.paths
+            },
+            module: {
+                type: 'es6',
+                strict: true,
+                strictMode: false,
+                resolveFully: true
+            },
+            sourceMaps: true,
+            inlineSourcesContent: false
+        };
+    }
+    async getPublishPackageJson() {
+        const packageJson = JSON.parse(JSON.stringify(this.packageJson));
+        for (let entry of this.entries){
+            if (entry.isHTML || entry.isExcluded) continue;
+            const typings = entry.isTypeScript ? './' + join('./dist/typings', relative(this.rootDir, entry.source.replace(/\.ts$/, '.d.ts'))) : undefined;
+            const bundle = `./dist/bundle/${entry.output}`;
+            if (packageJson.exports) {
+                packageJson.exports[entry.name ? "./" + entry.name : "."] = {
+                    default: bundle,
+                    typings
+                };
+            } else {
+                packageJson.main = bundle;
+                packageJson.typings = typings;
+            }
+        }
+        delete packageJson.module;
+        delete packageJson.browser;
+        delete packageJson.scripts;
+        delete packageJson.devDependencies;
+        if (!packageJson.files) packageJson.files = [
+            'dist'
+        ];
+        return JSON.stringify(packageJson, null, '\t');
+    }
+    createEntry(name, source) {
+        return {
+            ...super.createEntry(name, source),
+            isExcluded: this.isExcluded(source, true)
+        };
+    }
+    get https() {
+        const host = this.packageJson.config?.host;
+        if (!host) return null;
+        return {
+            host,
+            port: this.packageJson.config.port,
+            cert: join(this.rootDir, `dist/${host}.pem`),
+            key: join(this.rootDir, `dist/${host}-key.pem`)
+        };
+    }
+    get proxy() {
+        return this._proxy ??= Object.entries({
+            ...this.packageJson.config?.proxy ?? {}
+        }).map(([regex, replace])=>({
+                regex: new RegExp(regex),
+                replace
+            }));
+    }
+    constructor(...args){
+        super(...args), this.publicDir = join(this.rootDir, 'public');
+    }
+}
+
+class Resolver {
+    constructor(packs, flags){
+        this.packs = packs;
+        this.flags = flags;
+        this.basePath = '';
+        /**
+     * Resolve id to absolute path
+     * @param id - relative path: "react", "react/jsx-runtime.js", "loro-crdt/bundler", "loro-crdt/loro.wasm"...
+     * @param importer
+     * @param options
+     */ this.resolveId = (id, importer = null, options = null)=>{
+            if (options?.isEntry) return;
+            const pack = this.getPack(id);
+            if (!pack) return undefined;
+            return this.resolveInPack(pack.pack, pack.path, importer, options);
+        };
+    }
+    resolvePath(path, importer = null, options = null) {
+        const pack = this.getPack(path);
+        if (!pack) return undefined;
+        return this.resolveWithProxy(pack.pack, pack.path, importer, options) ?? pack;
+    }
+    resolveWithProxy(pack, path, importer = null, options = null) {
+        if (pack instanceof Target) {
+            for (let proxy of pack.proxy){
+                if (path.match(proxy.regex)) {
+                    path = path.replace(proxy.regex, proxy.replace);
+                    break;
+                }
+            }
+        }
+        return this.resolveInPack(pack, path, importer, options);
+    }
+    resolveInPack(pack, id, importer = null, options = null) {
+        if (options?.attributes?.resolve) {
+            return {
+                external: "absolute",
+                id: `${this.basePath}${pack.publicPath}`,
+                path: '',
+                entry: null,
+                pack
+            };
+        }
+        // id - absolute path inside pack: "", "/index.ts", "/src/page.html", "/bundler", "/loro.wasm"
+        const entry = pack.getEntry(id.replace(/^\//, ''));
+        if (!entry) {
+            return;
+        }
+        const resolved = !this.flags.production && pack instanceof Target ? entry.relative : entry.output;
+        return {
+            external: "absolute",
+            id: `${this.basePath}${pack.publicPath}/${resolved}`,
+            path: resolved,
+            entry,
+            pack
+        };
+    }
+    getPackNames() {
+        return this.packs.map((x)=>x.name);
+    }
+    getPack(id) {
+        if (id.startsWith(this.basePath)) id = id.substring(this.basePath.length);
+        for (const pack of this.packs){
+            if (pack.name == id) {
+                return {
+                    pack,
+                    path: ''
+                };
+            } else if (id.startsWith(pack.name + '/')) {
+                return {
+                    pack,
+                    path: id.substring(pack.name.length + 1)
+                };
+            } else if (id == pack.rootDir) {
+                return {
+                    pack,
+                    path: ''
+                };
+            } else if (id.startsWith(pack.rootDir)) {
+                return {
+                    pack,
+                    path: id.substring(pack.rootDir.length + 1)
+                };
+            } else if (id == pack.publicPath) {
+                return {
+                    pack,
+                    path: ''
+                };
+            } else if (id.startsWith(pack.publicPath + '/')) {
+                return {
+                    pack,
+                    path: id.substring(pack.publicPath.length + 1)
+                };
+            }
+        }
+    }
+}
+
+class Flags {
+    static{
+        this.Current = new Flags([]);
+    }
+    constructor(args){
+        this.args = args;
+        this.deploy = this.args.includes('--deploy');
+        this.out = this.args.includes('-out') ? this.args[this.args.indexOf('-out') + 1] : '.out';
+        this.command = args[0];
+        this.watch = args.includes('--watch');
+        this.minify = args.includes('--minify');
+        this.unsafe = args.includes('--unsafe');
+        this.workspace = args.includes('-w') ? args[args.indexOf('-w') + 1] ?? '.' : undefined;
+        this.version = this.command === 'version' ? args[1] : undefined;
+        this.production = args.includes('--prod');
+        if (this.workspace?.startsWith('--')) {
+            this.workspace = undefined;
+        }
+    }
+    get(arg) {
+        const index = this.args.indexOf(`--${arg}`);
+        if (index === -1) return undefined;
+        return this.args[index + 1];
+    }
+}
+
+class Bundle {
+    constructor(pack, output){
+        this.pack = pack;
+        this.output = output;
+    }
+    fileNames() {
+        return this.output.map((x)=>x.entry?.output ?? x.fileName);
+    }
+    get(id) {
+        return this.output.find((x)=>x.fileName == id || x.entry?.output == id)?.data;
+    }
+    async getPublicAsset(id) {
+        if (!(this.pack instanceof Target) || !this.pack.publicDir) {
+            return undefined;
+        }
+        return readFile(path.join(this.pack.publicDir, id));
+    }
+    async getBundleJson() {
+        return {
+            baseURI: this.pack.publicPath,
+            assets: [
+                ...await Promise.all(this.output.map((o)=>this.getOutputAsset(o)))
+            ]
+        };
+    }
+    async getOutputAsset(output) {
+        return {
+            path: output.entry?.output ?? output.fileName,
+            hash: await getHash(output.data),
+            size: output.data.length,
+            regex: output.entry && this.pack instanceof Target ? this.pack.proxy.find((x)=>x.replace == output.entry.name)?.regex.source : undefined,
+            deps: Object.fromEntries(this.getDeps(output))
+        };
+    }
+    *getDeps(output) {
+        const flat = output.deps.map((x)=>({
+                baseURI: x.pack === this.pack ? "." : x.pack.publicPath,
+                path: x.path
+            }));
+        if (typeof output.data === "string") {
+            for (let fileName of this.fileNames()){
+                if (output.data.includes(`new URL("${fileName}"`)) {
+                    flat.push({
+                        baseURI: ".",
+                        path: fileName
+                    });
+                }
+                if (output.data.includes(`import("./${fileName}"`)) {
+                    flat.push({
+                        baseURI: ".",
+                        path: fileName
+                    });
+                }
+            }
+        }
+        const grouped = Map.groupBy(flat, (x)=>x.baseURI);
+        for (let [uri, deps] of grouped){
+            yield [
+                uri,
+                Array.from(new Set(deps.map((x)=>x.path)))
+            ];
+        }
+    }
+}
+async function getHash(data) {
+    const buffer = Buffer.from(data);
+    const hash = await subtle.digest('SHA-1', buffer);
+    return Buffer.from(hash).toString('base64');
+}
+
+function wasm(options = {}) {
+    return {
+        name: 'wasm',
+        resolveId (id, importer) {
+            if (!/\.wasm$/.test(id)) return null;
+            const name = id.split('/').pop();
+            const moduleInfo = this.getModuleInfo(importer);
+            // @ts-ignore
+            moduleInfo.dynamicallyImportedIds.push(name);
+            // @ts-ignore
+            moduleInfo.importedIds.push(name);
+            return resolve(dirname(importer), id);
+        },
+        async load (id) {
+            if (!/\.wasm$/.test(id)) return null;
+            const name = id.split('/').pop();
+            let url = `new URL("./${name}?no-inline", import.meta.url)`;
+            if (options.emitAsset) {
+                const referenceId = this.emitFile({
+                    type: 'asset',
+                    source: await (this.fs ?? fs$1).readFile(id),
+                    name: options.assetName?.replace('{name}', name) ?? 'WASM Asset',
+                    fileName: name
+                });
+                url = `import.meta.ROLLUP_FILE_URL_${referenceId}`;
+            }
+            return {
+                map: {
+                    mappings: ''
+                },
+                code: [
+                    `const url = ${url};`,
+                    `const ab = await fetch(url).then(x => x.arrayBuffer())`,
+                    `export default new WebAssembly.Module(ab);`
+                ].join('\n')
+            };
+        }
+    };
+}
+
+function swcMinifyPlugin() {
+  return {
+    name: "custom-terser",
+    async renderChunk(code, chunk) {
+      if (!chunk.fileName.endsWith(".mjs") && !chunk.fileName.endsWith(".js")) {
+        return null;
+      }
+      const result = await minify(code, {
+        compress: {
+          defaults: false,
+          module: true,
+          hoist_props: true,
+          unused: true,
+          dead_code: true
+        },
+        ecma: 2016,
+        module: true,
+        format: {
+          comments: false,
+          ecma: 2016
+        }
+      });
+      return result.code || null;
+    }
+  };
+}
+
+class ViteBuilder {
+  constructor(target, resolver, flags) {
+    this.target = target;
+    this.resolver = resolver;
+    this.flags = flags;
+  }
+  async getConfig() {
+    return {
+      root: this.target.rootDir,
+      logLevel: "silent",
+      mode: this.flags.production ? "production" : "debug",
+      optimizeDeps: {
+        noDiscovery: true,
+        include: []
+      },
+      define: {
+        process: {
+          env: {
+            NODE_ENV: this.flags.production ? "production" : "development"
+          }
+        }
+      },
+      html: {},
+      base: this.target.publicPath + "/",
+      build: {
+        target: "baseline-widely-available",
+        emptyOutDir: false,
+        rollupOptions: {
+          external: [
+            ...this.resolver ? [] : this.target.deps.map((x) => new RegExp(`^${x.name}`.replace("/", "\\/"))),
+            ...builtinModules,
+            "fsevents",
+            /@id/g
+          ]
+        },
+        write: false,
+        minify: false,
+        sourcemap: this.flags.minify ? false : "inline",
+        commonjsOptions: {
+          transformMixedEsModules: true
+        }
+      },
+      plugins: [
+        ...this.getPlugins()
+      ]
+    };
+  }
+  *getPlugins() {
+    yield wasm();
+    yield swc.vite(this.target.swcConfig);
+    yield tsconfigPaths();
+    if (this.resolver) {
+      yield {
+        name: this.target.packageJson.name + ":resolver",
+        resolveId: this.resolver.resolveId,
+        enforce: "pre"
+      };
+    }
+    yield {
+      name: "cmmn:html-base-tag",
+      enforce: "pre",
+      transformIndexHtml: (_, config) => {
+        const dir = this.flags.production ? "" : dirname(config.path);
+        const result = [
+          {
+            tag: "base",
+            attrs: {
+              href: `${this.target.publicPath}${dir}/`
+            },
+            children: "/** injected **/"
+          }
+        ];
+        if (this.flags.production) {
+          result.push({
+            tag: "link",
+            attrs: {
+              rel: "manifest",
+              href: `${this.target.publicPath}/manifest.json`
+            }
+          });
+        }
+        return result;
+      }
+    };
+    if (this.flags.minify) yield swcMinifyPlugin();
+    yield {
+      name: "url-resolver",
+      enforce: "pre",
+      resolveId: (id, importer, options) => {
+        if (id.endsWith("?resolve")) {
+          const resolved = this.resolver?.resolveId(id.split("?")[0], importer, {
+            ...options,
+            attributes: {
+              ...options.attributes,
+              resolve: true
+            }
+          });
+          return resolved ? resolved.id + "?resolve" : id;
+        }
+      },
+      load: (id) => {
+        if (id.endsWith("?resolve")) {
+          return `export default ${JSON.stringify(id.split("?")[0])}`;
+        }
+      }
+    };
+  }
+}
+
+class ViteBundler extends ViteBuilder {
+    async getBundleConfig() {
+        const config = await this.getConfig();
+        config.build.lib = {
+            entry: Object.fromEntries(this.target.entries.filter((x)=>!x.isExcluded).map((x)=>[
+                    x.name,
+                    x.source
+                ])),
+            fileName: (format, entryName)=>{
+                if (entryName == '') entryName = 'index';
+                return entryName + '.js';
+            },
+            formats: [
+                'es'
+            ]
+        };
+        config.build.modulePreload = false;
+        return config;
+    }
+    async createBundle() {
+        if (!this.target.entries.length) return [];
+        const config = await this.getBundleConfig();
+        return build(config).catch((err)=>{
+            this.target.error(err.message);
+            return [];
+        });
+    }
+    async bundle() {
+        const rollupOutput = await this.createBundle();
+        const outputChunks = rollupOutput.flatMap((x)=>x.output);
+        const entryMap = new Map(this.target.entries.map((x)=>[
+                x.relative,
+                x
+            ]));
+        const outputs = outputChunks.map((x)=>{
+            return {
+                fileName: x.fileName,
+                entry: entryMap.get(x.fileName),
+                data: x.type == "asset" ? x.source : x.code,
+                deps: x.type == "asset" ? [] : [
+                    ...x.imports,
+                    ...x.dynamicImports
+                ].filter((x)=>!/^node:/.test(x)).map((path)=>path.replace(/^(\.\.\/)+/, '/')).map((path)=>this.resolver?.getPack(path) ?? {
+                        pack: this.target,
+                        path: path
+                    })
+            };
+        });
+        return new Bundle(this.target, outputs);
+    }
+}
+
+var define_process_default$1 = { env: { NODE_ENV: "production" } };
+class RolldownBundler {
+  constructor(pack, resolver, flags) {
+    this.pack = pack;
+    this.resolver = resolver;
+    this.flags = flags;
+    this.dir = path.join(define_process_default$1.cwd(), "./node_modules/.cmmn");
+  }
+  async getFileContent(entry) {
+    const target = entry.name ? `${this.pack.name}/${entry.name}` : `${this.pack.name}`;
+    if (this.pack.packageJson.type === "module") return `export * from '${target}';`;
+    const pkg = await import(target, entry.source.endsWith(".json") ? {
+      with: {
+        type: "json"
+      }
+    } : {});
+    const keys = Object.keys(pkg).filter((x) => x !== "default");
+    return [
+      `import * as result from '${target}';`,
+      `export const { ${keys.join(",")} } = result;`,
+      "default" in pkg ? "export default result.default;" : ""
+    ].join("\n");
+  }
+  async getInputs() {
+    const result = {
+      async [Symbol.asyncDispose]() {
+        for (let file of Object.values(this)) {
+          if (typeof file === "string") await fs$1.rm(file);
+        }
+      }
+    };
+    for (let entry of this.pack.entries) {
+      if (entry.source.match(/\.(d\.ts|css|scss|sass|less|styl|pcss|postcss|html)$/)) continue;
+      if (entry.source.includes("*")) continue;
+      const id = crc32(entry.name + /* @__PURE__ */ new Date() + Math.random());
+      const file = `${this.dir}/.${id}.js`;
+      const content = await this.getFileContent(entry);
+      await fs$1.mkdir(this.dir, {
+        recursive: true
+      });
+      await fs$1.writeFile(file, content, "utf-8");
+      result[entry.name] = file;
+    }
+    return result;
+  }
+  getConfig() {
+    return {
+      write: false,
+      output: {
+        format: "esm"
+      },
+      define: {
+        "process.env.NODE_ENV": this.flags.production ? '"production"' : '"development"'
+      },
+      experimental: {},
+      platform: "browser",
+      resolve: {
+        mainFields: [
+          "browser",
+          "module",
+          "main"
+        ]
+      },
+      optimization: {
+        inlineConst: this.flags.minify
+      },
+      treeshake: true,
+      plugins: [
+        ...this.getPlugins()
+      ]
+    };
+  }
+  // TODO: Filter hook https://rolldown.rs/in-depth/why-plugin-hook-filter#when-to-use-filters
+  *getPlugins() {
+    yield wasm({
+      emitAsset: true,
+      assetName: `{name}`
+    });
+    yield {
+      name: "require",
+      load: (id) => {
+        const prefix = "builtin:esm-external-require-";
+        if (id.startsWith(prefix)) {
+          const resolved = this.resolver.resolveId(id.substring(prefix.length), null, null);
+          if (resolved) return `export * from "${resolved.id}"`;
+        }
+      }
+    };
+    yield {
+      name: "externals",
+      resolveId: (id, importer, options) => {
+        if (options.kind === "require-call") return;
+        const resolved = this.resolver.resolveId(id, importer, options);
+        if (resolved && resolved.pack !== this.pack) return resolved;
+      }
+    };
+    yield esmExternalRequirePlugin({
+      external: this.resolver.getPackNames().filter((x) => x !== this.pack.name)
+    });
+    if (this.flags.minify) yield swcMinifyPlugin();
+  }
+  async bundle() {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const input = _(env, await this.getInputs(), true);
+      if (Object.keys(input).length == 0) return new Bundle(this.pack, []);
+      const { build } = await import('rolldown');
+      const config = this.getConfig();
+      const result = await build({
+        ...config,
+        input
+      }).catch((err) => {
+        this.pack.error(err.message);
+        return {
+          output: []
+        };
+      });
+      const outputs = result.output.map((x) => ({
+        fileName: x.fileName,
+        entry: this.pack.getEntry(x.name),
+        data: x.type == "asset" ? x.source : x.code,
+        deps: x.type == "asset" ? [] : [
+          ...x.imports,
+          ...x.dynamicImports
+        ].map((path2) => this.resolver.getPack(path2) ?? {
+          pack: this.pack,
+          path: path2
+        })
+      }));
+      return new Bundle(this.pack, outputs);
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
+    } finally {
+      const result = _$1(env);
+      if (result) await result;
+    }
+  }
+}
+
+var define_process_default = { env: { NODE_ENV: "production" } };
+class Monorepo {
+  static async load(flags = new Flags([]), rootDir = define_process_default.cwd()) {
+    const monorepoPackages = await getPackages(rootDir);
+    const monorepo = new MonorepoLoader(monorepoPackages);
+    await monorepo.load(flags.production);
+    return new Monorepo(monorepo.root, monorepo.packs, flags);
+  }
+  constructor(root, packsMap, flags) {
+    this.root = root;
+    this.packsMap = packsMap;
+    this.flags = flags;
+    this.packs = Array.from(this.packsMap.values());
+    if (flags.deploy) this.resolver = new Resolver(this.packs, this.flags);
+    this.packs.forEach((x) => x.init(flags, this.packsMap));
+    root.init(flags, this.packsMap);
+  }
+  get targets() {
+    return Array.from(this.packs.values()).filter((x) => x instanceof Target);
+  }
+  get(id) {
+    return this.packsMap.get(id);
+  }
+  createBundler(pack) {
+    if (pack instanceof Target) return new ViteBundler(pack, this.resolver, this.flags);
+    return new RolldownBundler(pack, this.resolver, this.flags);
+  }
+}
+class MonorepoLoader {
+  constructor(packages) {
+    this.packages = packages;
+    this.packs = /* @__PURE__ */ new Map();
+  }
+  async load(prod) {
+    for (let p of this.packages.packages) {
+      await this.export(p.packageJson.name, p.packageJson.version, prod);
+    }
+    this.root = await this.export(this.packages.rootPackage.packageJson.name, this.packages.rootPackage.packageJson.version, prod);
+    return Array.from(this.packs.values());
+  }
+  async export(name, version, prod) {
+    if (this.packs.has(name)) return this.packs.get(name);
+    const pkg = this.getPackage(name);
+    if (pkg) {
+      const pack = new Target(pkg.dir, pkg.packageJson);
+      this.packs.set(name, pack);
+      for (let [name2, version2] of pack.getAllDependencies(prod)) {
+        if (this.packs.has(name2)) continue;
+        await this.export(name2, version2, prod);
+      }
+      return pack;
+    } else {
+      const pack = await Pack.read(name, version);
+      this.packs.set(name, pack);
+      return pack;
+    }
+  }
+  getPackage(name) {
+    const p = this.packages.rootPackage.packageJson.name == name ? this.packages.rootPackage : this.packages.packages.find((x) => x.packageJson.name == name);
+    return p && {
+      dir: p.dir,
+      packageJson: p.packageJson,
+      version: p.packageJson.version
+    };
+  }
+}
+
+export { Flags, Monorepo };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","sources":["../model/pack.ts","../helpers/getTSConfig.ts","../model/target.ts","../model/resolver.ts","../model/flags.ts","../model/bundle.ts","../bundlers/plugins/wasm.ts","../bundlers/plugins/minify.ts","../bundlers/vite.builder.ts","../bundlers/vite.bundler.ts","../bundlers/rolldown-bundler.ts","../model/monorepo.ts"],"sourcesContent":["import {JSONSchemaForNPMPackageJsonFiles} from \"@schemastore/package\";\nimport {dirname, join, resolve} from \"node:path\";\nimport {Flags} from \"./flags\";\nimport terminalKit from \"terminal-kit\";\nimport {readFile, stat} from \"node:fs/promises\";\n\nexport class Pack extends EventTarget {\n    static async read(id: string, version?: string, dir = process.cwd()) {\n        while (dir) {\n            try {\n                const pkgDir = join(dir, 'node_modules', id);\n                if (await stat(pkgDir)) {\n                    const json = JSON.parse(await readFile(join(pkgDir, \"package.json\"), {encoding: 'utf-8'})) as JSONSchemaForNPMPackageJsonFiles;\n                    // TODO: check version\n                    // if (version && json.version !== version)\n                    //     dir = dirname(dir);\n                    // else\n                    return new Pack(pkgDir, json);\n                }\n            } catch {\n                dir = dirname(dir);\n            }\n        }\n    }\n\n    public* getAllDependencies(prod: boolean) {\n        yield* Object.entries(this.packageJson.dependencies ?? {});\n        if (!prod)\n            yield* Object.entries(this.packageJson.devDependencies ?? {});\n    }\n\n    deps: Pack[];\n    reactions: Pack[] = [];\n\n    constructor(public readonly rootDir,\n                public readonly packageJson: JSONSchemaForNPMPackageJsonFiles) {\n        super();\n    }\n\n    public init(flags: Flags, packsMap: Map<string, Pack>) {\n        const deps = Object.keys(this.packageJson.dependencies ?? {});\n        if (!flags.production)\n            deps.push(...Object.keys(this.packageJson.devDependencies ?? {}));\n        this.deps = deps.map(x => packsMap.get(x)).filter(x => !!x) as Pack[];\n        this.deps.forEach(x => x.reactions.push(this));\n        for (let dep of this.deps) {\n            dep.addEventListener('change', (e: ChangeEvent) => {\n                // TODO: prevent cycles\n                this.dispatchEvent(new ChangeEvent(e.payload, e.from));\n            });\n            dep.addEventListener('file', (e: FileChangeEvent) => {\n                // TODO: prevent cycles\n                this.dispatchEvent(new FileChangeEvent([]));\n            });\n        }\n    }\n\n    public get isServer() {\n        return !!this.packageJson.config?.server;\n    }\n\n    public get name() {\n        return this.packageJson.name;\n    }\n\n    term;\n\n    log(text) {\n        this.term ??= new terminalKit.Terminal();\n        this.term.blue(this.packageJson.name);\n        this.term.white(` ${text}\\n`);\n    }\n\n    error(text) {\n        this.log(`^RERROR: ^w` + text.toString());\n    }\n\n    _entries: Entry[]\n    get entries(): Entry[] {\n        if (this._entries) return this._entries;\n        if (this.packageJson.exports && typeof this.packageJson.exports == \"object\") {\n            const result = [] as Entry[];\n            for (let item in this.packageJson.exports) {\n                if (!item.startsWith('.')) {\n                    const exports = this.packageJson.exports as any;\n                    const importFile = exports.default ?? exports.require ?? exports.import;\n                    if (!importFile || !(typeof importFile === \"string\")) {\n                        this.error(`Failed to read entry '${item}' in ${this.packageJson.name}`)\n                        continue;\n                    }\n                    result.push(this.createEntry('.', importFile));\n                    break;\n                }\n                const importFile = this.packageJson.exports[item].default ??\n                    this.packageJson.exports[item].import ??\n                    this.packageJson.exports[item].require ?? this.packageJson.exports[item];\n                if (!importFile || !(typeof importFile === \"string\")) {\n                    this.error(`Failed to read entry '${item}' in ${this.packageJson.name}`)\n                    continue;\n                }\n                result.push(this.createEntry(item, importFile));\n            }\n            return this._entries = result;\n        }\n        const entry = this.packageJson.module\n            ?? this.packageJson.main\n            ?? this.packageJson.browser\n            ?? this.packageJson.exports as string\n        return this._entries = entry ? [this.createEntry('.', entry)] : [];\n    }\n\n    /**\n     * @param name relative path inside pack: \"\", \"/index.js\", \"/bundler\"...\n     */\n    getEntry(name: string): Entry | undefined {\n        return this.entries.find(x => x.name === name);\n    }\n\n    protected createEntry(name: string, source: string): Entry {\n        const absolute = resolve(this.rootDir, source);\n        name = name.replace(/^[.\\/]+/, '');\n        return {\n            name,\n            source: absolute,\n            relative: source.replace(/^[.\\/]+/, ''),\n            isExcluded: false,\n            isHTML: /\\.html$/i.test(source),\n            output: this.getExport(name, source),\n            isTypeScript: /\\.tsx?$/i.test(source),\n            isJavaScript: /\\.jsx?$/i.test(source)\n        }\n    }\n\n    getExport(entry: string, file: string) {\n        const extension = file.match(/\\.([^.]+)$/)[1];\n        const entryName = entry\n            .replace(/^\\.?\\/?/, '')\n            .replace(/\\.[^.]+$/, '') || 'index';\n        const outExt = extension\n            .replace(/^[jt]sx?$/, 'js')\n            .replace(/^(less|css|sass|scss)$/, 'css')\n        return `${entryName}.${outExt}`;\n    }\n\n    private static ImportPrefix: string = '/_/';\n\n    get publicPath(): string {\n        return `${Pack.ImportPrefix}${this.name}`;\n    }\n\n}\n\nexport class ChangeEvent extends Event {\n    payload;\n    from;\n\n    constructor(payload, from) {\n        super('change');\n        this.payload = payload;\n    }\n}\n\nexport class FileChangeEvent extends Event {\n    constructor(public files: string[]) {\n        super('file');\n    }\n\n}\n\nexport type Entry = {\n    name: string;\n    source: string;\n    relative: string;\n    isHTML: boolean;\n    isExcluded: boolean;\n    output: string;\n    isTypeScript: boolean;\n    isJavaScript: boolean;\n    // compiledPath: string;\n    // typingsPath: string;\n}","import ts, {CompilerOptions} from \"typescript\";\nimport path from \"node:path\";\nimport {fileURLToPath} from \"node:url\";\n\nexport function getTSConfig(configPath: string) {\n\tconst result = ts.readConfigFile(configPath, ts.sys.readFile);\n\tif (result.error) {\n\t\treturn null;\n\t}\n\tif (result.config.extends){\n\t\tconst extended = getTSConfig(path.resolve(path.dirname(configPath), result.config.extends)) ??\n\t\t\tgetTSConfig(fileURLToPath(import.meta.resolve(result.config.extends)));\n\t\tconst merged = merge([extended, result.config]);\n\t\treturn  merged;\n\t}\n\treturn result.config;\n}\n\nexport type TypescriptConfig = {\n\textends?: string;\n\tcompilerOptions?: CompilerOptions;\n\texclude?: string[];\n\tinclude?: string[];\n\treferences?: Array<{ path: string; }>\n}\n\nfunction merge(values: object[]){\n\tconst keys = new Set(values.flatMap(Object.keys));\n\tconst result = {};\n\tfor (let key of keys) {\n\t\tconst v = values.map(x => x[key as any]).filter(x => x !== undefined);\n\t\tif (v.length === 0)\n\t\t\tresult[key as any] = undefined;\n\t\telse if (v.length === 1)\n\t\t\tresult[key as any] = v[0];\n\t\telse if (typeof v.at(-1) !== \"object\" || v.at(-1) === null || Array.isArray(v.at(-1)))\n\t\t\tresult[key as any] = v.at(-1)\n\t\telse\n\t\t\tresult[key as any] = merge(v);\n\t}\n\treturn result;\n}","import {join, relative} from \"node:path\";\nimport fs from \"node:fs\";\nimport {fileURLToPath} from \"node:url\";\nimport {getTSConfig, TypescriptConfig} from \"../helpers/getTSConfig.js\";\nimport {Flags} from \"./flags\";\nimport {Config} from \"@swc/core\";\nimport {minimatch} from 'minimatch';\nimport {Entry, Pack} from \"./pack\";\n\nexport class Target extends Pack {\n    public readonly publicDir = join(this.rootDir, 'public');\n\n    get publicPath(): string | undefined {\n        return this.packageJson.config?.publicPath as string ?? super.publicPath;\n    }\n\n    _tsConfig: TypescriptConfig;\n    get tsConfig(): TypescriptConfig {\n        return this._tsConfig ??= getTSConfig(join(this.rootDir, 'tsconfig.json'));\n    }\n\n    isExcluded(fileName: string, isRelative: boolean = false) {\n        if (!isRelative)\n            fileName = relative(this.rootDir, fileName);\n        if (fileName.startsWith('./'))\n            fileName = fileName.substring(2);\n        const check = (pattern: string) => {\n            return fileName.startsWith(pattern) || minimatch(fileName, pattern);\n        };\n        const include = this.tsConfig.include ?? [];\n        if (include.length > 0) {\n            if (!include.some(check))\n                return true;\n        }\n        const exclude = this.tsConfig.exclude ?? ['dist', 'node_modules'];\n        return exclude.some(check);\n    }\n\n    get swcConfigPath(){\n        const local = join(this.rootDir, '.swcrc');\n        if (fs.existsSync(local))\n            return local;\n        return fileURLToPath(import.meta.resolve('@cmmn/tools/swcrc'));\n    }\n    swcConfigBase;\n\n    _swcConfig: Config;\n    get swcConfig(): Config {\n        this.swcConfigBase ??= JSON.parse(fs.readFileSync(this.swcConfigPath, {\n            encoding: 'utf-8'\n        }));\n        const tsConfig = this.tsConfig;\n        return this._swcConfig ??= {\n            ...this.swcConfigBase,\n            jsc: {\n                ...this.swcConfigBase.jsc,\n                baseUrl: this.rootDir,\n                paths: tsConfig.compilerOptions?.paths,\n            },\n            module: {\n                type: 'es6',\n                strict: true,\n                strictMode: false,\n\n                resolveFully: true\n            },\n            sourceMaps: true,\n            inlineSourcesContent: false\n        };\n    }\n\n\n\n    async getPublishPackageJson() {\n        const packageJson = JSON.parse(JSON.stringify(this.packageJson));\n        for (let entry of this.entries) {\n            if (entry.isHTML || entry.isExcluded) continue;\n            const typings = entry.isTypeScript ? './' + join('./dist/typings', relative(this.rootDir, entry.source.replace(/\\.ts$/, '.d.ts'))) : undefined;\n            const bundle = `./dist/bundle/${entry.output}`;\n            if (packageJson.exports) {\n                packageJson.exports[entry.name ? \"./\" + entry.name : \".\"] = {default: bundle, typings};\n            } else {\n                packageJson.main = bundle;\n                packageJson.typings = typings;\n            }\n        }\n        delete packageJson.module;\n        delete packageJson.browser;\n        delete packageJson.scripts;\n        delete packageJson.devDependencies;\n        if (!packageJson.files)\n            packageJson.files = ['dist'];\n        return JSON.stringify(packageJson, null, '\\t');\n    }\n\n    protected createEntry(name: string, source: string): Entry {\n        return {\n            ...super.createEntry(name, source),\n            isExcluded: this.isExcluded(source, true)\n        };\n    }\n\n    get https() {\n        const host = this.packageJson.config?.host;\n        if (!host) return null;\n        return {\n            host,\n            port: this.packageJson.config.port,\n            cert: join(this.rootDir, `dist/${host}.pem`),\n            key: join(this.rootDir, `dist/${host}-key.pem`),\n        }\n    }\n\n    _proxy;\n    get proxy(): Array<{ regex: RegExp; replace }> {\n        return this._proxy ??= Object.entries({\n            ...this.packageJson.config?.proxy as any ?? {},\n        })\n            .map(([regex, replace]) => ({\n                regex: new RegExp(regex),\n                replace\n            }));\n    }\n\n}","import {Pack} from \"./pack\";\nimport {Flags} from \"./flags\";\nimport {Target} from \"./target\";\n\nexport class Resolver {\n    basePath: string = '';\n    constructor(private readonly packs: Pack[], private flags: Flags) {\n    }\n\n    /**\n     * Resolve id to absolute path\n     * @param id - relative path: \"react\", \"react/jsx-runtime.js\", \"loro-crdt/bundler\", \"loro-crdt/loro.wasm\"...\n     * @param importer\n     * @param options\n     */\n    public resolveId = (id: string, importer: string = null, options = null) => {\n        if (options?.isEntry) return;\n        const pack = this.getPack(id);\n        if (!pack) return undefined;\n        return this.resolveInPack(pack.pack, pack.path, importer, options);\n    }\n\n    public resolvePath(path: string, importer: string = null, options = null){\n        const pack = this.getPack(path);\n        if (!pack) return undefined;\n        return this.resolveWithProxy(pack.pack, pack.path, importer, options) ?? pack;\n    }\n\n    private resolveWithProxy(pack: Pack, path: string, importer: string = null, options: any = null){\n        if (pack instanceof Target) {\n            for (let proxy of pack.proxy) {\n                if (path.match(proxy.regex)) {\n                    path = path.replace(proxy.regex, proxy.replace);\n                    break\n                }\n            }\n        }\n        return this.resolveInPack(pack, path, importer, options);\n    }\n\n    public resolveInPack(pack: Pack, id: string, importer: string = null, options: any = null){\n        if(options?.attributes?.resolve){\n            return {\n                external: \"absolute\" as boolean | \"absolute\" | \"relative\",\n                id: `${this.basePath}${pack.publicPath}`,\n                path: '',\n                entry: null,\n                pack\n            }\n        }\n        // id - absolute path inside pack: \"\", \"/index.ts\", \"/src/page.html\", \"/bundler\", \"/loro.wasm\"\n        const entry = pack.getEntry(id.replace(/^\\//,''));\n        if (!entry) {\n            return;\n        }\n        const resolved = (!this.flags.production && pack instanceof Target)\n            ? entry.relative : entry.output;\n        return {\n            external: \"absolute\" as boolean | \"absolute\" | \"relative\",\n            id: `${this.basePath}${pack.publicPath}/${resolved}`,\n            path: resolved,\n            entry,\n            pack\n        }\n    }\n\n    getPackNames() {\n        return this.packs.map(x => x.name);\n    }\n\n    public getPack(id: string): { pack: Pack, path: string } | undefined{\n        if (id.startsWith(this.basePath))\n            id = id.substring(this.basePath.length);\n        for (const pack of this.packs) {\n            if (pack.name == id) {\n                return { pack, path: '' };\n            } else if (id.startsWith(pack.name + '/')) {\n                return { pack, path: id.substring(pack.name.length + 1) };\n            } else if (id == pack.rootDir) {\n                return { pack, path: '' };\n            } else if (id.startsWith(pack.rootDir)) {\n                return { pack, path: id.substring(pack.rootDir.length + 1) };\n            } else if (id == pack.publicPath) {\n                return { pack, path: '' };\n            } else if (id.startsWith(pack.publicPath + '/')) {\n                return { pack, path: id.substring(pack.publicPath.length + 1) };\n            }\n        }\n    }\n}","\nexport class Flags {\n    static Current: Flags = new Flags([]);\n    watch?: boolean;\n    minify?: boolean;\n    workspace?: string;\n    unsafe?: boolean;\n    version?: string;\n    command?: string;\n    production?: boolean;\n    deploy? = this.args.includes('--deploy');\n    out = this.args.includes('-out')\n        ? this.args[this.args.indexOf('-out') + 1]\n        : '.out';\n\n    constructor(public args?: string[]) {\n        this.command = args[0];\n        this.watch = args.includes('--watch');\n        this.minify = args.includes('--minify');\n        this.unsafe = args.includes('--unsafe');\n        this.workspace = args.includes('-w')\n            ? args[args.indexOf('-w') + 1] ?? '.' : undefined;\n        this.version = this.command === 'version' ? args[1] : undefined\n        this.production = args.includes('--prod');\n        if (this.workspace?.startsWith('--')){\n            this.workspace = undefined;\n        }\n    }\n\n    get(arg) {\n        const index = this.args.indexOf(`--${arg}`);\n        if (index === -1) return undefined;\n        return this.args[index + 1];\n    }\n}","import {Entry, Pack} from \"./pack\";\nimport {Target} from \"./target\";\nimport {readFile} from \"node:fs/promises\";\nimport path from \"node:path\";\nimport {subtle} from \"crypto\";\nimport {string} from \"fast-glob/out/utils\";\n\nexport class Bundle {\n    constructor(private pack: Pack, private output: Output[]) {\n    }\n\n    fileNames(){\n        return this.output.map(x => x.entry?.output ?? x.fileName);\n    }\n\n    get(id: string){\n        return this.output.find(x => x.fileName == id || x.entry?.output == id)?.data;\n    }\n\n    async getPublicAsset(id: string){\n        if (!(this.pack instanceof Target) || !this.pack.publicDir) {\n            return undefined;\n        }\n        return readFile(path.join(this.pack.publicDir, id))\n    }\n\n    async getBundleJson(): Promise<BundleJson>{\n        return {\n            baseURI: this.pack.publicPath,\n            assets: [\n                ...(await Promise.all(this.output.map(o => this.getOutputAsset(o)))),\n            ],\n        }\n    }\n\n    private async getOutputAsset(output: Output): Promise<Asset> {\n        return {\n            path: output.entry?.output ?? output.fileName,\n            hash: await getHash(output.data),\n            size: output.data.length,\n            regex: output.entry && this.pack instanceof Target\n                ? this.pack.proxy.find(x => x.replace == output.entry.name)?.regex.source\n                : undefined,\n            deps: Object.fromEntries(this.getDeps(output)),\n        }\n    }\n\n    private *getDeps(output: Output): Generator<[string, string[]]>{\n        const flat = output.deps.map(x => ({\n            baseURI: x.pack === this.pack ? \".\" : x.pack.publicPath,\n            path: x.path\n        }));\n        if (typeof output.data === \"string\"){\n            for (let fileName of this.fileNames()) {\n                if (output.data.includes(`new URL(\"${fileName}\"`)) {\n                    flat.push({ baseURI: \".\", path: fileName });\n                }\n                if (output.data.includes(`import(\"./${fileName}\"`)) {\n                    flat.push({ baseURI: \".\", path: fileName });\n                }\n            }\n        }\n\n        const grouped = Map.groupBy(flat, x => x.baseURI);\n        for (let [uri, deps] of grouped) {\n            yield [uri, Array.from(new Set(deps.map(x => x.path)))];\n        }\n    }\n}\n\nexport async function getHash(data: string | Uint8Array) {\n    const buffer = Buffer.from(data);\n    const hash = await subtle.digest('SHA-1', buffer);\n    return Buffer.from(hash).toString('base64');\n}\n\nexport type Output = {\n    entry?: Entry;\n    fileName: string;\n    data: string | Uint8Array;\n    deps: Array<{\n        pack: Pack;\n        path: string;\n    }>\n}\nexport type BundleJson = {\n    baseURI: string;\n    assets: Asset[];\n}\nexport type Asset = {\n    path: string;\n    regex?: string;\n    hash: string;\n    size: number;\n    optional?: boolean;\n    deps: Record<string, string[]>;\n}","import fs from \"node:fs/promises\";\nimport {Plugin} from \"vite\";\nimport {dirname, resolve} from \"node:path\";\n\nexport function wasm(options: {\n\temitAsset?: boolean\n\tassetName?: string\n} = {}): Plugin{\n\treturn {\n\t\tname: 'wasm',\n        resolveId(id, importer){\n            if (!/\\.wasm$/.test(id)) return null;\n            const name = id.split('/').pop();\n            const moduleInfo = this.getModuleInfo(importer);\n            // @ts-ignore\n            moduleInfo.dynamicallyImportedIds.push(name);\n            // @ts-ignore\n            moduleInfo.importedIds.push(name);\n            return resolve(dirname(importer), id);\n        },\n\t\tasync load(id) {\n\t\t\tif (!/\\.wasm$/.test(id)) return null;\n\t\t\tconst name = id.split('/').pop();\n            let url =`new URL(\"./${name}?no-inline\", import.meta.url)`;\n\t\t\tif (options.emitAsset) {\n                const referenceId = this.emitFile({\n\t\t\t\t\ttype: 'asset',\n\t\t\t\t\tsource: await (this.fs ?? fs).readFile(id),\n\t\t\t\t\tname: options.assetName?.replace('{name}', name) ?? 'WASM Asset',\n\t\t\t\t\tfileName: name,\n\t\t\t\t});\n                url = `import.meta.ROLLUP_FILE_URL_${referenceId}`;\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tmap: {\n\t\t\t\t\tmappings: ''\n\t\t\t\t},\n\n\t\t\t\tcode: [\n\t\t\t\t\t`const url = ${url};`,\n\t\t\t\t\t`const ab = await fetch(url).then(x => x.arrayBuffer())`,\n\t\t\t\t\t`export default new WebAssembly.Module(ab);`\n\t\t\t\t].join('\\n')\n\t\t\t}\n\t\t}\n\t}\n};\n","import {minify} from \"@swc/core\";\nimport { Plugin } from \"vite\";\n\n/**\n * Custom plugin to apply terser during the bundle generation. Vite doesn't minify library ES\n * modules.\n */\nexport function swcMinifyPlugin(): Plugin {\n\treturn {\n\t\tname: 'custom-terser',\n\t\tasync renderChunk(code, chunk) {\n\t\t\t// Only process JavaScript chunks\n\t\t\tif (!chunk.fileName.endsWith('.mjs') && !chunk.fileName.endsWith('.js')) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Keep the result readable for debugging\n\t\t\tconst result = await minify(code, {\n\t\t\t\tcompress: {\n\t\t\t\t\tdefaults: false,\n\t\t\t\t\tmodule: true,\n\t\t\t\t\thoist_props: true,\n\t\t\t\t\tunused: true,\n\t\t\t\t\tdead_code: true,\n\t\t\t\t},\n\t\t\t\tecma: 2016,\n\t\t\t\tmodule: true,\n\t\t\t\tformat: {\n\t\t\t\t\tcomments: false,\n\t\t\t\t\tecma: 2016\n\t\t\t\t},\n\t\t\t});\n\n\t\t\treturn result.code || null;\n\t\t},\n\t};\n}","import {Target} from \"../model/target\";\nimport {Resolver} from \"../model/resolver\";\nimport {HtmlTagDescriptor, IndexHtmlTransformContext, InlineConfig, Plugin} from \"vite\";\nimport builtinModules from \"builtin-modules\";\nimport {wasm} from \"./plugins/wasm\";\nimport swc from \"unplugin-swc\";\nimport tsconfigPaths from \"vite-tsconfig-paths\";\nimport {dirname} from \"node:path\";\nimport {swcMinifyPlugin} from \"./plugins/minify\";\nimport {Flags} from \"../model/flags\";\n\nexport class ViteBuilder {\n    constructor(protected readonly target: Target,\n                protected readonly resolver: Resolver,\n                protected readonly flags: Flags) {\n\n    }\n\n    async getConfig(): Promise<InlineConfig> {\n        return {\n            root: this.target.rootDir,\n            logLevel: 'silent',\n            mode: this.flags.production ? \"production\" : 'debug',\n            optimizeDeps: {\n                noDiscovery: true,\n                include: []\n            },\n            define: {\n                process: {\n                    env: {\n                        NODE_ENV: this.flags.production ? 'production' : 'development'\n                    }\n                }\n            },\n            html: {},\n            base: this.target.publicPath + '/',\n            build: {\n                target: 'baseline-widely-available',\n                emptyOutDir: false,\n                rollupOptions: {\n                    external: [\n                        ...(this.resolver ? [] : this.target.deps.map(x =>\n                            new RegExp(`^${x.name}`.replace('/', '\\\\/'))\n                        )),\n                        ...builtinModules,\n                        'fsevents',\n                        /@id/g,\n                    ],\n                },\n                write: false,\n                minify: false,\n                sourcemap: this.flags.minify ? false : 'inline',\n                commonjsOptions: {\n                    transformMixedEsModules: true\n                },\n            },\n            plugins: [...this.getPlugins()],\n        };\n    }\n\n    * getPlugins(): Generator<Plugin> {\n        yield wasm();\n        yield swc.vite(this.target.swcConfig) as unknown as Plugin;\n        yield tsconfigPaths();\n        if (this.resolver) {\n            yield {\n                name: this.target.packageJson.name + ':resolver',\n                resolveId: this.resolver.resolveId,\n                enforce: 'pre',\n            };\n        }\n        yield {\n            name: \"cmmn:html-base-tag\",\n            enforce: 'pre',\n            transformIndexHtml: (_, config: IndexHtmlTransformContext) => {\n                const dir = this.flags.production ? '' : dirname(config.path);\n                const result: HtmlTagDescriptor[] = [\n                    {\n                        tag: \"base\",\n                        attrs: {href: `${this.target.publicPath}${dir}/`},\n                        children: '/** injected **/'\n                    }\n                ];\n                if (this.flags.production) {\n                    result.push({\n                        tag: \"link\",\n                        attrs: {\n                            rel: 'manifest',\n                            href: `${this.target.publicPath}/manifest.json`\n                        }\n                    });\n                }\n                return result;\n            },\n        }\n        if (this.flags.minify)\n            yield swcMinifyPlugin();\n        yield {\n            name: \"url-resolver\",\n            enforce: 'pre',\n            resolveId: (id, importer, options) => {\n                if (id.endsWith('?resolve')){\n                    const resolved = this.resolver?.resolveId(id.split('?')[0], importer, {\n                        ...options,\n                        attributes: {\n                            ...options.attributes,\n                            resolve: true,\n                        }\n                    });\n                    return resolved ? resolved.id + '?resolve' : id;\n                }\n            },\n            load: (id) => {\n                if (id.endsWith('?resolve')){\n                    return `export default ${JSON.stringify(id.split('?')[0])}`;\n                }\n            }\n        }\n        // yield analyzer();\n    }\n\n}\n","import {\n    build,\n    InlineConfig,\n} from \"vite\";\nimport {RollupOutput} from \"rollup\";\nimport {IBundler} from \"./types\";\nimport {Bundle, Output} from \"../model/bundle\";\nimport {ViteBuilder} from \"./vite.builder\";\n\nexport class ViteBundler extends ViteBuilder implements IBundler {\n\n    async getBundleConfig(): Promise<InlineConfig>{\n        const config = await this.getConfig();\n        config.build.lib = {\n            entry: Object.fromEntries(this.target.entries\n                .filter(x => !x.isExcluded)\n                .map(x => [x.name, x.source])) as any,\n            fileName: (format, entryName) => {\n                if (entryName == '') entryName = 'index';\n                return entryName + '.js';\n            },\n            formats: ['es'],\n        };\n        config.build.modulePreload = false;\n        return config;\n    }\n\n    private async createBundle(): Promise<RollupOutput[]> {\n        if (!this.target.entries.length)\n            return [];\n        const config = await this.getBundleConfig();\n        return build(config).catch(err => {\n            this.target.error(err.message);\n            return [];\n        }) as Promise<RollupOutput[]>;\n    }\n    public async bundle(): Promise<Bundle>{\n        const rollupOutput = await this.createBundle()\n        const outputChunks = rollupOutput.flatMap(x => x.output);\n        const entryMap = new Map(this.target.entries.map(x => [x.relative, x]))\n        const outputs = outputChunks.map(x => {\n            return {\n                fileName: x.fileName,\n                entry: entryMap.get(x.fileName),\n                data:  x.type == \"asset\" ? x.source : x.code,\n                deps: x.type == \"asset\" ? [] : [\n                    ...x.imports,\n                    ...x.dynamicImports\n                ].filter(x => !/^node:/.test(x)).map(path => path.replace(/^(\\.\\.\\/)+/,'/')).map(path => this.resolver?.getPack(path) ?? {\n                    pack: this.target,\n                    path: path\n                })\n            } as Output\n        });\n        return new Bundle(this.target, outputs);\n    }\n\n}\n","import {crc32} from \"node:zlib\";\nimport fs from \"node:fs/promises\";\nimport {wasm} from \"./plugins/wasm\";\nimport {swcMinifyPlugin} from \"./plugins/minify\";\nimport path, {join} from \"node:path\";\nimport {Bundle, Output} from \"../model/bundle\";\nimport {Entry, Pack} from \"../model/pack\";\nimport {Resolver} from \"../model/resolver\";\nimport {Flags} from \"../model/flags\";\nimport {BuildOptions} from \"rolldown\";\nimport {esmExternalRequirePlugin} from \"rolldown/experimental\";\nimport {IBundler} from \"./types\";\nimport {Plugin} from \"rolldown\";\nexport class RolldownBundler implements IBundler{\n    constructor(private pack: Pack,\n                private resolver: Resolver,\n                private flags: Flags) {\n    }\n\n    private async getFileContent(entry: Entry) {\n        const target = entry.name ? `${this.pack.name}/${entry.name}` : `${this.pack.name}`;\n        if (this.pack.packageJson.type === \"module\")\n            return `export * from '${target}';`\n        const pkg = await import(target, entry.source.endsWith('.json') ? {\n            with: {\n                type: 'json'\n            }\n        } : {});\n        const keys = Object.keys(pkg).filter(x => x !== 'default');\n        return [\n            `import * as result from '${target}';`,\n            `export const { ${keys.join(',')} } = result;`,\n            ('default' in pkg) ? 'export default result.default;' : ''\n        ].join('\\n');\n    }\n\n    dir = path.join(process.cwd(), './node_modules/.cmmn');\n\n    async getInputs(): Promise<AsyncDisposable & Record<string, string>> {\n        const result: AsyncDisposable & Record<string, string> = {\n            async [Symbol.asyncDispose]() {\n                for (let file of Object.values(this)) {\n                    if (typeof file === 'string')\n                        await fs.rm(file);\n                }\n            }\n        };\n        for (let entry of this.pack.entries) {\n            if (entry.source.match(/\\.(d\\.ts|css|scss|sass|less|styl|pcss|postcss|html)$/))\n                continue;\n            if(entry.source.includes('*')) // TODO: read all files\n                continue;\n            const id = crc32(entry.name + new Date() + Math.random());\n            const file = `${this.dir}/.${id}.js`;\n            const content = await this.getFileContent(entry);\n            await fs.mkdir(this.dir, {recursive: true});\n            await fs.writeFile(file, content, 'utf-8');\n            result[entry.name] = file;\n        }\n        return result;\n    }\n\n    private getConfig(): BuildOptions {\n        return {\n            write: false,\n            output: {\n                format: 'esm',\n                // chunkFileNames: chunk =>  '@_/' + chunk.name + '.js',\n                // assetFileNames: asset =>  '@_/' + asset.name + '.js',\n            },\n            define: {\n                'process.env.NODE_ENV': this.flags.production ? '\"production\"' : '\"development\"'\n            },\n            experimental: {},\n            platform: 'browser',\n            resolve: {\n                mainFields: [\n                    'browser',\n                    'module',\n                    'main',\n                ],\n            },\n            optimization: {\n                inlineConst: this.flags.minify,\n            },\n            treeshake: true,\n            plugins: [...this.getPlugins()]\n        }\n    }\n\n    // TODO: Filter hook https://rolldown.rs/in-depth/why-plugin-hook-filter#when-to-use-filters\n    * getPlugins(): Generator<Plugin> {\n        yield wasm({\n            emitAsset: true,\n            assetName: `{name}`\n        }) as any;\n        yield {\n            name: 'require',\n            load: id => {\n                const prefix = 'builtin:esm-external-require-';\n                if (id.startsWith(prefix)){\n                    const resolved = this.resolver.resolveId(id.substring(prefix.length), null, null)\n                    if (resolved)\n                        return `export * from \"${resolved.id}\"`;\n                }\n            }\n        };\n        yield {\n            name: 'externals',\n            resolveId: (id, importer, options) => {\n                if (options.kind === 'require-call')\n                    return;\n                const resolved = this.resolver.resolveId(id, importer, options);\n                if (resolved && resolved.pack !== this.pack)\n                    return resolved;\n            }\n        };\n        yield esmExternalRequirePlugin({\n            external: this.resolver.getPackNames().filter(x => x !== this.pack.name),\n        });\n        if (this.flags.minify)\n            yield swcMinifyPlugin() as any;\n    }\n\n    async bundle(): Promise<Bundle> {\n        await using input = await this.getInputs();\n        if (Object.keys(input).length == 0)\n            return new Bundle(this.pack, []);\n        const {build} = await import(\"rolldown\");\n        const config = this.getConfig();\n        const result = await build({\n            ...config,\n            input\n        }).catch(err => {\n            this.pack.error(err.message);\n            return {\n                output: []\n            };\n        });\n        const outputs = result.output.map(x => ({\n            fileName: x.fileName,\n            entry: this.pack.getEntry(x.name),\n            data: x.type == \"asset\" ? x.source : x.code,\n            deps: x.type == \"asset\" ? [] : [\n                ...x.imports,\n                ...x.dynamicImports\n            ].map(path => this.resolver.getPack(path) ?? {\n                pack: this.pack,\n                path: path\n            })\n        } as Output));\n        return new Bundle(this.pack, outputs);\n    }\n}","import {getPackages, Packages} from \"@manypkg/get-packages\";\nimport {JSONSchemaForNPMPackageJsonFiles} from \"@schemastore/package\";\nimport {Pack} from \"./pack\";\nimport {Target} from \"./target\";\nimport {Resolver} from \"./resolver\";\nimport {Flags} from \"./flags\";\nimport {ViteBundler} from \"../bundlers/vite.bundler\";\nimport {RolldownBundler} from \"../bundlers/rolldown-bundler\";\n\nexport class Monorepo {\n    public static async load(flags: Flags = new Flags([]), rootDir: string = process.cwd()): Promise<Monorepo> {\n        const monorepoPackages = await getPackages(rootDir);\n        const monorepo = new MonorepoLoader(monorepoPackages);\n        await monorepo.load(flags.production);\n        return new Monorepo(monorepo.root as Target, monorepo.packs, flags);\n    }\n    public readonly packs = Array.from(this.packsMap.values()) as Pack[];\n    private constructor(readonly root: Target,\n                        private readonly packsMap: Map<string,Pack>,\n                        public readonly flags: Flags) {\n        if (flags.deploy)\n            this.resolver = new Resolver(this.packs, this.flags);\n        this.packs.forEach(x => x.init(flags, this.packsMap));\n        root.init(flags, this.packsMap);\n    }\n\n    get targets(){\n        return Array.from(this.packs.values()).filter(x => x instanceof Target) as Target[];\n    }\n\n    get(id: string) {\n        return this.packsMap.get(id);\n    }\n\n    public readonly resolver: Resolver | undefined;\n\n    public createBundler(pack: Pack){\n        if (pack instanceof Target)\n            return new ViteBundler(pack, this.resolver, this.flags);\n        return new RolldownBundler(pack, this.resolver, this.flags)\n    }\n}\n\nclass MonorepoLoader {\n\n    packs = new Map<string, Pack>();\n    root: Pack;\n\n    constructor(private readonly packages: Packages) {\n    }\n\n    async load(prod: boolean){\n        for (let p of this.packages.packages) {\n            await this.export(p.packageJson.name, p.packageJson.version, prod);\n        }\n        this.root = await this.export(this.packages.rootPackage.packageJson.name,\n            this.packages.rootPackage.packageJson.version, prod);\n        return Array.from(this.packs.values());\n    }\n\n    private async export(name: string, version: string, prod: boolean){\n        if (this.packs.has(name)) return this.packs.get(name);\n        const pkg = this.getPackage(name);\n        if(pkg) {\n            const pack = new Target(pkg.dir, pkg.packageJson)\n            this.packs.set(name, pack);\n            for (let [name, version] of pack.getAllDependencies(prod)) {\n                if (this.packs.has(name)) continue;\n                await this.export(name, version, prod);\n            }\n            return pack;\n        } else {\n            const pack = await Pack.read(name, version);\n            this.packs.set(name, pack);\n            return pack;\n        }\n    }\n\n    private getPackage(name: string): Package | undefined {\n        const p = this.packages.rootPackage.packageJson.name == name\n            ? this.packages.rootPackage\n            : this.packages.packages.find(x => x.packageJson.name == name);\n        return p && {\n            dir: p.dir,\n            packageJson: p.packageJson as JSONSchemaForNPMPackageJsonFiles,\n            version: p.packageJson.version,\n        };\n    }\n\n}\ntype Package = {\n    dir: string;\n    packageJson: JSONSchemaForNPMPackageJsonFiles;\n    version: string;\n}\n"],"names":["Pack","EventTarget","read","id","version","dir","process","cwd","pkgDir","join","stat","json","JSON","parse","readFile","encoding","dirname","getAllDependencies","prod","Object","entries","packageJson","dependencies","devDependencies","rootDir","reactions","init","flags","packsMap","deps","keys","production","push","map","x","get","filter","forEach","dep","addEventListener","e","dispatchEvent","ChangeEvent","payload","from","FileChangeEvent","isServer","config","server","name","log","text","term","terminalKit","Terminal","blue","white","error","toString","_entries","exports","result","item","startsWith","importFile","default","require","import","createEntry","entry","module","main","browser","getEntry","find","source","absolute","resolve","replace","relative","isExcluded","isHTML","test","output","getExport","isTypeScript","isJavaScript","file","extension","match","entryName","outExt","ImportPrefix","publicPath","Event","files","getTSConfig","configPath","ts","readConfigFile","sys","extends","extended","path","fileURLToPath","merged","merge","values","Set","flatMap","key","v","undefined","length","at","Array","isArray","Target","tsConfig","_tsConfig","fileName","isRelative","substring","check","pattern","minimatch","include","some","exclude","swcConfigPath","local","fs","existsSync","swcConfig","swcConfigBase","readFileSync","_swcConfig","jsc","baseUrl","paths","compilerOptions","type","strict","strictMode","resolveFully","sourceMaps","inlineSourcesContent","getPublishPackageJson","stringify","typings","bundle","scripts","https","host","port","cert","proxy","_proxy","regex","RegExp","publicDir","Resolver","packs","basePath","resolveId","importer","options","isEntry","pack","getPack","resolveInPack","resolvePath","resolveWithProxy","attributes","external","resolved","getPackNames","Flags","Current","args","deploy","includes","out","indexOf","command","watch","minify","unsafe","workspace","arg","index","Bundle","fileNames","data","getPublicAsset","getBundleJson","baseURI","assets","Promise","all","o","getOutputAsset","hash","getHash","size","fromEntries","getDeps","flat","grouped","Map","groupBy","uri","buffer","Buffer","subtle","digest","wasm","split","pop","moduleInfo","getModuleInfo","dynamicallyImportedIds","importedIds","load","url","emitAsset","referenceId","emitFile","assetName","mappings","code","swcMinifyPlugin","renderChunk","chunk","endsWith","compress","defaults","hoist_props","unused","dead_code","ecma","format","comments","ViteBuilder","target","resolver","getConfig","root","logLevel","mode","optimizeDeps","noDiscovery","define","env","NODE_ENV","html","base","build","emptyOutDir","rollupOptions","builtinModules","write","sourcemap","commonjsOptions","transformMixedEsModules","plugins","getPlugins","swc","vite","tsconfigPaths","enforce","transformIndexHtml","_","tag","attrs","href","children","rel","ViteBundler","getBundleConfig","lib","formats","modulePreload","createBundle","catch","err","message","rollupOutput","outputChunks","entryMap","outputs","imports","dynamicImports","RolldownBundler","getFileContent","pkg","with","getInputs","Symbol","asyncDispose","rm","crc32","Date","Math","random","content","mkdir","recursive","writeFile","experimental","platform","mainFields","optimization","inlineConst","treeshake","prefix","kind","esmExternalRequirePlugin","input","Monorepo","monorepoPackages","getPackages","monorepo","MonorepoLoader","targets","createBundler","packages","p","export","rootPackage","has","getPackage","set"],"mappings":"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"}