@rsdoctor/components 1.2.0 → 1.2.1

package/dist/pages/BundleSize/components/search-modal.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const SearchModal: React.FC<{
+    onModuleClick?: (module: any) => void;
+    onClose?: () => void;
+    open?: boolean;
+    setOpen?: (open: boolean) => void;
+    isIcon?: boolean;
+}>;

package/dist/pages/BundleSize/config.d.ts

@@ -0,0 +1,6 @@
+interface config {
+    setModuleJumpList(ids: number[]): void;
+    moduleJumpList: number[];
+}
+export declare const ModuleGraphListContext: import("react").Context<config>;
+export {};

package/dist/pages/BundleSize/constants.d.ts

@@ -0,0 +1,5 @@
+import { Client } from '@rsdoctor/types';
+export declare const maxModuleSize = 5000;
+export declare const name = "BundleSize";
+export declare const route = Client.RsdoctorClientRoutes.BundleSize;
+export type GraphType = 'tile' | 'tree';

package/dist/pages/BundleSize/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/ModuleAnalyze/chunks.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+import React from 'react';
+import './index.sass';
+export declare const ChunksTable: React.FC<{
+    chunks: SDK.ChunkData[];
+}>;

package/dist/pages/ModuleAnalyze/components/fileTreeCom.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { NewTreeNodeType } from '../utils/hooks';
+import './fileTreeCom.scss';
+type FileTreeProps = {
+    treeData: NewTreeNodeType[];
+    needCode?: boolean;
+    needShowAllTree?: boolean;
+    needJumpto?: boolean;
+    defaultOpened?: boolean;
+    defaultOpenFather?: number;
+    cwd: string;
+    selectedChunk?: string;
+};
+export declare const FileTree: React.FC<FileTreeProps>;
+export {};

package/dist/pages/ModuleAnalyze/constants.d.ts

@@ -0,0 +1,7 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Module Analyze";
+export declare const route = Client.RsdoctorClientRoutes.ModuleAnalyze;
+export declare enum DevtoolsRuleClientConstant {
+    UrlQueryForModuleAnalyze = "curModuleId"
+}
+export declare const clsNamePrefix = "module-analyze";

package/dist/pages/ModuleAnalyze/dependency.d.ts

@@ -0,0 +1,9 @@
+import { SDK } from '@rsdoctor/types';
+import React from 'react';
+import './index.sass';
+declare const _default: React.NamedExoticComponent<{
+    module: SDK.ModuleData;
+    dependencies: SDK.DependencyData[];
+    cwd: string;
+}>;
+export default _default;

package/dist/pages/ModuleAnalyze/fileTree.d.ts

@@ -0,0 +1,10 @@
+import { SDK } from '@rsdoctor/types';
+import React from 'react';
+export declare const ModuleFilesTree: React.FC<{
+    modules: SDK.ModuleData[];
+    dependencies: SDK.DependencyData[];
+    curModule: SDK.ModuleData;
+    cwd: string;
+    selectedChunk: string;
+    activeTabKey: string;
+}>;

package/dist/pages/ModuleAnalyze/index.d.ts

@@ -0,0 +1,15 @@
+import { SDK } from '@rsdoctor/types';
+import React from 'react';
+import './index.scss';
+export declare enum TabList {
+    Reasons = 0,
+    Dependencies = 1,
+    BailoutReason = 2
+}
+export declare const ModuleAnalyzeComponent: React.FC<{
+    modules: SDK.ModuleData[];
+    cwd: string;
+    moduleId: string | number;
+    show: boolean;
+    setShow: (arg: boolean) => void;
+}>;

package/dist/pages/ModuleAnalyze/utils/hooks.d.ts

@@ -0,0 +1,21 @@
+import { SDK } from '@rsdoctor/types';
+export type NewTreeNodeType = {
+    __RESOURCEPATH__: string;
+    id: number;
+    key: string;
+    name: string;
+    level: number;
+    kind: number;
+    size?: string;
+    concatModules: number[] | undefined;
+    chunks?: string[];
+    getChildren?: () => NewTreeNodeType[];
+    dependencies?: number[];
+    fatherPath?: string;
+    children?: number[];
+    needExpand?: boolean | string;
+};
+export declare function useCreateFileTreeData(modules: SDK.ModuleData[], importedModules: SDK.ModuleData[], curModule: SDK.ModuleData): {
+    data: NewTreeNodeType[];
+};
+export declare function getContactMainModulePath(concatModules: number[], modules: SDK.ModuleData[]): string[];

