@let-value/translate-extract-static 1.1.2 → 1.1.6-beta.1

package/dist/src/index.d.mts

@@ -0,0 +1,433 @@
+//#region ../node_modules/.pnpm/loglevel@1.9.2/node_modules/loglevel/index.d.ts
+// Originally from Definitely Typed, see:
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b4683d7/types/loglevel/index.d.ts
+// Original definitions by: Stefan Profanter <https://github.com/Pro>
+//                          Gabor Szmetanko <https://github.com/szmeti>
+//                          Christian Rackerseder <https://github.com/screendriver>
+declare const log: log.RootLogger;
+declare namespace log {
+  /**
+   * Log levels
+   */
+  interface LogLevel {
+    TRACE: 0;
+    DEBUG: 1;
+    INFO: 2;
+    WARN: 3;
+    ERROR: 4;
+    SILENT: 5;
+  }
+  /**
+   * Possible log level numbers.
+   */
+  type LogLevelNumbers = LogLevel[keyof LogLevel];
+  /**
+   * Possible log level descriptors, may be string, lower or upper case, or number.
+   */
+  type LogLevelDesc = LogLevelNumbers | LogLevelNames | 'silent' | keyof LogLevel;
+  type LogLevelNames = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+  type LoggingMethod = (...message: any[]) => void;
+  type MethodFactory = (methodName: LogLevelNames, level: LogLevelNumbers, loggerName: string | symbol) => LoggingMethod;
+  interface RootLogger extends Logger {
+    /**
+     * If you're using another JavaScript library that exposes a 'log' global, you can run into conflicts with loglevel.
+     * Similarly to jQuery, you can solve this by putting loglevel into no-conflict mode immediately after it is loaded
+     * onto the page. This resets to 'log' global to its value before loglevel was loaded (typically undefined), and
+     * returns the loglevel object, which you can then bind to another name yourself.
+     */
+    noConflict(): any;
+    /**
+     * This gets you a new logger object that works exactly like the root log object, but can have its level and
+     * logging methods set independently. All loggers must have a name (which is a non-empty string or a symbol)
+     * Calling * getLogger() multiple times with the same name will return an identical logger object.
+     * In large applications, it can be incredibly useful to turn logging on and off for particular modules as you are
+     * working with them. Using the getLogger() method lets you create a separate logger for each part of your
+     * application with its own logging level. Likewise, for small, independent modules, using a named logger instead
+     * of the default root logger allows developers using your module to selectively turn on deep, trace-level logging
+     * when trying to debug problems, while logging only errors or silencing logging altogether under normal
+     * circumstances.
+     * @param name The name of the produced logger
+     */
+    getLogger(name: string | symbol): Logger;
+    /**
+     * This will return you the dictionary of all loggers created with getLogger, keyed off of their names.
+     */
+    getLoggers(): {
+      [name: string]: Logger;
+    };
+    /**
+     * A .default property for ES6 default import compatibility
+     */
+    default: RootLogger;
+  }
+  interface Logger {
+    /**
+     * Available log levels.
+     */
+    readonly levels: LogLevel;
+    /**
+     * Plugin API entry point. This will be called for each enabled method each time the level is set
+     * (including initially), and should return a MethodFactory to be used for the given log method, at the given level,
+     * for a logger with the given name. If you'd like to retain all the reliability and features of loglevel, it's
+     * recommended that this wraps the initially provided value of log.methodFactory
+     */
+    methodFactory: MethodFactory;
+    /**
+     * Output trace message to console.
+     * This will also include a full stack trace
+     *
+     * @param msg any data to log to the console
+     */
+    trace(...msg: any[]): void;
+    /**
+     * Output debug message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    debug(...msg: any[]): void;
+    /**
+     * Output debug message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    log(...msg: any[]): void;
+    /**
+     * Output info message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    info(...msg: any[]): void;
+    /**
+     * Output warn message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    warn(...msg: any[]): void;
+    /**
+     * Output error message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    error(...msg: any[]): void;
+    /**
+     * This disables all logging below the given level, so that after a log.setLevel("warn") call log.warn("something")
+     * or log.error("something") will output messages, but log.info("something") will not.
+     *
+     * @param level as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)
+     * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
+     *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
+     *     false as the optional 'persist' second argument, persistence will be skipped.
+     */
+    setLevel(level: LogLevelDesc, persist?: boolean): void;
+    /**
+     * Returns the current logging level, as a value from LogLevel.
+     * It's very unlikely you'll need to use this for normal application logging; it's provided partly to help plugin
+     * development, and partly to let you optimize logging code as below, where debug data is only generated if the
+     * level is set such that it'll actually be logged. This probably doesn't affect you, unless you've run profiling
+     * on your code and you have hard numbers telling you that your log data generation is a real performance problem.
+     */
+    getLevel(): LogLevel[keyof LogLevel];
+    /**
+     * This sets the current log level only if one has not been persisted and can’t be loaded. This is useful when
+     * initializing scripts; if a developer or user has previously called setLevel(), this won’t alter their settings.
+     * For example, your application might set the log level to error in a production environment, but when debugging
+     * an issue, you might call setLevel("trace") on the console to see all the logs. If that error setting was set
+     * using setDefaultLevel(), it will still say as trace on subsequent page loads and refreshes instead of resetting
+     * to error.
+     *
+     * The level argument takes is the same values that you might pass to setLevel(). Levels set using
+     * setDefaultLevel() never persist to subsequent page loads.
+     *
+     * @param level as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)
+     */
+    setDefaultLevel(level: LogLevelDesc): void;
+    /**
+     * This resets the current log level to the default level (or `warn` if no explicit default was set) and clears
+     * the persisted level if one was previously persisted.
+     */
+    resetLevel(): void;
+    /**
+     * This enables all log messages, and is equivalent to log.setLevel("trace").
+     *
+     * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
+     *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
+     *     false as the optional 'persist' second argument, persistence will be skipped.
+     */
+    enableAll(persist?: boolean): void;
+    /**
+     * This disables all log messages, and is equivalent to log.setLevel("silent").
+     *
+     * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
+     *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
+     *     false as the optional 'persist' second argument, persistence will be skipped.
+     */
+    disableAll(persist?: boolean): void;
+    /**
+     * Rebuild the logging methods on this logger and its child loggers.
+     *
+     * This is mostly intended for plugin developers, but can be useful if you update a logger's `methodFactory` or
+     * if you want to apply the root logger’s level to any *pre-existing* child loggers (this updates the level on
+     * any child logger that hasn't used `setLevel()` or `setDefaultLevel()`).
+     */
+    rebuild(): void;
+  }
+}
+//#endregion
+//#region ../translate/dist/index.d.mts
+//#region src/locales.d.ts
+type PluralFormsLocale = "ach" | "af" | "ak" | "am" | "an" | "ar" | "arn" | "ast" | "ay" | "az" | "be" | "bg" | "bn" | "bo" | "br" | "brx" | "bs" | "ca" | "cgg" | "cs" | "csb" | "cy" | "da" | "de" | "doi" | "dz" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "ff" | "fi" | "fil" | "fo" | "fr" | "fur" | "fy" | "ga" | "gd" | "gl" | "gu" | "gun" | "ha" | "he" | "hi" | "hne" | "hr" | "hu" | "hy" | "id" | "is" | "it" | "ja" | "jbo" | "jv" | "ka" | "kab" | "kk" | "km" | "kn" | "ko" | "ku" | "kw" | "ky" | "lb" | "ln" | "lo" | "lt" | "lv" | "mai" | "mfe" | "mg" | "mi" | "mk" | "ml" | "mn" | "mni" | "mnk" | "mr" | "ms" | "mt" | "my" | "nah" | "nap" | "nb" | "ne" | "nl" | "nn" | "no" | "nso" | "oc" | "or" | "pa" | "pap" | "pl" | "pms" | "ps" | "pt" | "rm" | "ro" | "ru" | "rw" | "sah" | "sat" | "sco" | "sd" | "se" | "si" | "sk" | "sl" | "so" | "son" | "sq" | "sr" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "th" | "ti" | "tk" | "tr" | "tt" | "ug" | "uk" | "ur" | "uz" | "vi" | "wa" | "wo" | "yo" | "zh"; //#endregion
+//#region src/config.d.ts
+//#endregion
+//#region ../extract/dist/configuration-oHJyypq5.d.mts
+//#region src/logger.d.ts
+type Logger$1 = log.Logger;
+type LogLevelNames$1 = log.LogLevelNames;
+type LogLevel$1 = LogLevelNames$1; //#endregion
+//#region src/plugins/cleanup/cleanup.d.ts
+declare function cleanup$1(): Plugin; //#endregion
+//#region src/plugins/core/queries/types.d.ts
+interface Comments {
+  translator?: string;
+  reference?: string;
+  extracted?: string;
+  flag?: string;
+  previous?: string;
+}
+interface Translation {
+  context?: string;
+  id: string;
+  plural?: string;
+  message: string[];
+  comments?: Comments;
+  obsolete?: boolean;
+} //#endregion
+//#region src/plugins/core/core.d.ts
+declare function core$1(): Plugin<string, Translation[]>; //#endregion
+//#region src/plugins/po/po.d.ts
+declare function po$1(): Plugin; //#endregion
+//#region src/plugins/react/react.d.ts
+declare function react$1(): Plugin<string, Translation[]>; //#endregion
+//#region src/static.d.ts
+declare function core(...props: Parameters<typeof core$1>): {
+  readonly static: {
+    readonly name: "core";
+    readonly props: [];
+  };
+};
+declare function react(...props: Parameters<typeof react$1>): {
+  readonly static: {
+    readonly name: "react";
+    readonly props: [];
+  };
+};
+declare function po(...props: Parameters<typeof po$1>): {
+  readonly static: {
+    readonly name: "po";
+    readonly props: [];
+  };
+};
+declare function cleanup(...props: Parameters<typeof cleanup$1>): {
+  readonly static: {
+    readonly name: "cleanup";
+    readonly props: [];
+  };
+};
+type StaticPlugin = ReturnType<typeof core> | ReturnType<typeof react> | ReturnType<typeof po> | ReturnType<typeof cleanup>; //#endregion
+//#region src/plugin.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface Context {
+  config: ResolvedConfig;
+  generatedAt: Date;
+  paths: Set<string>;
+  logger?: Logger$1;
+}
+interface ImportReference {
+  spec: string;
+  kind: "static" | "dynamic";
+  typeOnly: boolean;
+}
+interface ResolveArgs<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  import?: ImportReference;
+  data?: TInput;
+}
+interface ResolveResult<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  import?: ImportReference;
+  data?: TInput;
+}
+interface LoadArgs<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data?: TInput;
+}
+interface LoadResult<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data: TInput;
+}
+interface ProcessArgs<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data: TInput;
+}
+interface ProcessResult<TOutput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data: TOutput;
+}
+type Filter = {
+  filter: RegExp;
+  namespace?: string;
+};
+type ResolveHook<TInput = unknown> = (args: ResolveArgs<TInput>) => MaybePromise<ResolveResult<TInput> | undefined>;
+type LoadHook<TInput = unknown> = (args: LoadArgs<TInput>) => MaybePromise<LoadResult<TInput> | undefined>;
+type ProcessHook<TInput = unknown, TOutput = unknown> = (args: ProcessArgs<TInput>) => MaybePromise<ProcessResult<TOutput> | undefined>;
+interface Build<TInput = unknown, TOutput = unknown> {
+  context: Context;
+  source(path: string): void;
+  resolve(args: ResolveArgs<unknown>): void;
+  load(args: LoadArgs<unknown>): void;
+  process(args: ProcessArgs<unknown>): void;
+  defer(namespace: string): Promise<void>;
+  onResolve(options: Filter, hook: ResolveHook<TInput>): void;
+  onLoad(options: Filter, hook: LoadHook<TInput>): void;
+  onProcess(options: Filter, hook: ProcessHook<TInput, TOutput>): void;
+}
+interface Plugin<TInput = unknown, TOutput = unknown> {
+  name: string;
+  setup(build: Build<TInput, TOutput>): void;
+}
+type UniversalPlugin = Plugin | StaticPlugin; //#endregion
+//#region src/exclude.d.ts
+declare const defaultExclude: {
+  readonly modules: ({
+    path
+  }: ResolveArgs) => boolean;
+  readonly dist: ({
+    path
+  }: ResolveArgs) => boolean;
+  readonly build: ({
+    path
+  }: ResolveArgs) => boolean;
+  readonly types: ({
+    import: imp
+  }: ResolveArgs) => boolean;
+};
+type DefaultExclude = typeof defaultExclude; //#endregion
+//#region src/configuration.d.ts
+type DestinationFn = (args: {
+  locale: string;
+  entrypoint: string;
+  path: string;
+}) => string;
+type ExcludeFn = (args: ResolveArgs) => boolean;
+type Exclude = RegExp | ExcludeFn;
+type ExcludeConfig = RegExp | Exclude[] | ((defaultExclude: DefaultExclude) => Exclude[]);
+declare const defaultPlugins: {
+  core: typeof core;
+  po: typeof po;
+  cleanup: typeof cleanup;
+};
+type DefaultPlugins = typeof defaultPlugins;
+/**
+ * Strategy to handle obsolete translations in existing locale files:
+ * - "mark": keep obsolete entries in the locale file but mark them as obsolete
+ * - "remove": remove obsolete entries from the locale file
+ */
+type ObsoleteStrategy = "mark" | "remove";
+interface EntrypointConfig {
+  entrypoint: string;
+  destination?: DestinationFn;
+  obsolete?: ObsoleteStrategy;
+  walk?: boolean;
+  exclude?: ExcludeConfig;
+}
+interface UserConfig {
+  /**
+   * Default locale to use as the base for extraction
+   * @default "en"
+   * @see {@link PluralFormsLocale} for available locales
+   */
+  defaultLocale?: PluralFormsLocale;
+  /**
+   * Array of locales to extract translations for
+   * @default [defaultLocale]
+   * @see {@link PluralFormsLocale} for available locales
+   */
+  locales?: PluralFormsLocale[];
+  /**
+   * Array of plugins to use or a function to override the default plugins
+   * @default DefaultPlugins
+   * @see {@link DefaultPlugins} for available plugins
+   */
+  plugins?: UniversalPlugin[] | ((defaultPlugins: DefaultPlugins) => UniversalPlugin[]);
+  /**
+   * One or more entrypoints to extract translations from, could be:
+   * - file path, will be treated as a single file entrypoint
+   * - glob pattern will be expanded to match files, each treated as a separate entrypoint
+   * - configuration object with options for the entrypoint
+   * @see {@link EntrypointConfig} for configuration options
+   */
+  entrypoints: string | EntrypointConfig | Array<string | EntrypointConfig>;
+  /**
+   * Function to determine the destination path for each extracted locale file
+   * @default `./translations/entrypoint.locale.po`
+   * @see {@link DestinationFn}
+   * @see Can be overridden per entrypoint via `destination` in {@link EntrypointConfig
+   */
+  destination?: DestinationFn;
+  /**
+   * Strategy to handle obsolete translations in existing locale files
+   * @default "mark"
+   * @see {@link ObsoleteStrategy} for available strategies
+   * @see Can be overridden per entrypoint via `obsolete` in {@link EntrypointConfig
+   */
+  obsolete?: ObsoleteStrategy;
+  /**
+   * Whether to recursively walk dependencies of the entrypoints
+   * @default true
+   * @see Can be overridden per entrypoint via `walk` in {@link EntrypointConfig}.
+   */
+  walk?: boolean;
+  /**
+   * Paths or patterns to exclude from extraction, applied to all entrypoints
+   * @default [/node_modules/, /dist/, /build/]
+   * @see Can be overridden per entrypoint via `exclude` in {@link EntrypointConfig}.
+   */
+  exclude?: ExcludeConfig;
+  /**
+   * Log level for the extraction process
+   * @default "info"
+   */
+  logLevel?: LogLevel$1;
+}
+interface ResolvedEntrypoint extends Omit<EntrypointConfig, "exclude"> {
+  exclude?: Exclude[];
+}
+interface ResolvedConfig {
+  plugins: UniversalPlugin[];
+  entrypoints: ResolvedEntrypoint[];
+  defaultLocale: string;
+  locales: string[];
+  destination: DestinationFn;
+  obsolete: ObsoleteStrategy;
+  walk: boolean;
+  logLevel: LogLevel$1;
+  exclude: Exclude[];
+}
+/**
+ * Type helper to make it easier to use translate.config.ts
+ * @param config - {@link UserConfig}.
+ */
+declare function defineConfig(config: UserConfig): ResolvedConfig; //#endregion
+//#endregion
+export { Build, Context, DestinationFn, EntrypointConfig, Exclude, ExcludeConfig, ExcludeFn, Filter, ImportReference, LoadArgs, LoadHook, LoadResult, ObsoleteStrategy, Plugin, ProcessArgs, ProcessHook, ProcessResult, ResolveArgs, ResolveHook, ResolveResult, ResolvedConfig, ResolvedEntrypoint, StaticPlugin, UniversalPlugin, UserConfig, cleanup, core, defineConfig, po, react };

