@kubb/core 1.15.0-canary.20231026T131818 → 1.15.0-canary.20231026T182312

package/dist/index.cjs

@@ -56,6 +56,8 @@ var os__default = /*#__PURE__*/_interopDefault(os);
 var process__default = /*#__PURE__*/_interopDefault(process);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -63,6 +65,40 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 async function clean(path5) {
   return fs2.remove(path5);
 }
@@ -161,7 +197,6 @@ async function read(path5) {
   return reader(path5);
 }
 var URLPath = class {
-  path;
   constructor(path5) {
     this.path = path5;
     return this;
@@ -512,10 +547,8 @@ async function write(data, path5) {
   return writer(path5, data.trim());
 }
 var TreeNode = class _TreeNode {
-  data;
-  parent;
-  children = [];
   constructor(data, parent) {
+    this.children = [];
     this.data = data;
     this.parent = parent;
     return this;
@@ -600,14 +633,15 @@ var TreeNode = class _TreeNode {
 };
 
 // src/BarrelManager.ts
+var _options;
 var BarrelManager = class {
-  #options = {};
   constructor(options = {}) {
-    this.#options = options;
+    __privateAdd(this, _options, {});
+    __privateSet(this, _options, options);
     return this;
   }
   getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = this.#options;
+    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
     const extMapper = {
       ".ts": {
         extensions: /\.ts/,
@@ -676,50 +710,47 @@ var BarrelManager = class {
     return map ? filteredFiles.map(map) : filteredFiles;
   }
 };
+_options = new WeakMap();
 
 // src/FileManager.ts
-var FileManager = class _FileManager {
-  #cache = /* @__PURE__ */ new Map();
-  #task;
-  #isWriting = false;
-  /**
-   * Timeout between writes
-   */
-  #timeout = 0;
-  #queue;
+var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _FileManager = class _FileManager {
   constructor(options) {
+    __privateAdd(this, _validate);
+    __privateAdd(this, _add);
+    __privateAdd(this, _addOrAppend);
+    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
+    __privateAdd(this, _task, void 0);
+    __privateAdd(this, _isWriting, false);
+    /**
+     * Timeout between writes
+     */
+    __privateAdd(this, _timeout, 0);
+    __privateAdd(this, _queue, void 0);
     if (options) {
-      this.#task = options.task;
-      this.#queue = options.queue;
-      this.#timeout = options.timeout || 0;
+      __privateSet(this, _task, options.task);
+      __privateSet(this, _queue, options.queue);
+      __privateSet(this, _timeout, options.timeout || 0);
     }
     return this;
   }
   get files() {
     const files = [];
-    this.#cache.forEach((item) => {
+    __privateGet(this, _cache).forEach((item) => {
       files.push(...item.flat(1));
     });
     return files;
   }
   get isExecuting() {
-    return this.#queue?.hasJobs ?? this.#isWriting ?? false;
-  }
-  #validate(file) {
-    if (!file.validate) {
-      return;
-    }
-    if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-      throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-    }
+    return __privateGet(this, _queue)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
   }
   async add(...files) {
     const promises = files.map((file) => {
-      this.#validate(file);
+      __privateMethod(this, _validate, validate_fn).call(this, file);
       if (file.override) {
-        return this.#add(file);
+        return __privateMethod(this, _add, add_fn).call(this, file);
       }
-      return this.#addOrAppend(file);
+      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
     });
     const resolvedFiles = await Promise.all(promises);
     if (files.length > 1) {
@@ -727,36 +758,6 @@ var FileManager = class _FileManager {
     }
     return resolvedFiles[0];
   }
-  async #add(file) {
-    const controller = new AbortController();
-    const resolvedFile = { id: crypto2__default.default.randomUUID(), ...file };
-    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-    if (this.#queue) {
-      await this.#queue.run(
-        async () => {
-          return this.#task?.(resolvedFile);
-        },
-        { controller }
-      );
-    }
-    return resolvedFile;
-  }
-  async #addOrAppend(file) {
-    const previousCaches = this.#cache.get(file.path);
-    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
-    if (previousCache) {
-      this.#cache.delete(previousCache.path);
-      return this.#add({
-        ...file,
-        source: previousCache.source && file.source ? `${previousCache.source}
-${file.source}` : "",
-        imports: [...previousCache.imports || [], ...file.imports || []],
-        exports: [...previousCache.exports || [], ...file.exports || []],
-        env: { ...previousCache.env || {}, ...file.env || {} }
-      });
-    }
-    return this.#add(file);
-  }
   async addIndexes({ root, extName = ".ts", meta, options = {} }) {
     const barrelManager = new BarrelManager(options);
     const files = barrelManager.getIndexes(root, extName);
@@ -765,7 +766,7 @@ ${file.source}` : "",
     }
     return await Promise.all(
       files.map((file) => {
-        return this.#addOrAppend({
+        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
           ...file,
           meta: meta ? meta : file.meta
         });
@@ -774,29 +775,29 @@ ${file.source}` : "",
   }
   getCacheByUUID(UUID) {
     let cache;
-    this.#cache.forEach((files) => {
+    __privateGet(this, _cache).forEach((files) => {
       cache = files.find((item) => item.id === UUID);
     });
     return cache;
   }
   get(path5) {
-    return this.#cache.get(path5);
+    return __privateGet(this, _cache).get(path5);
   }
   remove(path5) {
     const cacheItem = this.get(path5);
     if (!cacheItem) {
       return;
     }
-    this.#cache.delete(path5);
+    __privateGet(this, _cache).delete(path5);
   }
   async write(...params) {
-    if (!this.#isWriting) {
-      this.#isWriting = true;
+    if (!__privateGet(this, _isWriting)) {
+      __privateSet(this, _isWriting, true);
       const text = await write(...params);
-      this.#isWriting = false;
+      __privateSet(this, _isWriting, false);
       return text;
     }
-    await timeout(this.#timeout);
+    await timeout(__privateGet(this, _timeout));
     return this.write(...params);
   }
   async read(...params) {
@@ -856,6 +857,54 @@ ${file.source}` : "",
     return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
   }
 };
+_cache = new WeakMap();
+_task = new WeakMap();
+_isWriting = new WeakMap();
+_timeout = new WeakMap();
+_queue = new WeakMap();
+_validate = new WeakSet();
+validate_fn = function(file) {
+  if (!file.validate) {
+    return;
+  }
+  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
+    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
+  }
+};
+_add = new WeakSet();
+add_fn = async function(file) {
+  const controller = new AbortController();
+  const resolvedFile = { id: crypto2__default.default.randomUUID(), ...file };
+  __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+  if (__privateGet(this, _queue)) {
+    await __privateGet(this, _queue).run(
+      async () => {
+        var _a;
+        return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
+      },
+      { controller }
+    );
+  }
+  return resolvedFile;
+};
+_addOrAppend = new WeakSet();
+addOrAppend_fn = async function(file) {
+  const previousCaches = __privateGet(this, _cache).get(file.path);
+  const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+  if (previousCache) {
+    __privateGet(this, _cache).delete(previousCache.path);
+    return __privateMethod(this, _add, add_fn).call(this, {
+      ...file,
+      source: previousCache.source && file.source ? `${previousCache.source}
+${file.source}` : "",
+      imports: [...previousCache.imports || [], ...file.imports || []],
+      exports: [...previousCache.exports || [], ...file.exports || []],
+      env: { ...previousCache.env || {}, ...file.env || {} }
+    });
+  }
+  return __privateMethod(this, _add, add_fn).call(this, file);
+};
+var FileManager = _FileManager;
 function combineExports(exports) {
   const combinedExports = naturalOrderby.orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
@@ -951,86 +1000,95 @@ function getEnvSource(source, env) {
     return prev;
   }, source);
 }
+var _emitter;
 var EventEmitter = class {
   constructor() {
-    this.#emitter.setMaxListeners(100);
+    __privateAdd(this, _emitter, new events.EventEmitter());
+    __privateGet(this, _emitter).setMaxListeners(100);
   }
-  #emitter = new events.EventEmitter();
   emit(eventName, ...eventArg) {
-    this.#emitter.emit(eventName, ...eventArg);
+    __privateGet(this, _emitter).emit(eventName, ...eventArg);
   }
   on(eventName, handler) {
-    this.#emitter.on(eventName, handler);
+    __privateGet(this, _emitter).on(eventName, handler);
   }
   off(eventName, handler) {
-    this.#emitter.off(eventName, handler);
+    __privateGet(this, _emitter).off(eventName, handler);
   }
   removeAll() {
-    this.#emitter.removeAllListeners();
+    __privateGet(this, _emitter).removeAllListeners();
   }
 };
+_emitter = new WeakMap();
+var _queue2, _workerCount, _maxParallel, _debug, _work, work_fn;
 var Queue = class {
-  #queue = [];
-  eventEmitter = new EventEmitter();
-  #workerCount = 0;
-  #maxParallel;
-  #debug = false;
   constructor(maxParallel, debug = false) {
-    this.#maxParallel = maxParallel;
-    this.#debug = debug;
+    __privateAdd(this, _work);
+    __privateAdd(this, _queue2, []);
+    this.eventEmitter = new EventEmitter();
+    __privateAdd(this, _workerCount, 0);
+    __privateAdd(this, _maxParallel, void 0);
+    __privateAdd(this, _debug, false);
+    __privateSet(this, _maxParallel, maxParallel);
+    __privateSet(this, _debug, debug);
   }
   run(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
     return new Promise((resolve2, reject) => {
       const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
         reject("Aborted");
       });
-      this.#queue.push(item);
-      this.#work();
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
     new Promise((resolve2, reject) => {
       const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
       });
-      this.#queue.push(item);
-      this.#work();
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
     });
   }
   get hasJobs() {
-    return this.#workerCount > 0 || this.#queue.length > 0;
+    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue2).length > 0;
   }
   get count() {
-    return this.#workerCount;
+    return __privateGet(this, _workerCount);
   }
-  #work() {
-    if (this.#workerCount >= this.#maxParallel) {
-      return;
-    }
-    this.#workerCount++;
-    let entry;
-    while (entry = this.#queue.shift()) {
-      const { reject, resolve: resolve2, job, name, description } = entry;
-      if (this.#debug) {
-        perf_hooks.performance.mark(name + "_start");
+};
+_queue2 = new WeakMap();
+_workerCount = new WeakMap();
+_maxParallel = new WeakMap();
+_debug = new WeakMap();
+_work = new WeakSet();
+work_fn = function() {
+  if (__privateGet(this, _workerCount) >= __privateGet(this, _maxParallel)) {
+    return;
+  }
+  __privateWrapper(this, _workerCount)._++;
+  let entry;
+  while (entry = __privateGet(this, _queue2).shift()) {
+    const { reject, resolve: resolve2, job, name, description } = entry;
+    if (__privateGet(this, _debug)) {
+      perf_hooks.performance.mark(name + "_start");
+    }
+    job().then((result) => {
+      this.eventEmitter.emit("jobDone", result);
+      resolve2(result);
+      if (__privateGet(this, _debug)) {
+        perf_hooks.performance.mark(name + "_stop");
+        perf_hooks.performance.measure(description, name + "_start", name + "_stop");
       }
-      job().then((result) => {
-        this.eventEmitter.emit("jobDone", result);
-        resolve2(result);
-        if (this.#debug) {
-          perf_hooks.performance.mark(name + "_stop");
-          perf_hooks.performance.measure(description, name + "_start", name + "_stop");
-        }
-      }).catch((err) => {
-        this.eventEmitter.emit("jobFailed", err);
-        reject(err);
-      });
-    }
-    this.#workerCount--;
+    }).catch((err) => {
+      this.eventEmitter.emit("jobFailed", err);
+      reject(err);
+    });
   }
+  __privateWrapper(this, _workerCount)._--;
 };
 
 // src/utils/uniqueName.ts
@@ -1046,8 +1104,6 @@ function setUniqueName(originalName, data) {
 
 // src/errors.ts
 var PluginError = class extends Error {
-  pluginManager;
-  cause;
   constructor(message, options) {
     super(message, { cause: options.cause });
     this.name = "PluginError";
@@ -1056,10 +1112,9 @@ var PluginError = class extends Error {
   }
 };
 var ParallelPluginError = class extends Error {
-  errors = [];
-  pluginManager;
   constructor(message, options) {
     super(message, { cause: options.cause });
+    this.errors = [];
     this.name = "ParallelPluginError";
     this.errors = options.errors;
     this.pluginManager = options.pluginManager;
@@ -1080,7 +1135,6 @@ var ParallelPluginError = class extends Error {
   }
 };
 var SummaryError = class extends Error {
-  summary;
   constructor(message, options) {
     super(message, { cause: options.cause });
     this.name = "SummaryError";
@@ -1193,10 +1247,11 @@ function hookSeq(promises) {
 }
 
 // src/PromiseManager.ts
+var _options2;
 var PromiseManager = class {
-  #options = {};
   constructor(options = {}) {
-    this.#options = options;
+    __privateAdd(this, _options2, {});
+    __privateSet(this, _options2, options);
     return this;
   }
   run(strategy, promises) {
@@ -1206,6 +1261,7 @@ var PromiseManager = class {
     throw new Error(`${strategy} not implemented`);
   }
 };
+_options2 = new WeakMap();
 function isPromise(result) {
   return !!result && typeof result?.then === "function";
 }
@@ -1214,21 +1270,81 @@ function isPromiseRejectedResult(result) {
 }
 
 // src/PluginManager.ts
+var _core, _usedPluginNames, _promiseManager, _getSortedPlugins, getSortedPlugins_fn, _addExecutedToCallStack, addExecutedToCallStack_fn, _execute, execute_fn, _executeSync, executeSync_fn, _catcher, catcher_fn, _parse, parse_fn;
 var PluginManager = class {
-  plugins;
-  fileManager;
-  eventEmitter = new EventEmitter();
-  queue;
-  executed = [];
-  logger;
-  #core;
-  #usedPluginNames = {};
-  #promiseManager;
   constructor(config, options) {
+    __privateAdd(this, _getSortedPlugins);
+    __privateAdd(this, _addExecutedToCallStack);
+    /**
+     * Run an async plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The actual pluginObject to run.
+     */
+    // Implementation signature
+    __privateAdd(this, _execute);
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    __privateAdd(this, _executeSync);
+    __privateAdd(this, _catcher);
+    __privateAdd(this, _parse);
+    this.eventEmitter = new EventEmitter();
+    this.executed = [];
+    __privateAdd(this, _core, void 0);
+    __privateAdd(this, _usedPluginNames, {});
+    __privateAdd(this, _promiseManager, void 0);
+    this.resolvePath = (params) => {
+      if (params.pluginKey) {
+        const paths = this.hookForPluginSync({
+          pluginKey: params.pluginKey,
+          hookName: "resolvePath",
+          parameters: [params.baseName, params.directory, params.options]
+        });
+        if (paths && paths?.length > 1) {
+          throw new Error(
+            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Paths: ${JSON.stringify(paths, void 0, 2)}`
+          );
+        }
+        return paths?.at(0);
+      }
+      return this.hookFirstSync({
+        hookName: "resolvePath",
+        parameters: [params.baseName, params.directory, params.options]
+      }).result;
+    };
+    this.resolveName = (params) => {
+      if (params.pluginKey) {
+        const names = this.hookForPluginSync({
+          pluginKey: params.pluginKey,
+          hookName: "resolveName",
+          parameters: [params.name, params.type]
+        });
+        if (names && names?.length > 1) {
+          throw new Error(
+            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Names: ${JSON.stringify(names, void 0, 2)}`
+          );
+        }
+        return transformReservedWord(names?.at(0) || params.name);
+      }
+      const name = this.hookFirstSync({
+        hookName: "resolveName",
+        parameters: [params.name, params.type]
+      }).result;
+      return transformReservedWord(name);
+    };
     this.logger = options.logger;
     this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
-    this.#promiseManager = new PromiseManager();
+    __privateSet(this, _promiseManager, new PromiseManager());
     const plugins = config.plugins || [];
     const core = definePlugin({
       config,
@@ -1237,57 +1353,14 @@ var PluginManager = class {
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: this.#getSortedPlugins.bind(this)
+      getPlugins: __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).bind(this)
     });
-    this.#core = this.#parse(core, this, core.api.call(null));
-    this.plugins = [this.#core, ...plugins].map((plugin) => {
-      return this.#parse(plugin, this, this.#core.api);
+    __privateSet(this, _core, __privateMethod(this, _parse, parse_fn).call(this, core, this, core.api.call(null)));
+    this.plugins = [__privateGet(this, _core), ...plugins].map((plugin) => {
+      return __privateMethod(this, _parse, parse_fn).call(this, plugin, this, __privateGet(this, _core).api);
     });
     return this;
   }
-  resolvePath = (params) => {
-    if (params.pluginKey) {
-      const paths = this.hookForPluginSync({
-        pluginKey: params.pluginKey,
-        hookName: "resolvePath",
-        parameters: [params.baseName, params.directory, params.options]
-      });
-      if (paths && paths?.length > 1) {
-        throw new Error(
-          `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Paths: ${JSON.stringify(paths, void 0, 2)}`
-        );
-      }
-      return paths?.at(0);
-    }
-    return this.hookFirstSync({
-      hookName: "resolvePath",
-      parameters: [params.baseName, params.directory, params.options]
-    }).result;
-  };
-  resolveName = (params) => {
-    if (params.pluginKey) {
-      const names = this.hookForPluginSync({
-        pluginKey: params.pluginKey,
-        hookName: "resolveName",
-        parameters: [params.name, params.type]
-      });
-      if (names && names?.length > 1) {
-        throw new Error(
-          `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Names: ${JSON.stringify(names, void 0, 2)}`
-        );
-      }
-      return transformReservedWord(names?.at(0) || params.name);
-    }
-    const name = this.hookFirstSync({
-      hookName: "resolveName",
-      parameters: [params.name, params.type]
-    }).result;
-    return transformReservedWord(name);
-  };
   on(eventName, handler) {
     this.eventEmitter.on(eventName, handler);
   }
@@ -1301,7 +1374,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
     const promises = plugins.map((plugin) => {
-      return this.#execute({
+      return __privateMethod(this, _execute, execute_fn).call(this, {
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -1317,7 +1390,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
     return plugins.map((plugin) => {
-      return this.#executeSync({
+      return __privateMethod(this, _executeSync, executeSync_fn).call(this, {
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -1334,7 +1407,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     skipped
   }) {
     let promise = Promise.resolve(null);
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
@@ -1342,7 +1415,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
         if (parseResult?.result != null) {
           return parseResult;
         }
-        const value = await this.#execute({
+        const value = await __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1367,12 +1440,12 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     skipped
   }) {
     let parseResult = null;
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
       parseResult = {
-        result: this.#executeSync({
+        result: __privateMethod(this, _executeSync, executeSync_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1394,8 +1467,8 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     parameters
   }) {
     const parallelPromises = [];
-    for (const plugin of this.#getSortedPlugins()) {
-      const promise = this.#execute({ strategy: "hookParallel", hookName, parameters, plugin });
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+      const promise = __privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
       if (promise) {
         parallelPromises.push(promise);
       }
@@ -1422,16 +1495,16 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }) {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       promise = promise.then((arg0) => {
-        const value = this.#execute({
+        const value = __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookReduceArg0",
           hookName,
           parameters: [arg0, ...rest],
           plugin
         });
         return value;
-      }).then((result) => reduce.call(this.#core.api, argument0, result, plugin));
+      }).then((result) => reduce.call(__privateGet(this, _core).api, argument0, result, plugin));
     }
     return promise;
   }
@@ -1439,28 +1512,15 @@ Names: ${JSON.stringify(names, void 0, 2)}`
    * Chains plugins
    */
   hookSeq({ hookName, parameters }) {
-    const promises = this.#getSortedPlugins().map((plugin) => {
-      return () => this.#execute({
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => __privateMethod(this, _execute, execute_fn).call(this, {
         strategy: "hookSeq",
         hookName,
         parameters,
         plugin
       });
     });
-    return this.#promiseManager.run("seq", promises);
-  }
-  #getSortedPlugins(hookName) {
-    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
-    if (hookName) {
-      if (this.logger.logLevel === "info") {
-        const containsHookName = plugins.some((item) => item[hookName]);
-        if (!containsHookName) {
-          this.logger.warn(`No hook ${hookName} found`);
-        }
-      }
-      return plugins.filter((item) => item[hookName]);
-    }
-    return plugins;
+    return __privateGet(this, _promiseManager).run("seq", promises);
   }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
@@ -1488,129 +1548,6 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     }
     return pluginByPluginName;
   }
