@umijs/bundler-webpack 3.5.19 → 4.0.0-beta.3

package/compiled/terser-webpack-plugin/minify.js

@@ -0,0 +1,43 @@
+"use strict";
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+
+/**
+ * @template T
+ * @param {import("./index.js").InternalOptions<T>} options
+ * @returns {Promise<MinimizedResult>}
+ */
+async function minify(options) {
+  const {
+    name,
+    input,
+    inputSourceMap,
+    extractComments
+  } = options;
+  const {
+    implementation,
+    options: minimizerOptions
+  } = options.minimizer;
+  return implementation({
+    [name]: input
+  }, inputSourceMap, minimizerOptions, extractComments);
+}
+/**
+ * @param {string} options
+ * @returns {Promise<MinimizedResult>}
+ */
+
+
+async function transform(options) {
+  // 'use strict' => this === undefined (Clean Scope)
+  // Safer for possible security issues, albeit not critical at all here
+  // eslint-disable-next-line no-param-reassign
+  const evaluatedOptions = // eslint-disable-next-line no-new-func
+  new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`)(exports, require, module, __filename, __dirname);
+  return minify(evaluatedOptions);
+}
+
+module.exports.minify = minify;
+module.exports.transform = transform;

package/compiled/terser-webpack-plugin/package.json

@@ -0,0 +1 @@
+{"name":"terser-webpack-plugin","author":"webpack Contrib Team","license":"MIT","types":"types/cjs.d.ts"}

package/compiled/terser-webpack-plugin/schema-utils/declarations/ValidationError.d.ts

@@ -0,0 +1,74 @@
+export default ValidationError;
+export type JSONSchema6 = import('../../json-schema').JSONSchema6;
+export type JSONSchema7 = import('../../json-schema').JSONSchema7;
+export type Schema = import('./validate').Schema;
+export type ValidationErrorConfiguration =
+  import('./validate').ValidationErrorConfiguration;
+export type PostFormatter = import('./validate').PostFormatter;
+export type SchemaUtilErrorObject = import('./validate').SchemaUtilErrorObject;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(
+    errors: Array<SchemaUtilErrorObject>,
+    schema: Schema,
+    configuration?: ValidationErrorConfiguration
+  );
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors: Array<SchemaUtilErrorObject>;
+  /** @type {Schema} */
+  schema: Schema;
+  /** @type {string} */
+  headerName: string;
+  /** @type {string} */
+  baseDataPath: string;
+  /** @type {PostFormatter | null} */
+  postFormatter: PostFormatter | null;
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(path: string): Schema;
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(
+    schema: Schema,
+    logic?: boolean,
+    prevSchemas?: Array<Object>
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
+  getSchemaPartText(
+    schemaPart?: Schema | undefined,
+    additionalPath?: (boolean | Array<string>) | undefined,
+    needDot?: boolean | undefined,
+    logic?: boolean | undefined
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(error: SchemaUtilErrorObject): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
+}

package/compiled/terser-webpack-plugin/schema-utils/declarations/index.d.ts

@@ -0,0 +1,3 @@
+import { validate } from './validate';
+import { ValidationError } from './validate';
+export { validate, ValidationError };

package/compiled/terser-webpack-plugin/schema-utils/declarations/validate.d.ts

@@ -0,0 +1,37 @@
+export type JSONSchema4 = import('../../json-schema').JSONSchema4;
+export type JSONSchema6 = import('../../json-schema').JSONSchema6;
+export type JSONSchema7 = import('../../json-schema').JSONSchema7;
+export type ErrorObject = import('../../ajv').ErrorObject;
+export type Extend = {
+  formatMinimum?: number | undefined;
+  formatMaximum?: number | undefined;
+  formatExclusiveMinimum?: boolean | undefined;
+  formatExclusiveMaximum?: boolean | undefined;
+  link?: string | undefined;
+};
+export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend;
+export type SchemaUtilErrorObject = ErrorObject & {
+  children?: Array<ErrorObject>;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: SchemaUtilErrorObject
+) => string;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+export function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+import ValidationError from './ValidationError';
+export { ValidationError };

package/compiled/terser-webpack-plugin/source-map/source-map.d.ts

@@ -0,0 +1,98 @@
+export interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+
+export interface Position {
+    line: number;
+    column: number;
+}
+
+export interface LineRange extends Position {
+    lastColumn: number;
+}
+
+export interface FindPosition extends Position {
+    // SourceMapConsumer.GREATEST_LOWER_BOUND or SourceMapConsumer.LEAST_UPPER_BOUND
+    bias?: number;
+}
+
+export interface SourceFindPosition extends FindPosition {
+    source: string;
+}
+
+export interface MappedPosition extends Position {
+    source: string;
+    name?: string;
+}
+
+export interface MappingItem {
+    source: string;
+    generatedLine: number;
+    generatedColumn: number;
+    originalLine: number;
+    originalColumn: number;
+    name: string;
+}
+
+export class SourceMapConsumer {
+    static GENERATED_ORDER: number;
+    static ORIGINAL_ORDER: number;
+
+    static GREATEST_LOWER_BOUND: number;
+    static LEAST_UPPER_BOUND: number;
+
+    constructor(rawSourceMap: RawSourceMap);
+    computeColumnSpans(): void;
+    originalPositionFor(generatedPosition: FindPosition): MappedPosition;
+    generatedPositionFor(originalPosition: SourceFindPosition): LineRange;
+    allGeneratedPositionsFor(originalPosition: MappedPosition): Position[];
+    hasContentsOfAllSources(): boolean;
+    sourceContentFor(source: string, returnNullOnMissing?: boolean): string;
+    eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
+}
+
+export interface Mapping {
+    generated: Position;
+    original: Position;
+    source: string;
+    name?: string;
+}
+
+export class SourceMapGenerator {
+    constructor(startOfSourceMap?: StartOfSourceMap);
+    static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator;
+    addMapping(mapping: Mapping): void;
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
+    toString(): string;
+}
+
+export interface CodeWithSourceMap {
+    code: string;
+    map: SourceMapGenerator;
+}
+
+export class SourceNode {
+    constructor();
+    constructor(line: number, column: number, source: string);
+    constructor(line: number, column: number, source: string, chunk?: string, name?: string);
+    static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode;
+    add(chunk: string): void;
+    prepend(chunk: string): void;
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
+    walkSourceContents(fn: (file: string, content: string) => void): void;
+    join(sep: string): SourceNode;
+    replaceRight(pattern: string, replacement: string): SourceNode;
+    toString(): string;
+    toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
+}

package/compiled/terser-webpack-plugin/types/cjs.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: typeof plugin.default;
+export = _exports;
+import plugin = require('./index');

package/compiled/terser-webpack-plugin/types/index.d.ts

@@ -0,0 +1,295 @@
+export default TerserPlugin;
+export type Schema = import('../schema-utils/declarations/validate').Schema;
+export type Compiler = import('../../webpack').Compiler;
+export type Compilation = import('../../webpack').Compilation;
+export type WebpackError = import('../../webpack').WebpackError;
+export type Asset = import('../../webpack').Asset;
+export type TerserECMA = import('./utils').TerserECMA;
+export type TerserOptions = import('./utils').TerserOptions;
+export type CustomOptions = import('./utils').CustomOptions;
+export type JestWorker = import('../jest-worker').Worker;
+export type RawSourceMap = import('../source-map').RawSourceMap;
+export type Rule = RegExp | string;
+export type Rules = Rule[] | Rule;
+export type ExtractCommentsFunction = (
+  astNode: any,
+  comment: {
+    value: string;
+    type: "comment1" | "comment2" | "comment3" | "comment4";
+    pos: number;
+    line: number;
+    col: number;
+  }
+) => boolean;
+export type ExtractCommentsCondition =
+  | boolean
+  | "all"
+  | "some"
+  | RegExp
+  | ExtractCommentsFunction;
+export type ExtractCommentsFilename = string | ((fileData: any) => string);
+export type ExtractCommentsBanner =
+  | string
+  | boolean
+  | ((commentsFile: string) => string);
+export type ExtractCommentsObject = {
+  condition?: ExtractCommentsCondition | undefined;
+  filename?: ExtractCommentsFilename | undefined;
+  banner?: ExtractCommentsBanner | undefined;
+};
+export type ExtractCommentsOptions =
+  | ExtractCommentsCondition
+  | ExtractCommentsObject;
+export type Input = {
+  [file: string]: string;
+};
+export type MinimizedResult = {
+  code: string;
+  map?: import('../source-map').RawSourceMap | undefined;
+  errors?: (string | Error)[] | undefined;
+  warnings?: (string | Error)[] | undefined;
+  extractedComments?: string[] | undefined;
+};
+export type PredefinedOptions = {
+  module?: boolean | undefined;
+  ecma?: any;
+};
+export type MinimizerImplementationAndOptions<T> = {
+  implementation: MinimizerImplementation<T>;
+  options: PredefinedOptions & T;
+};
+export type InternalOptions<T> = {
+  name: string;
+  input: string;
+  inputSourceMap: RawSourceMap | undefined;
+  extractComments: ExtractCommentsOptions | undefined;
+  minimizer: MinimizerImplementationAndOptions<T>;
+};
+export type MinimizerWorker<T> = Worker & {
+  transform: (options: string) => MinimizedResult;
+  minify: (options: InternalOptions<T>) => MinimizedResult;
+};
+export type BasicMinimizerImplementation<T> = (
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minifyOptions: T,
+  extractComments: ExtractCommentsOptions | undefined
+) => Promise<MinimizedResult>;
+export type MinimizeFunctionHelpers = {
+  getMinimizerVersion?: (() => string | undefined) | undefined;
+};
+export type MinimizerImplementation<T> = BasicMinimizerImplementation<T> &
+  MinimizeFunctionHelpers;
+export type Parallel = undefined | boolean | number;
+export type BasePluginOptions = {
+  test?: Rules | undefined;
+  include?: Rules | undefined;
+  exclude?: Rules | undefined;
+  extractComments?: ExtractCommentsOptions | undefined;
+  parallel?: Parallel;
+};
+export type InferDefaultType<T> = T extends infer U
+  ? U
+  : import('./utils').CustomOptions;
+export type DefinedDefaultMinimizerAndOptions<T> =
+  InferDefaultType<T> extends TerserOptions
+    ? {
+        minify?: MinimizerImplementation<InferDefaultType<T>> | undefined;
+        terserOptions?: InferDefaultType<T> | undefined;
+      }
+    : {
+        minify: MinimizerImplementation<InferDefaultType<T>>;
+        terserOptions?: InferDefaultType<T> | undefined;
+      };
+/** @typedef {import('../schema-utils/declarations/validate').Schema} Schema */
+/** @typedef {import('../../webpack').Compiler} Compiler */
+/** @typedef {import('../../webpack').Compilation} Compilation */
+/** @typedef {import('../../webpack').WebpackError} WebpackError */
+/** @typedef {import('../../webpack').Asset} Asset */
+/** @typedef {import('./utils').TerserECMA} TerserECMA */
+/** @typedef {import('./utils').TerserOptions} TerserOptions */
+/** @typedef {import('./utils').CustomOptions} CustomOptions */
+/** @typedef {import('../jest-worker').Worker} JestWorker */
+/** @typedef {import('../source-map').RawSourceMap} RawSourceMap */
+/** @typedef {RegExp | string} Rule */
+/** @typedef {Rule[] | Rule} Rules */
+/**
+ * @callback ExtractCommentsFunction
+ * @param {any} astNode
+ * @param {{ value: string, type: 'comment1' | 'comment2' | 'comment3' | 'comment4', pos: number, line: number, col: number }} comment
+ * @returns {boolean}
+ */
+/**
+ * @typedef {boolean | 'all' | 'some' | RegExp | ExtractCommentsFunction} ExtractCommentsCondition
+ */
+/**
+ * @typedef {string | ((fileData: any) => string)} ExtractCommentsFilename
+ */
+/**
+ * @typedef {boolean | string | ((commentsFile: string) => string)} ExtractCommentsBanner
+ */
+/**
+ * @typedef {Object} ExtractCommentsObject
+ * @property {ExtractCommentsCondition} [condition]
+ * @property {ExtractCommentsFilename} [filename]
+ * @property {ExtractCommentsBanner} [banner]
+ */
+/**
+ * @typedef {ExtractCommentsCondition | ExtractCommentsObject} ExtractCommentsOptions
+ */
+/**
+ * @typedef {{ [file: string]: string }} Input
+ */
+/**
+ * @typedef {Object} MinimizedResult
+ * @property {string} code
+ * @property {RawSourceMap} [map]
+ * @property {Array<Error | string>} [errors]
+ * @property {Array<Error | string>} [warnings]
+ * @property {Array<string>} [extractedComments]
+ */
+/**
+ * @typedef {Object} PredefinedOptions
+ * @property {boolean} [module]
+ * @property {any} [ecma]
+ */
+/**
+ * @template T
+ * @typedef {Object} MinimizerImplementationAndOptions
+ * @property {MinimizerImplementation<T>} implementation
+ * @property {PredefinedOptions & T} options
+ */
+/**
+ * @template T
+ * @typedef {Object} InternalOptions
+ * @property {string} name
+ * @property {string} input
+ * @property {RawSourceMap | undefined} inputSourceMap
+ * @property {ExtractCommentsOptions | undefined} extractComments
+ * @property {MinimizerImplementationAndOptions<T>} minimizer
+ */
+/**
+ * @template T
+ * @typedef {JestWorker & { transform: (options: string) => MinimizedResult, minify: (options: InternalOptions<T>) => MinimizedResult }} MinimizerWorker
+ */
+/**
+ * @template T
+ * @callback BasicMinimizerImplementation
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {T} minifyOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @returns {Promise<MinimizedResult>}
+ */
+/**
+ * @typedef {object} MinimizeFunctionHelpers
+ * @property {() => string | undefined} [getMinimizerVersion]
+ */
+/**
+ * @template T
+ * @typedef {BasicMinimizerImplementation<T> & MinimizeFunctionHelpers } MinimizerImplementation
+ */
+/**
+ * @typedef {undefined | boolean | number} Parallel
+ */
+/**
+ * @typedef {Object} BasePluginOptions
+ * @property {Rules} [test]
+ * @property {Rules} [include]
+ * @property {Rules} [exclude]
+ * @property {ExtractCommentsOptions} [extractComments]
+ * @property {Parallel} [parallel]
+ */
+/**
+ * @template T
+ * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
+ */
+/**
+ * @template T
+ * @typedef {InferDefaultType<T> extends TerserOptions ? { minify?: MinimizerImplementation<InferDefaultType<T>> | undefined, terserOptions?: InferDefaultType<T> | undefined } : { minify: MinimizerImplementation<InferDefaultType<T>>, terserOptions?: InferDefaultType<T> | undefined }} DefinedDefaultMinimizerAndOptions
+ */
+/**
+ * @template T
+ */
+declare class TerserPlugin<T = TerserOptions> {
+  /**
+   * @private
+   * @param {any} input
+   * @returns {boolean}
+   */
+  private static isSourceMap;
+  /**
+   * @private
+   * @param {Error | string} warning
+   * @param {string} file
+   * @returns {WebpackError}
+   */
+  private static buildWarning;
+  /**
+   * @private
+   * @param {any} error
+   * @param {string} file
+   * @param {Compilation["requestShortener"]} [requestShortener]
+   * @param {SourceMapConsumer} [sourceMap]
+   * @returns {WebpackError}
+   */
+  private static buildError;
+  /**
+   * @private
+   * @param {Parallel} parallel
+   * @returns {number}
+   */
+  private static getAvailableNumberOfCores;
+  /**
+   * @private
+   * @param {any} environment
+   * @returns {TerserECMA}
+   */
+  private static getEcmaVersion;
+  /**
+   * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>} [options]
+   */
+  constructor(
+    options?:
+      | (BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>)
+      | undefined
+  );
+  options: {
+    test: Rules;
+    extractComments: ExtractCommentsOptions;
+    parallel: number | boolean;
+    include: Rules | undefined;
+    exclude: Rules | undefined;
+    minimizer: {
+      implementation: MinimizerImplementation<
+        import('../../terser').MinifyOptions & InferDefaultType<T>
+      >;
+      options: InferDefaultType<T>;
+    };
+  };
+  /**
+   * @private
+   * @param {Compiler} compiler
+   * @param {Compilation} compilation
+   * @param {Record<string, import('../../webpack').sources.Source>} assets
+   * @param {{availableNumberOfCores: number}} optimizeOptions
+   * @returns {Promise<void>}
+   */
+  private optimize;
+  /**
+   * @param {Compiler} compiler
+   * @returns {void}
+   */
+  apply(compiler: Compiler): void;
+}
+declare namespace TerserPlugin {
+  export { terserMinify };
+  export { uglifyJsMinify };
+  export { swcMinify };
+  export { esbuildMinify };
+}
+import { Worker } from '../jest-worker';
+import { terserMinify } from './utils';
+import { uglifyJsMinify } from './utils';
+import { swcMinify } from './utils';
+import { esbuildMinify } from './utils';

package/compiled/terser-webpack-plugin/types/utils.d.ts

@@ -0,0 +1,105 @@
+export type RawSourceMap = import('../source-map').RawSourceMap;
+export type TerserFormatOptions = import('../../terser').FormatOptions;
+export type TerserOptions = import('../../terser').MinifyOptions;
+export type TerserECMA = import('../../terser').ECMA;
+export type ExtractCommentsOptions =
+  import('./index').ExtractCommentsOptions;
+export type ExtractCommentsFunction =
+  import('./index').ExtractCommentsFunction;
+export type ExtractCommentsCondition =
+  import('./index').ExtractCommentsCondition;
+export type Input = import('./index').Input;
+export type MinimizedResult = import('./index').MinimizedResult;
+export type PredefinedOptions = import('./index').PredefinedOptions;
+export type CustomOptions = {
+  [key: string]: any;
+};
+export type ExtractedComments = Array<string>;
+/** @typedef {import('../source-map').RawSourceMap} RawSourceMap */
+/** @typedef {import('../../terser').FormatOptions} TerserFormatOptions */
+/** @typedef {import('../../terser').MinifyOptions} TerserOptions */
+/** @typedef {import('../../terser').ECMA} TerserECMA */
+/** @typedef {import('./index').ExtractCommentsOptions} ExtractCommentsOptions */
+/** @typedef {import('./index').ExtractCommentsFunction} ExtractCommentsFunction */
+/** @typedef {import('./index').ExtractCommentsCondition} ExtractCommentsCondition */
+/** @typedef {import('./index').Input} Input */
+/** @typedef {import('./index').MinimizedResult} MinimizedResult */
+/** @typedef {import('./index').PredefinedOptions} PredefinedOptions */
+/**
+ * @typedef {{ [key: string]: any }} CustomOptions
+ */
+/**
+ * @typedef {Array<string>} ExtractedComments
+ */
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @return {Promise<MinimizedResult>}
+ */
+export function terserMinify(
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minimizerOptions: PredefinedOptions & CustomOptions,
+  extractComments: ExtractCommentsOptions | undefined
+): Promise<MinimizedResult>;
+export namespace terserMinify {
+  /**
+   * @returns {string | undefined}
+   */
+  function getMinimizerVersion(): string | undefined;
+}
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @return {Promise<MinimizedResult>}
+ */
+export function uglifyJsMinify(
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minimizerOptions: PredefinedOptions & CustomOptions,
+  extractComments: ExtractCommentsOptions | undefined
+): Promise<MinimizedResult>;
+export namespace uglifyJsMinify {
+  /**
+   * @returns {string | undefined}
+   */
+  function getMinimizerVersion(): string | undefined;
+}
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+export function swcMinify(
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minimizerOptions: PredefinedOptions & CustomOptions
+): Promise<MinimizedResult>;
+export namespace swcMinify {
+  /**
+   * @returns {string | undefined}
+   */
+  function getMinimizerVersion(): string | undefined;
+}
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+export function esbuildMinify(
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minimizerOptions: PredefinedOptions & CustomOptions
+): Promise<MinimizedResult>;
+export namespace esbuildMinify {
+  /**
+   * @returns {string | undefined}
+   */
+  function getMinimizerVersion(): string | undefined;
+}