package/dist/src/{index.js → index.mjs}

@@ -1,6 +1,20 @@
 import { basename, dirname, extname, join } from "node:path";
-
-//#region ../extract/src/static.ts
+//#region ../extract/dist/exclude-CpTGSisK.mjs
+function normalizedPath(path) {
+	return path.replace(/\\/g, "/");
+}
+function isInsideDirectory(path, directory) {
+	return normalizedPath(path).split("/").some((part) => part === directory);
+}
+const defaultExclude = {
+	modules: ({ path }) => isInsideDirectory(path, "node_modules"),
+	dist: ({ path }) => isInsideDirectory(path, "dist"),
+	build: ({ path }) => isInsideDirectory(path, "build"),
+	types: ({ import: imp }) => imp?.typeOnly ?? false
+};
+const defaultExcludes = Object.values(defaultExclude);
+//#endregion
+//#region ../extract/dist/src/static.mjs
 function core(...props) {
 	return { static: {
 		name: "core",
@@ -25,24 +39,22 @@ function cleanup(...props) {
 		props
 	} };
 }
-
 //#endregion
-//#region ../extract/src/configuration.ts
+//#region ../extract/dist/src/core.mjs
 const defaultPlugins = {
 	core,
 	po,
 	cleanup
 };
 const defaultDestination = ({ entrypoint, locale }) => join(dirname(entrypoint), "translations", `${basename(entrypoint, extname(entrypoint))}.${locale}.po`);
-const defaultExclude = [
-	/(?:^|[\\/])node_modules(?:[\\/]|$)/,
-	/(?:^|[\\/])dist(?:[\\/]|$)/,
-	/(?:^|[\\/])build(?:[\\/]|$)/
-];
 function normalizeExclude(exclude) {
 	if (!exclude) return [];
 	return Array.isArray(exclude) ? exclude : [exclude];
 }
+function resolveExcludes(exclude) {
+	if (typeof exclude === "function") return exclude(defaultExclude);
+	return [...defaultExcludes, ...normalizeExclude(exclude)];
+}
 function resolveEntrypoint(ep) {
 	if (typeof ep === "string") return { entrypoint: ep };
 	const { entrypoint, destination, obsolete, walk, exclude } = ep;
@@ -51,7 +63,7 @@ function resolveEntrypoint(ep) {
 		destination,
 		obsolete,
 		walk,
-		exclude: exclude ? normalizeExclude(exclude) : void 0
+		exclude: exclude ? resolveExcludes(exclude) : void 0
 	};
 }
 function resolvePlugins(user) {
@@ -65,20 +77,17 @@ function resolvePlugins(user) {
 */
 function defineConfig(config) {
 	const defaultLocale = config.defaultLocale ?? "en";
-	const plugins = resolvePlugins(config.plugins);
-	const entrypoints = (Array.isArray(config.entrypoints) ? config.entrypoints : [config.entrypoints]).map(resolveEntrypoint);
 	return {
-		plugins,
-		entrypoints,
+		plugins: resolvePlugins(config.plugins),
+		entrypoints: (Array.isArray(config.entrypoints) ? config.entrypoints : [config.entrypoints]).map(resolveEntrypoint),
 		defaultLocale,
 		locales: config.locales ?? [defaultLocale],
 		destination: config.destination ?? defaultDestination,
 		obsolete: config.obsolete ?? "mark",
 		walk: config.walk ?? true,
 		logLevel: config.logLevel ?? "info",
-		exclude: config.exclude ? normalizeExclude(config.exclude) : defaultExclude
+		exclude: resolveExcludes(config.exclude)
 	};
 }
-
 //#endregion
-export { cleanup, core, defineConfig, po, react };
+export { cleanup, core, defineConfig, po, react };

package/package.json

@@ -1,41 +1,46 @@
 {
-    "name": "@let-value/translate-extract-static",
-    "version": "1.1.2",
-    "type": "module",
-    "main": "./dist/src/index.cjs",
-    "module": "./dist/src/index.js",
-    "types": "./dist/src/index.d.ts",
-    "bin": {
-        "extract": "./dist/bin/cli.js"
+  "name": "@let-value/translate-extract-static",
+  "version": "1.1.6-beta.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/let-value/translate"
+  },
+  "bin": {
+    "extract": "./dist/bin/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "postinstall.cjs"
+  ],
+  "type": "module",
+  "main": "./dist/src/index.cjs",
+  "module": "./dist/src/index.mjs",
+  "types": "./dist/src/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.mts",
+      "import": "./dist/src/index.mjs",
+      "require": "./dist/src/index.cjs"
     },
-    "exports": {
-        ".": {
-            "types": "./dist/src/index.d.ts",
-            "import": "./dist/src/index.js",
-            "require": "./dist/src/index.cjs"
-        },
-        "./package.json": "./package.json"
-    },
-    "files": [
-        "dist",
-        "postinstall.cjs"
-    ],
-    "scripts": {
-        "postinstall": "node postinstall.cjs",
-        "build": "tsdown",
-        "check": "biome check .",
-        "format": "biome check --write .",
-        "typecheck": "tsc --build",
-        "test": "node --test"
-    },
-    "devDependencies": {
-        "@let-value/translate-extract": "1.1.2",
-        "@types/bun": "1.3.8",
-        "@types/node": "22.10.2",
-        "tsdown": "0.15.2",
-        "typescript": "5.9.2"
-    },
-    "dependencies": {
-        "detect-libc": "2.1.2"
-    }
-}
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "detect-libc": "2.1.2"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "@types/node": "26.0.1",
+    "typescript": "6.0.3",
+    "vite-plus": "latest",
+    "@let-value/translate-extract": "1.1.6-beta.1",
+    "@let-value/translate": "1.1.6-beta.1"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.cjs",
+    "build": "vp pack",
+    "check": "vp check",
+    "format": "vp fmt",
+    "typecheck": "tsc --build",
+    "test": "vp test"
+  }
+}