package/dist/pages/ModuleAnalyze/utils/index.d.ts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/types';
+export declare const getImporteds: (curModule: SDK.ModuleData, modules: SDK.ModuleData[]) => SDK.ModuleData[];
+export declare const getModuleReasonsTree: (curModule: SDK.ModuleData, modules: SDK.ModuleData[], reasonsTree: string[], visited: Map<number, boolean>) => void;

package/dist/pages/ModuleResolve/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "ModuleResolve";
+export declare const route = Client.RsdoctorClientRoutes.ModuleResolve;

package/dist/pages/ModuleResolve/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/Overall/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Overall";
+export declare const route = Client.RsdoctorClientRoutes.Overall;

package/dist/pages/Overall/index.d.ts

@@ -0,0 +1,9 @@
+import { SDK } from '@rsdoctor/types';
+import React from 'react';
+interface Props {
+    project: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetProjectInfo>;
+}
+export declare const Page: React.FC<Omit<Props, "project"> & Partial<{
+    body?: any;
+}>>;
+export * from './constants';

package/dist/pages/Overall/responsiveLayout.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    children: React.ReactNode[];
+}
+export declare const ResponsiveLayout: ({ children }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/Resources/BundleDiff/DiffContainer/assets.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { SDK } from '@rsdoctor/types';
+export declare const Assets: React.FC<{
+    outputFilename: string;
+    baseline: SDK.ServerAPI.ResponseTypes[SDK.ServerAPI.API.GetBundleDiffSummary];
+    current: SDK.ServerAPI.ResponseTypes[SDK.ServerAPI.API.GetBundleDiffSummary];
+}>;

package/dist/pages/Resources/BundleDiff/DiffContainer/cards.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { BundleDiffComponentCardProps } from './types';
+export declare const DiffCards: React.FC<BundleDiffComponentCardProps>;

package/dist/pages/Resources/BundleDiff/DiffContainer/changes.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface ViewChangesContentProps {
+    file: string;
+    data: {
+        baseline?: string | void;
+        current: string | void;
+        baselineTitle?: string;
+        currentTitle?: string;
+        group: string;
+    }[];
+}
+export declare const ViewChanges: React.FC<ViewChangesContentProps & {
+    text?: string;
+}>;
+export {};

package/dist/pages/Resources/BundleDiff/DiffContainer/constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum UpdateType {
+    New = "New",
+    Changed = "Changed",
+    Deleted = "Deleted",
+    NotChanged = "Not Changed"
+}
+export declare enum SortType {
+    Name = "Sorted by Name",
+    Size = "Sorted by Size",
+    Delta = "Sorted by Delta"
+}

package/dist/pages/Resources/BundleDiff/DiffContainer/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { BundleDiffContainerProps } from './types';
+export declare const DiffContainer: React.FC<BundleDiffContainerProps>;

package/dist/pages/Resources/BundleDiff/DiffContainer/modules.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { BundleDiffComponentCardProps, BundleDiffTableModulesData } from './types';
+import { UpdateType } from './constants';
+export declare function getUpdateType(e: BundleDiffTableModulesData): UpdateType;
+export declare const FileUpdateTypeTag: React.FC<{
+    type: UpdateType;
+}>;
+export declare const Modules: React.FC<BundleDiffComponentCardProps>;

package/dist/pages/Resources/BundleDiff/DiffContainer/overview.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Client } from '@rsdoctor/types';
+export declare const Overview: React.FC<{
+    assetsDiffResult: Client.RsdoctorClientAssetsDiffResult;
+}>;

