plotlink-ows 0.1.13

package/packages/cli/node_modules/tsup/dist/index.d.ts

@@ -0,0 +1,511 @@
+import { BuildOptions, Metafile, Plugin as Plugin$1, Loader } from 'esbuild';
+import { SourceMap, TreeshakingOptions, TreeshakingPreset, InputOption } from 'rollup';
+import { SectionedSourceMapInput } from './types.cts';
+import { RawSourceMap } from 'source-map';
+import { Options as Options$1 } from '@swc/core';
+
+/// <reference lib="es2015" />
+
+
+
+type ECMA = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020;
+
+type ConsoleProperty = keyof typeof console;
+type DropConsoleOption = boolean | ConsoleProperty[];
+
+interface ParseOptions {
+    bare_returns?: boolean;
+    /** @deprecated legacy option. Currently, all supported EcmaScript is valid to parse. */
+    ecma?: ECMA;
+    html5_comments?: boolean;
+    shebang?: boolean;
+}
+
+interface CompressOptions {
+    arguments?: boolean;
+    arrows?: boolean;
+    booleans_as_integers?: boolean;
+    booleans?: boolean;
+    collapse_vars?: boolean;
+    comparisons?: boolean;
+    computed_props?: boolean;
+    conditionals?: boolean;
+    dead_code?: boolean;
+    defaults?: boolean;
+    directives?: boolean;
+    drop_console?: DropConsoleOption;
+    drop_debugger?: boolean;
+    ecma?: ECMA;
+    evaluate?: boolean;
+    expression?: boolean;
+    global_defs?: object;
+    hoist_funs?: boolean;
+    hoist_props?: boolean;
+    hoist_vars?: boolean;
+    ie8?: boolean;
+    if_return?: boolean;
+    inline?: boolean | InlineFunctions;
+    join_vars?: boolean;
+    keep_classnames?: boolean | RegExp;
+    keep_fargs?: boolean;
+    keep_fnames?: boolean | RegExp;
+    keep_infinity?: boolean;
+    lhs_constants?: boolean;
+    loops?: boolean;
+    module?: boolean;
+    negate_iife?: boolean;
+    passes?: number;
+    properties?: boolean;
+    pure_funcs?: string[];
+    pure_new?: boolean;
+    pure_getters?: boolean | 'strict';
+    reduce_funcs?: boolean;
+    reduce_vars?: boolean;
+    sequences?: boolean | number;
+    side_effects?: boolean;
+    switches?: boolean;
+    toplevel?: boolean;
+    top_retain?: null | string | string[] | RegExp;
+    typeofs?: boolean;
+    unsafe_arrows?: boolean;
+    unsafe?: boolean;
+    unsafe_comps?: boolean;
+    unsafe_Function?: boolean;
+    unsafe_math?: boolean;
+    unsafe_symbols?: boolean;
+    unsafe_methods?: boolean;
+    unsafe_proto?: boolean;
+    unsafe_regexp?: boolean;
+    unsafe_undefined?: boolean;
+    unused?: boolean;
+}
+
+declare enum InlineFunctions {
+    Disabled = 0,
+    SimpleFunctions = 1,
+    WithArguments = 2,
+    WithArgumentsAndVariables = 3
+}
+
+interface MangleOptions {
+    eval?: boolean;
+    keep_classnames?: boolean | RegExp;
+    keep_fnames?: boolean | RegExp;
+    module?: boolean;
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler;
+    properties?: boolean | ManglePropertiesOptions;
+    reserved?: string[];
+    safari10?: boolean;
+    toplevel?: boolean;
+}
+
+/**
+ * An identifier mangler for which the output is invariant with respect to the source code.
+ */
+interface SimpleIdentifierMangler {
+    /**
+     * Obtains the nth most favored (usually shortest) identifier to rename a variable to.
+     * The mangler will increment n and retry until the return value is not in use in scope, and is not a reserved word.
+     * This function is expected to be stable; Evaluating get(n) === get(n) should always return true.
+     * @param n The ordinal of the identifier.
+     */
+    get(n: number): string;
+}
+
+/**
+ * An identifier mangler that leverages character frequency analysis to determine identifier precedence.
+ */
+interface WeightedIdentifierMangler extends SimpleIdentifierMangler {
+    /**
+     * Modifies the internal weighting of the input characters by the specified delta.
+     * Will be invoked on the entire printed AST, and then deduct mangleable identifiers.
+     * @param chars The characters to modify the weighting of.
+     * @param delta The numeric weight to add to the characters.
+     */
+    consider(chars: string, delta: number): number;
+    /**
+     * Resets character weights.
+     */
+    reset(): void;
+    /**
+     * Sorts identifiers by character frequency, in preparation for calls to get(n).
+     */
+    sort(): void;
+}
+
+interface ManglePropertiesOptions {
+    builtins?: boolean;
+    debug?: boolean;
+    keep_quoted?: boolean | 'strict';
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler;
+    regex?: RegExp | string;
+    reserved?: string[];
+}
+
+interface FormatOptions {
+    ascii_only?: boolean;
+    /** @deprecated Not implemented anymore */
+    beautify?: boolean;
+    braces?: boolean;
+    comments?: boolean | 'all' | 'some' | RegExp | ( (node: any, comment: {
+        value: string,
+        type: 'comment1' | 'comment2' | 'comment3' | 'comment4',
+        pos: number,
+        line: number,
+        col: number,
+    }) => boolean );
+    ecma?: ECMA;
+    ie8?: boolean;
+    keep_numbers?: boolean;
+    indent_level?: number;
+    indent_start?: number;
+    inline_script?: boolean;
+    keep_quoted_props?: boolean;
+    max_line_len?: number | false;
+    preamble?: string;
+    preserve_annotations?: boolean;
+    quote_keys?: boolean;
+    quote_style?: OutputQuoteStyle;
+    safari10?: boolean;
+    semicolons?: boolean;
+    shebang?: boolean;
+    shorthand?: boolean;
+    source_map?: SourceMapOptions;
+    webkit?: boolean;
+    width?: number;
+    wrap_iife?: boolean;
+    wrap_func_args?: boolean;
+}
+
+declare enum OutputQuoteStyle {
+    PreferDouble = 0,
+    AlwaysSingle = 1,
+    AlwaysDouble = 2,
+    AlwaysOriginal = 3
+}
+
+interface MinifyOptions {
+    compress?: boolean | CompressOptions;
+    ecma?: ECMA;
+    enclose?: boolean | string;
+    ie8?: boolean;
+    keep_classnames?: boolean | RegExp;
+    keep_fnames?: boolean | RegExp;
+    mangle?: boolean | MangleOptions;
+    module?: boolean;
+    nameCache?: object;
+    format?: FormatOptions;
+    /** @deprecated */
+    output?: FormatOptions;
+    parse?: ParseOptions;
+    safari10?: boolean;
+    sourceMap?: boolean | SourceMapOptions;
+    toplevel?: boolean;
+}
+
+interface SourceMapOptions {
+    /** Source map object, 'inline' or source map file content */
+    content?: SectionedSourceMapInput | string;
+    includeSources?: boolean;
+    filename?: string;
+    root?: string;
+    asObject?: boolean;
+    url?: string | 'inline';
+}
+
+type Prettify<Type> = Type extends Function ? Type : Extract<{
+    [Key in keyof Type]: Type[Key];
+}, Type>;
+
+type MarkRequired<Type, Keys extends keyof Type> = Type extends Type ? Prettify<Type & Required<Omit<Type, Exclude<keyof Type, Keys>>>> : never;
+
+type Logger = ReturnType<typeof createLogger>;
+declare const createLogger: (name?: string) => {
+    setName(_name: string): void;
+    success(label: string, ...args: any[]): void;
+    info(label: string, ...args: any[]): void;
+    error(label: string, ...args: any[]): void;
+    warn(label: string, ...args: any[]): void;
+    log(label: string, type: "info" | "success" | "error" | "warn", ...data: unknown[]): void;
+};
+
+type ChunkInfo = {
+    type: 'chunk';
+    code: string;
+    map?: string | RawSourceMap | null;
+    path: string;
+    /**
+     * Sets the file mode
+     */
+    mode?: number;
+    entryPoint?: string;
+    exports?: string[];
+    imports?: Metafile['outputs'][string]['imports'];
+};
+type RenderChunk = (this: PluginContext, code: string, chunkInfo: ChunkInfo) => MaybePromise<{
+    code: string;
+    map?: object | string | SourceMap | null;
+} | undefined | null | void>;
+type BuildStart = (this: PluginContext) => MaybePromise<void>;
+type BuildEnd = (this: PluginContext, ctx: {
+    writtenFiles: WrittenFile[];
+}) => MaybePromise<void>;
+type ModifyEsbuildOptions = (this: PluginContext, options: BuildOptions) => void;
+type Plugin = {
+    name: string;
+    esbuildOptions?: ModifyEsbuildOptions;
+    buildStart?: BuildStart;
+    renderChunk?: RenderChunk;
+    buildEnd?: BuildEnd;
+};
+type PluginContext = {
+    format: Format;
+    splitting?: boolean;
+    options: NormalizedOptions;
+    logger: Logger;
+};
+type WrittenFile = {
+    readonly name: string;
+    readonly size: number;
+};
+
+type TreeshakingStrategy = boolean | TreeshakingOptions | TreeshakingPreset;
+
+type SwcPluginConfig = {
+    logger: Logger;
+} & Options$1;
+
+type KILL_SIGNAL = 'SIGKILL' | 'SIGTERM';
+type Format = 'cjs' | 'esm' | 'iife';
+type ContextForOutPathGeneration = {
+    options: NormalizedOptions;
+    format: Format;
+    /** "type" field in project's package.json */
+    pkgType?: string;
+};
+type OutExtensionObject = {
+    js?: string;
+    dts?: string;
+};
+type OutExtensionFactory = (ctx: ContextForOutPathGeneration) => OutExtensionObject;
+type DtsConfig = {
+    entry?: InputOption;
+    /** Resolve external types used in dts files from node_modules */
+    resolve?: boolean | (string | RegExp)[];
+    /** Emit declaration files only */
+    only?: boolean;
+    /** Insert at the top of each output .d.ts file  */
+    banner?: string;
+    /** Insert at the bottom */
+    footer?: string;
+    /**
+     * Overrides `compilerOptions`
+     * This option takes higher priority than `compilerOptions` in tsconfig.json
+     */
+    compilerOptions?: any;
+};
+type ExperimentalDtsConfig = {
+    entry?: InputOption;
+    /**
+     * Overrides `compilerOptions`
+     * This option takes higher priority than `compilerOptions` in tsconfig.json
+     */
+    compilerOptions?: any;
+};
+type BannerOrFooter = {
+    js?: string;
+    css?: string;
+} | ((ctx: {
+    format: Format;
+}) => {
+    js?: string;
+    css?: string;
+} | undefined);
+type BrowserTarget = 'chrome' | 'deno' | 'edge' | 'firefox' | 'hermes' | 'ie' | 'ios' | 'node' | 'opera' | 'rhino' | 'safari';
+type BrowserTargetWithVersion = `${BrowserTarget}${number}` | `${BrowserTarget}${number}.${number}` | `${BrowserTarget}${number}.${number}.${number}`;
+type EsTarget = 'es3' | 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023' | 'es2024' | 'esnext';
+type Target = BrowserTarget | BrowserTargetWithVersion | EsTarget | (string & {});
+type Entry = string[] | Record<string, string>;
+/**
+ * The options available in tsup.config.ts
+ * Not all of them are available from CLI flags
+ */
+type Options = {
+    /** Optional config name to show in CLI output */
+    name?: string;
+    /**
+     * @deprecated Use `entry` instead
+     */
+    entryPoints?: Entry;
+    entry?: Entry;
+    /**
+     * Output different formats to different folder instead of using different extensions
+     */
+    legacyOutput?: boolean;
+    /**
+     * Compile target
+     *
+     * default to `node16`
+     */
+    target?: Target | Target[];
+    minify?: boolean | 'terser';
+    terserOptions?: MinifyOptions;
+    minifyWhitespace?: boolean;
+    minifyIdentifiers?: boolean;
+    minifySyntax?: boolean;
+    keepNames?: boolean;
+    watch?: boolean | string | (string | boolean)[];
+    ignoreWatch?: string[] | string;
+    onSuccess?: string | (() => Promise<void | undefined | (() => void | Promise<void>)>);
+    jsxFactory?: string;
+    jsxFragment?: string;
+    outDir?: string;
+    outExtension?: OutExtensionFactory;
+    format?: Format[] | Format;
+    globalName?: string;
+    env?: {
+        [k: string]: string;
+    };
+    define?: {
+        [k: string]: string;
+    };
+    dts?: boolean | string | DtsConfig;
+    experimentalDts?: boolean | string | ExperimentalDtsConfig;
+    sourcemap?: boolean | 'inline';
+    /** Always bundle modules matching given patterns */
+    noExternal?: (string | RegExp)[];
+    /** Don't bundle these modules */
+    external?: (string | RegExp)[];
+    /**
+     * Replace `process.env.NODE_ENV` with `production` or `development`
+     * `production` when the bundled is minified, `development` otherwise
+     */
+    replaceNodeEnv?: boolean;
+    /**
+     * Code splitting
+     * Default to `true` for ESM, `false` for CJS.
+     *
+     * You can set it to `true` explicitly, and may want to disable code splitting sometimes: [`#255`](https://github.com/egoist/tsup/issues/255)
+     */
+    splitting?: boolean;
+    /**
+     * Clean output directory before each build
+     */
+    clean?: boolean | string[];
+    esbuildPlugins?: Plugin$1[];
+    esbuildOptions?: (options: BuildOptions, context: {
+        format: Format;
+    }) => void;
+    /**
+     * Suppress non-error logs (excluding "onSuccess" process output)
+     */
+    silent?: boolean;
+    /**
+     * Skip node_modules bundling
+     * Will still bundle modules matching the `noExternal` option
+     */
+    skipNodeModulesBundle?: boolean;
+    /**
+     * @see https://esbuild.github.io/api/#pure
+     */
+    pure?: string | string[];
+    /**
+     * Disable bundling, default to true
+     */
+    bundle?: boolean;
+    /**
+     * This option allows you to automatically replace a global variable with an import from another file.
+     * @see https://esbuild.github.io/api/#inject
+     */
+    inject?: string[];
+    /**
+     * Emit esbuild metafile
+     * @see https://esbuild.github.io/api/#metafile
+     */
+    metafile?: boolean;
+    footer?: BannerOrFooter;
+    banner?: BannerOrFooter;
+    /**
+     * Target platform
+     * @default `node`
+     */
+    platform?: 'node' | 'browser' | 'neutral';
+    /**
+     * Esbuild loader option
+     */
+    loader?: Record<string, Loader>;
+    /**
+     * Disable config file with `false`
+     * Or pass a custom config filename
+     */
+    config?: boolean | string;
+    /**
+     * Use a custom tsconfig
+     */
+    tsconfig?: string;
+    /**
+     * Inject CSS as style tags to document head
+     * @default {false}
+     */
+    injectStyle?: boolean | ((css: string, fileId: string) => string | Promise<string>);
+    /**
+     * Inject cjs and esm shims if needed
+     * @default false
+     */
+    shims?: boolean;
+    /**
+     * TSUP plugins
+     * @experimental
+     * @alpha
+     */
+    plugins?: Plugin[];
+    /**
+     * By default esbuild already does treeshaking
+     *
+     * But this option allow you to perform additional treeshaking with Rollup
+     *
+     * This can result in smaller bundle size
+     */
+    treeshake?: TreeshakingStrategy;
+    /**
+     * Copy the files inside `publicDir` to output directory
+     */
+    publicDir?: string | boolean;
+    killSignal?: KILL_SIGNAL;
+    /**
+     * Interop default within `module.exports` in cjs
+     * @default false
+     */
+    cjsInterop?: boolean;
+    /**
+     * Remove `node:` protocol from imports
+     *
+     * The default value will be flipped to `false` in the next major release
+     * @default true
+     */
+    removeNodeProtocol?: boolean;
+    swc?: SwcPluginConfig;
+};
+interface NormalizedExperimentalDtsConfig {
+    entry: {
+        [entryAlias: string]: string;
+    };
+    compilerOptions?: any;
+}
+type NormalizedOptions = Omit<MarkRequired<Options, 'entry' | 'outDir'>, 'dts' | 'experimentalDts' | 'format'> & {
+    dts?: DtsConfig;
+    experimentalDts?: NormalizedExperimentalDtsConfig;
+    tsconfigResolvePaths: Record<string, string[]>;
+    tsconfigDecoratorMetadata?: boolean;
+    format: Format[];
+    swc?: SwcPluginConfig;
+};
+
+type MaybePromise<T> = T | Promise<T>;
+
+declare const defineConfig: (options: Options | Options[] | ((
+/** The options derived from CLI flags */
+overrideOptions: Options) => MaybePromise<Options | Options[]>)) => Options | Options[] | ((overrideOptions: Options) => MaybePromise<Options | Options[]>);
+declare function build(_options: Options): Promise<void>;
+
+export { type Format, type NormalizedOptions, type Options, build, defineConfig };