package/dist/binary-B-BK0iD4.cjs

@@ -1,37 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
-let detect_libc = require("detect-libc");
-detect_libc = require_chunk.__toESM(detect_libc);
-
-//#region src/binary.ts
-const root = (0, node_path.resolve)(__dirname, "..");
-const platform = process.platform;
-const arch = process.arch;
-const libc = (0, detect_libc.familySync)() || null;
-function getBinaryName(platform$1, arch$1, libc$1) {
-	const extension = platform$1 === "win32" ? ".exe" : "";
-	return `extract-${platform$1}-${arch$1}${libc$1 ? `-${libc$1}` : ""}${extension}`;
-}
-const binaryName = getBinaryName(platform, arch, libc);
-const binaryPath = (0, node_path.resolve)(root, "prebuilts", binaryName);
-
-//#endregion
-Object.defineProperty(exports, 'binaryName', {
-  enumerable: true,
-  get: function () {
-    return binaryName;
-  }
-});
-Object.defineProperty(exports, 'binaryPath', {
-  enumerable: true,
-  get: function () {
-    return binaryPath;
-  }
-});
-Object.defineProperty(exports, 'platform', {
-  enumerable: true,
-  get: function () {
-    return platform;
-  }
-});

package/dist/chunk-CUT6urMc.cjs

@@ -1,30 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});