package/dist/pages/Resources/BundleDiff/DiffContainer/packages.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { SDK } from '@rsdoctor/types';
+import { UpdateType } from './constants';
+export declare const PackagesStatistic: React.FC<{
+    dataSource: ReturnType<typeof getPackagesTableDataSource>;
+}>;
+export declare const getPackagesTableDataSource: ({ baseline, current, }: {
+    baseline: SDK.PackageGraphData;
+    current: SDK.PackageGraphData;
+}) => {
+    updateType: UpdateType;
+    name: string;
+    baseline?: SDK.PackageData[];
+    current?: SDK.PackageData[];
+}[];
+export declare const Packages: React.FC<{
+    baseline: SDK.PackageGraphData;
+    current: SDK.PackageGraphData;
+}>;

package/dist/pages/Resources/BundleDiff/DiffContainer/row.d.ts

@@ -0,0 +1,9 @@
+import { ColumnGroupType, ColumnType } from 'antd/es/table/interface';
+import React from 'react';
+import { BundleDiffComponentCardProps, BundleDiffTableAssetsData, BundleDiffTableModulesData } from './types';
+export declare const ModuleHashPattern: RegExp;
+export declare const getSizeColumnPropsForModuleRow: (key: "baseline" | "current", sizeKey: "parsedSize" | "sourceSize", sortByChanged?: boolean) => ColumnType<BundleDiffTableModulesData>;
+export declare const getTargetColumnPropsForModuleRow: (key: "baseline" | "current", bModulesCount: number, cModulesCount: number) => ColumnGroupType<BundleDiffTableModulesData>;
+export declare const ModuleRowForAsset: React.FC<{
+    data: BundleDiffTableAssetsData;
+} & Pick<BundleDiffComponentCardProps, 'baseline' | 'current'>>;

package/dist/pages/Resources/BundleDiff/DiffContainer/types.d.ts

@@ -0,0 +1,44 @@
+import { Client, Manifest, SDK } from '@rsdoctor/types';
+import { UpdateType } from './constants';
+import { InferServerAPIBody } from '../../../../components/Manifest/api';
+export type BundleDiffServerAPIProviderComponentCommonProps<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends> = {
+    manifests?: Manifest.RsdoctorManifest[];
+    api: T;
+    children: (baseline: SDK.ServerAPI.InferResponseType<T>, current: SDK.ServerAPI.InferResponseType<T>) => JSX.Element;
+} & InferServerAPIBody<T>;
+export interface BundleDiffContainerProps {
+    manifests: Manifest.RsdoctorManifest[];
+}
+export interface BundleDiffComponentCommonProps {
+    baseline: Manifest.RsdoctorManifest;
+    current: Manifest.RsdoctorManifest;
+    onlyBaseline: boolean;
+    assetsDiffResult: Client.RsdoctorClientAssetsDiffResult;
+}
+export interface BundleDiffComponentCardProps {
+    baseline: SDK.ServerAPI.ResponseTypes[SDK.ServerAPI.API.GetBundleDiffSummary];
+    current: SDK.ServerAPI.ResponseTypes[SDK.ServerAPI.API.GetBundleDiffSummary];
+    onlyBaseline: boolean;
+    assetsDiffResult: Client.RsdoctorClientAssetsDiffResult;
+}
+export interface BundleDiffTableOverviewData {
+    total: Client.RsdoctorClientAssetsDiffItem;
+    initial?: Client.RsdoctorClientAssetsDiffItem;
+}
+export interface BundleDiffTableAssetsData {
+    alias: string;
+    baseline?: SDK.AssetData;
+    current?: SDK.AssetData;
+}
+export interface BundleDiffTableModulesData {
+    path: string;
+    baseline?: SDK.ModuleData;
+    current?: SDK.ModuleData;
+    __is_baseline__?: boolean;
+}
+export interface BundleDiffTablePackagesData {
+    name: string;
+    updateType: UpdateType;
+    baseline?: SDK.PackageData[];
+    current?: SDK.PackageData[];
+}

package/dist/pages/Resources/BundleDiff/DiffContainer/utils.d.ts

@@ -0,0 +1,2 @@
+import { Client } from '@rsdoctor/types';
+export declare const formatDiffSize: (bSize: number, cSize: number, state: Client.RsdoctorClientDiffState, propsStyle?: Record<string, string | number>) => import("react/jsx-runtime").JSX.Element;