-  #addExecutedToCallStack(executer) {
-    if (executer) {
-      this.eventEmitter.emit("executed", executer);
-      this.executed.push(executer);
-    }
-  }
-  /**
-   * Run an async plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The actual pluginObject to run.
-   */
-  // Implementation signature
-  #execute({
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  }) {
-    const hook = plugin[hookName];
-    let output;
-    if (!hook) {
-      return null;
-    }
-    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
-    const task = Promise.resolve().then(() => {
-      if (typeof hook === "function") {
-        const possiblePromiseResult = hook.apply({ ...this.#core.api, plugin }, parameters);
-        if (isPromise(possiblePromiseResult)) {
-          return Promise.resolve(possiblePromiseResult);
-        }
-        return possiblePromiseResult;
-      }
-      return hook;
-    }).then((result) => {
-      output = result;
-      return result;
-    }).catch((e) => {
-      this.#catcher(e, plugin, hookName);
-      return null;
-    }).finally(() => {
-      this.#addExecutedToCallStack({
-        parameters,
-        output,
-        strategy,
-        hookName,
-        plugin
-      });
-    });
-    return task;
-  }
-  /**
-   * Run a sync plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The acutal plugin
-   * @param replaceContext When passed, the plugin context can be overridden.
-   */
-  #executeSync({
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  }) {
-    const hook = plugin[hookName];
-    let output;
-    if (!hook) {
-      return null;
-    }
-    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
-    try {
-      if (typeof hook === "function") {
-        const fn = hook.apply({ ...this.#core.api, plugin }, parameters);
-        output = fn;
-        return fn;
-      }
-      output = hook;
-      return hook;
-    } catch (e) {
-      this.#catcher(e, plugin, hookName);
-      return null;
-    } finally {
-      this.#addExecutedToCallStack({
-        parameters,
-        output,
-        strategy,
-        hookName,
-        plugin
-      });
-    }
-  }
-  #catcher(e, plugin, hookName) {
-    const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
-`;
-    const pluginError = new PluginError(text, { cause: e, pluginManager: this });
-    this.eventEmitter.emit("error", pluginError);
-    throw pluginError;
-  }
-  #parse(plugin, pluginManager, context) {
-    const usedPluginNames = pluginManager.#usedPluginNames;
-    setUniqueName(plugin.name, usedPluginNames);
-    const key = plugin.key || [plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-    if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
-      pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
-    }
-    if (!plugin.transform) {
-      plugin.transform = function transform(code) {
-        return code;
-      };
-    }
-    if (plugin.api && typeof plugin.api === "function") {
-      const api = plugin.api.call(context);
-      return {
-        ...plugin,
-        key,
-        api
-      };
-    }
-    return {
-      ...plugin,
-      key
-    };
-  }
   static getDependedPlugins(plugins, dependedPluginNames) {
     let pluginNames = [];
     if (typeof dependedPluginNames === "string") {
@@ -1631,6 +1568,137 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
   }
 };
+_core = new WeakMap();
+_usedPluginNames = new WeakMap();
+_promiseManager = new WeakMap();
+_getSortedPlugins = new WeakSet();
+getSortedPlugins_fn = function(hookName) {
+  const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
+  if (hookName) {
+    if (this.logger.logLevel === "info") {
+      const containsHookName = plugins.some((item) => item[hookName]);
+      if (!containsHookName) {
+        this.logger.warn(`No hook ${hookName} found`);
+      }
+    }
+    return plugins.filter((item) => item[hookName]);
+  }
+  return plugins;
+};
+_addExecutedToCallStack = new WeakSet();
+addExecutedToCallStack_fn = function(executer) {
+  if (executer) {
+    this.eventEmitter.emit("executed", executer);
+    this.executed.push(executer);
+  }
+};
+_execute = new WeakSet();
+execute_fn = function({
+  strategy,
+  hookName,
+  parameters,
+  plugin
+}) {
+  const hook = plugin[hookName];
+  let output;
+  if (!hook) {
+    return null;
+  }
+  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  const task = Promise.resolve().then(() => {
+    if (typeof hook === "function") {
+      const possiblePromiseResult = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
+      if (isPromise(possiblePromiseResult)) {
+        return Promise.resolve(possiblePromiseResult);
+      }
+      return possiblePromiseResult;
+    }
+    return hook;
+  }).then((result) => {
+    output = result;
+    return result;
+  }).catch((e) => {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
+  }).finally(() => {
+    __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin
+    });
+  });
+  return task;
+};
+_executeSync = new WeakSet();
+executeSync_fn = function({
+  strategy,
+  hookName,
+  parameters,
+  plugin
+}) {
+  const hook = plugin[hookName];
+  let output;
+  if (!hook) {
+    return null;
+  }
+  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  try {
+    if (typeof hook === "function") {
+      const fn = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
+      output = fn;
+      return fn;
+    }
+    output = hook;
+    return hook;
+  } catch (e) {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
+  } finally {
+    __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin
+    });
+  }
+};
+_catcher = new WeakSet();
+catcher_fn = function(e, plugin, hookName) {
+  const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
+`;
+  const pluginError = new PluginError(text, { cause: e, pluginManager: this });
+  this.eventEmitter.emit("error", pluginError);
+  throw pluginError;
+};
+_parse = new WeakSet();
+parse_fn = function(plugin, pluginManager, context) {
+  const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
+  setUniqueName(plugin.name, usedPluginNames);
+  const key = plugin.key || [plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
+  if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
+    pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
+  }
+  if (!plugin.transform) {
+    plugin.transform = function transform(code) {
+      return code;
+    };
+  }
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      key,
+      api
+    };
+  }
+  return {
+    ...plugin,
+    key
+  };
+};
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
@@ -1745,80 +1813,87 @@ ${code}`);
 }
 
 // src/Generator.ts
+var _options3, _context;
 var Generator = class {
-  #options = {};
-  #context = {};
   constructor(options, context) {
+    __privateAdd(this, _options3, {});
+    __privateAdd(this, _context, {});
     if (context) {
-      this.#context = context;
+      __privateSet(this, _context, context);
     }
     if (options) {
-      this.#options = options;
+      __privateSet(this, _options3, options);
     }
     return this;
   }
   get options() {
-    return this.#options;
+    return __privateGet(this, _options3);
   }
   get context() {
-    return this.#context;
+    return __privateGet(this, _context);
   }
   set options(options) {
-    this.#options = { ...this.#options, ...options };
+    __privateSet(this, _options3, { ...__privateGet(this, _options3), ...options });
   }
 };
+_options3 = new WeakMap();
+_context = new WeakMap();
 
 // ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
 var Node = class {
-  value;
-  next;
   constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
     this.value = value;
   }
 };
+var _head, _tail, _size;
 var Queue2 = class {
-  #head;
-  #tail;
-  #size;
   constructor() {
+    __privateAdd(this, _head, void 0);
+    __privateAdd(this, _tail, void 0);
+    __privateAdd(this, _size, void 0);
     this.clear();
   }
   enqueue(value) {
     const node = new Node(value);
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
+    if (__privateGet(this, _head)) {
+      __privateGet(this, _tail).next = node;
+      __privateSet(this, _tail, node);
     } else {
-      this.#head = node;
-      this.#tail = node;
+      __privateSet(this, _head, node);
+      __privateSet(this, _tail, node);
     }
-    this.#size++;
+    __privateWrapper(this, _size)._++;
   }
   dequeue() {
-    const current = this.#head;
+    const current = __privateGet(this, _head);
     if (!current) {
       return;
     }
-    this.#head = this.#head.next;
-    this.#size--;
+    __privateSet(this, _head, __privateGet(this, _head).next);
+    __privateWrapper(this, _size)._--;
     return current.value;
   }
   clear() {
-    this.#head = void 0;
-    this.#tail = void 0;
-    this.#size = 0;
+    __privateSet(this, _head, void 0);
+    __privateSet(this, _tail, void 0);
+    __privateSet(this, _size, 0);
   }
   get size() {
-    return this.#size;
+    return __privateGet(this, _size);
   }
   *[Symbol.iterator]() {
-    let current = this.#head;
+    let current = __privateGet(this, _head);
     while (current) {
       yield current.value;
       current = current.next;
     }
   }
 };
+_head = new WeakMap();
+_tail = new WeakMap();
+_size = new WeakMap();
 
 // ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 function pLimit(concurrency) {
@@ -2034,32 +2109,32 @@ function findUpSync(name, options = {}) {
   const matches = findUpMultipleSync(name, { ...options, limit: 1 });
   return matches[0];
 }
-var PackageManager = class _PackageManager {
-  static #cache = {};
-  #cwd;
-  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+var _cache2, _cwd, _SLASHES;
+var _PackageManager = class _PackageManager {
   constructor(workspace) {
+    __privateAdd(this, _cwd, void 0);
+    __privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) {
-      this.#cwd = workspace;
+      __privateSet(this, _cwd, workspace);
     }
     return this;
   }
   set workspace(workspace) {
-    this.#cwd = workspace;
+    __privateSet(this, _cwd, workspace);
   }
   get workspace() {
-    return this.#cwd;
+    return __privateGet(this, _cwd);
   }
   normalizeDirectory(directory) {
-    if (!this.#SLASHES.has(directory[directory.length - 1])) {
+    if (!__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
       return `${directory}/`;
     }
     return directory;
   }
   getLocation(path5) {
     let location = path5;
-    if (this.#cwd) {
-      const require2 = mod__default.default.createRequire(this.normalizeDirectory(this.#cwd));
+    if (__privateGet(this, _cwd)) {
+      const require2 = mod__default.default.createRequire(this.normalizeDirectory(__privateGet(this, _cwd)));
       location = require2.resolve(path5);
     }
     return location;
@@ -2079,7 +2154,7 @@ var PackageManager = class _PackageManager {
   }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -2088,7 +2163,7 @@ var PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -2096,11 +2171,11 @@ var PackageManager = class _PackageManager {
     return __require(pkgPath);
   }
   static setVersion(dependency, version) {
-    _PackageManager.#cache[dependency] = version;
+    __privateGet(_PackageManager, _cache2)[dependency] = version;
   }
   async getVersion(dependency) {
-    if (_PackageManager.#cache[dependency]) {
-      return _PackageManager.#cache[dependency];
+    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+      return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
@@ -2109,8 +2184,8 @@ var PackageManager = class _PackageManager {
     return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
   }
   getVersionSync(dependency) {
-    if (_PackageManager.#cache[dependency]) {
-      return _PackageManager.#cache[dependency];
+    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+      return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
@@ -2141,6 +2216,11 @@ var PackageManager = class _PackageManager {
     return semver.satisfies(semVer, version);
   }
 };
+_cache2 = new WeakMap();
+_cwd = new WeakMap();
+_SLASHES = new WeakMap();
+__privateAdd(_PackageManager, _cache2, {});
+var PackageManager = _PackageManager;
 
 // src/SchemaGenerator.ts
 var SchemaGenerator = class extends Generator {