package/dist/pages/Resources/BundleDiff/DiffServerAPIProvider/index.d.ts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/types';
+import { BundleDiffServerAPIProviderComponentCommonProps } from '../DiffContainer/types';
+export declare const DiffServerAPIProvider: <T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(props: BundleDiffServerAPIProviderComponentCommonProps<T>) => JSX.Element;

package/dist/pages/Resources/BundleDiff/constants.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Client, Manifest } from '@rsdoctor/types';
+export declare const name = "Bundle Diff";
+export declare const route = Client.RsdoctorClientRoutes.BundleDiff;
+export declare const BundleDiffContext: React.Context<{
+    manifests: Manifest.RsdoctorManifest[];
+    setManifests(_manifests: Manifest.RsdoctorManifest[]): void;
+    loading: boolean;
+    setLoading(_loading: boolean): void;
+    withLoading(_func: (...args: unknown[]) => Promise<unknown> | unknown): Promise<void>;
+}>;

package/dist/pages/Resources/BundleDiff/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export * from './constants';
+export * from './DiffContainer';
+export declare const Page: React.FC;

package/dist/pages/Resources/RuleIndex/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Rule Index";
+export declare const route = Client.RsdoctorClientRoutes.RuleIndex;

package/dist/pages/Resources/RuleIndex/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/TreeShaking/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "TreeShaking";
+export declare const route = Client.RsdoctorClientRoutes.TreeShaking;

package/dist/pages/TreeShaking/editor.d.ts

@@ -0,0 +1,11 @@
+import { SDK } from '@rsdoctor/types';
+import { SetEditorStatus } from './types';
+export interface CodeEditorProps {
+    module: SDK.ModuleInstance;
+    moduleGraph: SDK.ModuleGraphInstance;
+    ranges: SDK.SourceRange[];
+    setEditorData: SetEditorStatus;
+    source: SDK.ModuleSource;
+    toLine?: number;
+}
+export declare function CodeEditor(props: CodeEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/pages/TreeShaking/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { SDK } from '@rsdoctor/types';
+import './index.sass';
+export * from './constants';
+export declare const TreeShakingPage: React.FC<Omit<{
+    data: SDK.ModuleGraphData;
+    cwd: string;
+}, "data" | "cwd">>;

package/dist/pages/TreeShaking/open-tag.d.ts

@@ -0,0 +1,11 @@
+import { SDK } from '@rsdoctor/types';
+export declare enum AttributeKey {
+    Module = "data-module",
+    Range = "data-range"
+}
+export interface OpenTagData {
+    module: number;
+    range: SDK.SourceRange;
+}
+export declare function getOpenTagText(module: number, range: SDK.SourceRange, text: string): string;
+export declare function parseOpenTag(dom: HTMLElement): OpenTagData | undefined;

package/dist/pages/TreeShaking/range.d.ts

@@ -0,0 +1,282 @@
+/**
+ * The following is modified based on source found in
+ * https://github.com/microsoft/monaco-editor
+ *
+ * MIT Licensed
+ * Copyright (c) 2016 - present Microsoft Corporation
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ */
+export declare class Range {
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+    constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number);
+    /**
+     * Test if this range is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Test if `range` is empty.
+     */
+    static isEmpty(range: Range): boolean;
+    /**
+     * Test if position is in this range. If the position is at the edges, will return true.
+     */
+    containsPosition(position: any): boolean;
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return true.
+     */
+    static containsPosition(range: Range, position: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return false.
+     * @internal
+     */
+    static strictContainsPosition(range: Range, position: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * Test if range is in this range. If the range is equal to this range, will return true.
+     */
+    containsRange(range: Range): boolean;
+    /**
+     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
+     */
+    static containsRange(range: Range, otherRange: {
+        startLineNumber: number;
+        endLineNumber: number;
+        startColumn: number;
+        endColumn: number;
+    }): boolean;
+    /**
+     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.
+     */
+    strictContainsRange(range: Range): boolean;
+    /**
+     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
+     */
+    static strictContainsRange(range: Range, otherRange: {
+        startLineNumber: number;
+        endLineNumber: number;
+        startColumn: number;
+        endColumn: number;
+    }): boolean;
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    plusRange(range: Range): Range;
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    static plusRange(a: Range, b: Range): Range;
+    /**
+     * A intersection of the two ranges.
+     */
+    intersectRanges(range: Range): Range | null;
+    /**
+     * A intersection of the two ranges.
+     */
+    static intersectRanges(a: Range, b: Range): Range | null;
+    /**
+     * Test if this range equals other.
+     */
+    equalsRange(other: Range): boolean;
+    /**
+     * Test if range `a` equals `b`.
+     */
+    static equalsRange(a: Range, b: Range): boolean;
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    getEndPosition(): Position;
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    static getEndPosition(range: Range): Position;
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    getStartPosition(): Position;
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    static getStartPosition(range: Range): Position;
+    /**
+     * Transform to a user presentable string representation.
+     */
+    toString(): string;
+    /**
+     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
+     */
+    setEndPosition(endLineNumber: number, endColumn: number): Range;
+    /**
+     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+     */
+    setStartPosition(startLineNumber: number, startColumn: number): Range;
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    collapseToStart(): Range;
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    static collapseToStart(range: Range): Range;
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    collapseToEnd(): Range;
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    static collapseToEnd(range: Range): Range;
+    /**
+     * Moves the range by the given amount of lines.
+     */
+    delta(lineCount: number): Range;
+    static fromPositions(start: {
+        lineNumber: number;
+        column: number;
+    }, end?: {
+        lineNumber: number;
+        column: number;
+    }): Range;
+    static lift(range: Range): Range | null;
+    /**
+     * Test if `obj` is an `IRange`.
+     */
+    static isIRange(obj: Range): boolean;
+    /**
+     * Test if the two ranges are touching in any way.
+     */
+    static areIntersectingOrTouching(a: Range, b: Range): boolean;
+    /**
+     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+     */
+    static areIntersecting(a: Range, b: Range): boolean;
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the startPosition and then on the endPosition
+     */
+    static compareRangesUsingStarts(a: Range, b: Range): number;
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the endPosition and then on the startPosition
+     */
+    static compareRangesUsingEnds(a: {
+        endLineNumber: number;
+        endColumn: number;
+        startLineNumber: number;
+        startColumn: number;
+    }, b: {
+        endLineNumber: number;
+        endColumn: number;
+        startLineNumber: number;
+        startColumn: number;
+    }): number;
+    /**
+     * Test if the range spans multiple lines.
+     */
+    static spansMultipleLines(range: Range): boolean;
+    toJSON(): this;
+}
+/**
+ * A position in the editor.
+ */
+export declare class Position {
+    lineNumber: number;
+    column: number;
+    constructor(lineNumber: number, column: number);
+    /**
+     * Create a new position from this position.
+     *
+     * @param newLineNumber new line number
+     * @param newColumn new column
+     */
+    with(newLineNumber?: number, newColumn?: number): Position;
+    /**
+     * Derive a new position from this position.
+     *
+     * @param deltaLineNumber line number delta
+     * @param deltaColumn column delta
+     */
+    delta(deltaLineNumber?: number, deltaColumn?: number): Position;
+    /**
+     * Test if this position equals other position
+     */
+    equals(other: any): boolean;
+    /**
+     * Test if position `a` equals position `b`
+     */
+    static equals(a: any, b: {
+        lineNumber: any;
+        column: any;
+    }): boolean;
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be false.
+     */
+    isBefore(other: any): boolean;
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be false.
+     */
+    static isBefore(a: any, b: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be true.
+     */
+    isBeforeOrEqual(other: any): boolean;
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be true.
+     */
+    static isBeforeOrEqual(a: any, b: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * A function that compares positions, useful for sorting
+     */
+    static compare(a: {
+        lineNumber: number;
+        column: number;
+    }, b: {
+        lineNumber: number;
+        column: number;
+    }): number;
+    /**
+     * Clone this position.
+     */
+    clone(): Position;
+    /**
+     * Convert to a human-readable representation.
+     */
+    toString(): string;
+    /**
+     * Create a `Position` from an `IPosition`.
+     */
+    static lift(pos: {
+        lineNumber: any;
+        column: any;
+    }): Position;
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj: {
+        lineNumber: any;
+        column: any;
+    }): boolean;
+    toJSON(): {
+        lineNumber: number;
+        column: number;
+    };
+}