devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/models/formatter/FormatterWorkerPool.d.ts

@@ -0,0 +1,58 @@
+import * as FormatterActions from '../../entrypoints/formatter_worker/FormatterActions.js';
+export { DefinitionKind, ScopeKind, type ScopeTreeNode } from '../../entrypoints/formatter_worker/FormatterActions.js';
+export declare class FormatterWorkerPool {
+    private taskQueue;
+    private workerTasks;
+    private entrypointURL;
+    constructor(entrypointURL?: string);
+    static instance(opts?: {
+        forceNew: true;
+        entrypointURL: string;
+    }): FormatterWorkerPool;
+    dispose(): void;
+    static removeInstance(): void;
+    private createWorker;
+    private processNextTask;
+    private onWorkerMessage;
+    private onWorkerError;
+    private runChunkedTask;
+    private runTask;
+    format(mimeType: string, content: string, indentString: string): Promise<FormatterActions.FormatResult>;
+    javaScriptSubstitute(expression: string, mapping: Map<string, string | null>): Promise<string>;
+    javaScriptScopeTree(expression: string, sourceType?: 'module' | 'script'): Promise<FormatterActions.ScopeTreeNode | null>;
+    parseCSS(content: string, callback: (arg0: boolean, arg1: CSSRule[]) => void): void;
+}
+interface CSSProperty {
+    name: string;
+    nameRange: TextRange;
+    value: string;
+    valueRange: TextRange;
+    range: TextRange;
+    disabled?: boolean;
+}
+export declare function formatterWorkerPool(): FormatterWorkerPool;
+export interface OutlineItem {
+    line: number;
+    column: number;
+    title: string;
+    subtitle?: string;
+}
+export interface CSSStyleRule {
+    selectorText: string;
+    styleRange: TextRange;
+    lineNumber: number;
+    columnNumber: number;
+    properties: CSSProperty[];
+}
+export interface CSSAtRule {
+    atRule: string;
+    lineNumber: number;
+    columnNumber: number;
+}
+export type CSSRule = CSSStyleRule | CSSAtRule;
+export interface TextRange {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}

package/dist/lib/front_end/models/formatter/ScriptFormatter.d.ts

@@ -0,0 +1,11 @@
+import * as Common from '../../core/common/common.js';
+export interface FormattedContent {
+    formattedContent: string;
+    formattedMapping: FormatterSourceMapping;
+}
+export declare function format(contentType: Common.ResourceType.ResourceType, mimeType: string, content: string, indent?: string): Promise<FormattedContent>;
+export declare function formatScriptContent(mimeType: string, content: string, indent?: string): Promise<FormattedContent>;
+export interface FormatterSourceMapping {
+    originalToFormatted(lineNumber: number, columnNumber?: number): number[];
+    formattedToOriginal(lineNumber: number, columnNumber?: number): number[];
+}

package/dist/lib/front_end/models/formatter/formatter.d.ts

@@ -0,0 +1,3 @@
+import * as FormatterWorkerPool from './FormatterWorkerPool.js';
+import * as ScriptFormatter from './ScriptFormatter.js';
+export { FormatterWorkerPool, ScriptFormatter };

package/dist/lib/front_end/models/geometry/GeometryImpl.d.ts

@@ -0,0 +1,105 @@
+export declare class Vector {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+    length(): number;
+    normalize(): void;
+}
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    distanceTo(p: Point): number;
+    projectOn(line: Point): Point;
+    scale(scalar: number): Point;
+    toString(): string;
+}
+export declare class CubicBezier {
+    controlPoints: Point[];
+    constructor(point1: Point, point2: Point);
+    static parse(text: string): CubicBezier | null;
+    evaluateAt(t: number): Point;
+    asCSSText(): string;
+    static readonly Regex: RegExp;
+}
+export declare const LINEAR_BEZIER: CubicBezier;
+export declare class EulerAngles {
+    alpha: number;
+    beta: number;
+    gamma: number;
+    constructor(alpha: number, beta: number, gamma: number);
+    /**
+     * Derives orientation angles from a rotation matrix.
+     *
+     * The angles alpha, beta and gamma are in the [0, 360), [-180, 180) and
+     * [-90, 90) intervals respectively, as specified in the Device Orientation
+     * spec (https://w3c.github.io/deviceorientation/#deviceorientation).
+     *
+     * The Euler angles derived here follow a Z-X'-Y'' sequence.
+     *
+     * In particular we compute the decomposition of a given rotation matrix r
+     * such that
+     *    r = rz(alpha) * rx(beta) * ry(gamma)
+     * where rz, rx and ry are rotation matrices around z, x and y axes in the
+     * world coordinate reference frame respectively. The reference frame
+     * consists of three orthogonal axes x, y, z where x points East, y points
+     * north and z points upwards perpendicular to the ground plane. The computed
+     * angles alpha, beta and gamma are in degrees and clockwise-positive when
+     * viewed along the positive direction of the corresponding axis. Except for
+     * the special case when the beta angle is +-90 these angles uniquely
+     * define the orientation of a mobile device in 3D space. The
+     * alpha-beta-gamma representation resembles the yaw-pitch-roll convention
+     * used in vehicle dynamics, however it does not exactly match it. One of the
+     * differences is that the 'pitch' angle beta is allowed to be within [-180,
+     * 180). A mobile device with pitch angle greater than 90 could
+     * correspond to a user lying down and looking upward at the screen.
+     */
+    static fromDeviceOrientationRotationMatrix(rotationMatrix: DOMMatrixReadOnly): EulerAngles;
+}
+export declare const scalarProduct: (u: Vector, v: Vector) => number;
+export declare const crossProduct: (u: Vector, v: Vector) => Vector;
+export declare const subtract: (u: Vector, v: Vector) => Vector;
+export declare const multiplyVectorByMatrixAndNormalize: (v: Vector, m: DOMMatrix) => Vector;
+export declare const calculateAngle: (u: Vector, v: Vector) => number;
+export declare const degreesToRadians: (deg: number) => number;
+export declare const degreesToGradians: (deg: number) => number;
+export declare const degreesToTurns: (deg: number) => number;
+export declare const radiansToDegrees: (rad: number) => number;
+export declare const radiansToGradians: (rad: number) => number;
+export declare const radiansToTurns: (rad: number) => number;
+export declare const gradiansToRadians: (grad: number) => number;
+export declare const turnsToRadians: (turns: number) => number;
+export declare const boundsForTransformedPoints: (matrix: DOMMatrix, points: number[], aggregateBounds?: {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}) => {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+export declare class Size {
+    width: number;
+    height: number;
+    constructor(width: number, height: number);
+    clipTo(size?: Size | null): Size;
+    scale(scale: number): Size;
+    isEqual(size: Size | null): boolean;
+    widthToMax(size: number | Size): Size;
+    addWidth(size: number | Size): Size;
+    heightToMax(size: number | Size): Size;
+    addHeight(size: number | Size): Size;
+}
+export declare class Constraints {
+    minimum: Size;
+    preferred: Size;
+    constructor(minimum?: Size, preferred?: Size | null);
+    isEqual(constraints: Constraints | null): boolean;
+    widthToMax(value: number | Constraints): Constraints;
+    addWidth(value: number | Constraints): Constraints;
+    heightToMax(value: number | Constraints): Constraints;
+    addHeight(value: number | Constraints): Constraints;
+}

package/dist/lib/front_end/models/geometry/geometry.d.ts

@@ -0,0 +1 @@
+export * from './GeometryImpl.js';

package/dist/lib/front_end/models/text_utils/CodeMirrorUtils.d.ts

@@ -0,0 +1,3 @@
+type Tokenizer = (line: string, callback: (value: string, style: string | null) => void) => Promise<void>;
+export declare function createCssTokenizer(): Tokenizer;
+export {};

package/dist/lib/front_end/models/text_utils/ContentData.d.ts

@@ -0,0 +1,74 @@
+import { type DeferredContent } from './ContentProvider.js';
+import { Text } from './Text.js';
+/**
+ * This class is a small wrapper around either raw binary or text data.
+ * As the binary data can actually contain textual data, we also store the
+ * MIME type and if applicable, the charset.
+ *
+ * This information should be generally kept together, as interpreting text
+ * from raw bytes requires an encoding.
+ *
+ * Note that we only rarely have to decode text ourselves in the frontend,
+ * this is mostly handled by the backend. There are cases though (e.g. SVG,
+ * or streaming response content) where we receive text data in
+ * binary (base64-encoded) form.
+ *
+ * The class only implements decoding. We currently don't have a use-case
+ * to re-encode text into base64 bytes using a specified charset.
+ */
+export declare class ContentData {
+    #private;
+    readonly mimeType: string;
+    readonly charset: string;
+    constructor(data: string, isBase64: boolean, mimeType: string, charset?: string);
+    /**
+     * Returns the data as base64.
+     *
+     * @throws if this `ContentData` was constructed from text content.
+     */
+    get base64(): string;
+    /**
+     * Returns the content as text. If this `ContentData` was constructed with base64
+     * encoded bytes, it will use the provided charset to attempt to decode the bytes.
+     *
+     * @throws if `mimeType` is not a text type.
+     */
+    get text(): string;
+    /** @returns true, if this `ContentData` was constructed from text content or the mime type indicates text that can be decoded */
+    get isTextContent(): boolean;
+    get isEmpty(): boolean;
+    get createdFromBase64(): boolean;
+    /**
+     * Returns the text content as a `Text` object. The returned object is always the same to
+     * minimize the number of times we have to calculate the line endings array.
+     *
+     * @throws if `mimeType` is not a text type.
+     */
+    get textObj(): Text;
+    /**
+     * @returns True, iff the contents (base64 or text) are equal.
+     * Does not compare mime type and charset, but will decode base64 data if both
+     * mime types indicate that it's text content.
+     */
+    contentEqualTo(other: ContentData): boolean;
+    asDataUrl(): string | null;
+    /**
+     * @deprecated Used during migration from `DeferredContent` to `ContentData`.
+     */
+    asDeferedContent(): DeferredContent;
+    static isError(contentDataOrError: ContentDataOrError): contentDataOrError is {
+        error: string;
+    };
+    /** @returns `value` if the passed `ContentDataOrError` is an error, or the text content otherwise */
+    static textOr<T>(contentDataOrError: ContentDataOrError, value: T): string | T;
+    /** @returns an empty 'text/plain' content data if the passed `ContentDataOrError` is an error, or the content data itself otherwise */
+    static contentDataOrEmpty(contentDataOrError: ContentDataOrError): ContentData;
+    /**
+     * @deprecated Used during migration from `DeferredContent` to `ContentData`.
+     */
+    static asDeferredContent(contentDataOrError: ContentDataOrError): DeferredContent;
+}
+export declare const EMPTY_TEXT_CONTENT_DATA: ContentData;
+export type ContentDataOrError = ContentData | {
+    error: string;
+};

package/dist/lib/front_end/models/text_utils/ContentProvider.d.ts

@@ -0,0 +1,42 @@
+import type * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+import type { ContentDataOrError } from './ContentData.js';
+import type { StreamingContentDataOrError } from './StreamingContentData.js';
+import type { WasmDisassembly } from './WasmDisassembly.js';
+export interface ContentProvider {
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    requestContentData(): Promise<ContentDataOrError>;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<SearchMatch[]>;
+}
+export declare class SearchMatch {
+    readonly lineNumber: number;
+    readonly lineContent: string;
+    readonly columnNumber: number;
+    readonly matchLength: number;
+    constructor(lineNumber: number, lineContent: string, columnNumber: number, matchLength: number);
+    static comparator(a: SearchMatch, b: SearchMatch): number;
+}
+export declare const contentAsDataURL: (content: string | null, mimeType: string, contentEncoded: boolean, charset?: string | null, limitSize?: boolean) => string | null;
+export type DeferredContent = {
+    content: string;
+    isEncoded: boolean;
+} | {
+    content: '';
+    isEncoded: false;
+    wasmDisassemblyInfo: WasmDisassembly;
+} | {
+    content: null;
+    error: string;
+    isEncoded: boolean;
+};
+/**
+ * Some ContentProvider like NetworkRequests might never actually be able to return
+ * a fully completed "requestContentData" as the request keeps on going indefinitely.
+ * Such proivders can implement the "StreamingContentProvider" addition, which allows
+ * for partial/streaming content.
+ **/
+export interface StreamingContentProvider extends ContentProvider {
+    requestStreamingContent(): Promise<StreamingContentDataOrError>;
+}
+export declare const isStreamingContentProvider: (provider: ContentProvider) => provider is StreamingContentProvider;

package/dist/lib/front_end/models/text_utils/StaticContentProvider.d.ts

@@ -0,0 +1,13 @@
+import type * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+import { type ContentDataOrError } from './ContentData.js';
+import type { ContentProvider, SearchMatch } from './ContentProvider.js';
+export declare class StaticContentProvider implements ContentProvider {
+    #private;
+    constructor(contentURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType, lazyContent: () => Promise<ContentDataOrError>);
+    static fromString(contentURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType, content: string): StaticContentProvider;
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    requestContentData(): Promise<ContentDataOrError>;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<SearchMatch[]>;
+}

package/dist/lib/front_end/models/text_utils/StreamingContentData.d.ts

@@ -0,0 +1,49 @@
+import * as Common from '../../core/common/common.js';
+import { ContentData, type ContentDataOrError } from './ContentData.js';
+/**
+ * Usage of this class is mostly intended for content that is never "complete".
+ * E.g. streaming XHR/fetch requests.
+ *
+ * Due to the streaming nature this class only supports base64-encoded binary data.
+ * Decoding to text only happens on-demand by clients. This ensures that at most we have
+ * incomplete unicode at the end and not in-between chunks.
+ */
+export declare class StreamingContentData extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+    #private;
+    readonly mimeType: string;
+    private constructor();
+    /**
+     * Creates a new StreamingContentData with the given MIME type/charset.
+     */
+    static create(mimeType: string, charset?: string): StreamingContentData;
+    /**
+     * Creates a new StringContentData from an existing ContentData instance.
+     *
+     * Calling `addChunk` is on the resulting `StreamingContentData` is illegal if
+     * `content` was not created from base64 data. The reason is that JavaScript TextEncoder
+     * only supports UTF-8. We can't convert text with arbitrary encoding back to base64 for concatenation.
+     */
+    static from(content: ContentData): StreamingContentData;
+    /** @returns true, if this `ContentData` was constructed from text content or the mime type indicates text that can be decoded */
+    get isTextContent(): boolean;
+    /** @param chunk base64 encoded data */
+    addChunk(chunk: string): void;
+    /** @returns An immutable ContentData with all the bytes received so far */
+    content(): ContentData;
+}
+export type StreamingContentDataOrError = StreamingContentData | {
+    error: string;
+};
+export declare const isError: (contentDataOrError: StreamingContentDataOrError) => contentDataOrError is {
+    error: string;
+};
+export declare const asContentDataOrError: (contentDataOrError: StreamingContentDataOrError) => ContentDataOrError;
+export declare const enum Events {
+    CHUNK_ADDED = "ChunkAdded"
+}
+export interface EventTypes {
+    [Events.CHUNK_ADDED]: {
+        content: StreamingContentData;
+        chunk: string;
+    };
+}

package/dist/lib/front_end/models/text_utils/Text.d.ts

@@ -0,0 +1,19 @@
+import { SourceRange, TextRange } from './TextRange.js';
+export declare class Text {
+    #private;
+    constructor(value: string);
+    lineEndings(): number[];
+    value(): string;
+    lineCount(): number;
+    offsetFromPosition(lineNumber: number, columnNumber: number): number;
+    positionFromOffset(offset: number): Position;
+    lineAt(lineNumber: number): string;
+    toSourceRange(range: TextRange): SourceRange;
+    toTextRange(sourceRange: SourceRange): TextRange;
+    replaceRange(range: TextRange, replacement: string): string;
+    extract(range: TextRange): string;
+}
+export interface Position {
+    lineNumber: number;
+    columnNumber: number;
+}

package/dist/lib/front_end/models/text_utils/TextCursor.d.ts

@@ -0,0 +1,9 @@
+export declare class TextCursor {
+    #private;
+    constructor(lineEndings: number[]);
+    advance(offset: number): void;
+    offset(): number;
+    resetTo(offset: number): void;
+    lineNumber(): number;
+    columnNumber(): number;
+}

package/dist/lib/front_end/models/text_utils/TextRange.d.ts

@@ -0,0 +1,80 @@
+export interface SerializedTextRange {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export declare class TextRange {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    constructor(startLine: number, startColumn: number, endLine: number, endColumn: number);
+    static createFromLocation(line: number, column: number): TextRange;
+    static createUnboundedFromLocation(line: number, column: number): TextRange;
+    static fromObject(serializedTextRange: SerializedTextRange): TextRange;
+    static comparator(range1: TextRange, range2: TextRange): number;
+    static fromEdit(oldRange: TextRange, newText: string): TextRange;
+    isEmpty(): boolean;
+    immediatelyPrecedes(range?: TextRange): boolean;
+    immediatelyFollows(range?: TextRange): boolean;
+    follows(range: TextRange): boolean;
+    get linesCount(): number;
+    collapseToEnd(): TextRange;
+    collapseToStart(): TextRange;
+    normalize(): TextRange;
+    clone(): TextRange;
+    serializeToObject(): {
+        startLine: number;
+        startColumn: number;
+        endLine: number;
+        endColumn: number;
+    };
+    compareTo(other: TextRange): number;
+    compareToPosition(lineNumber: number, columnNumber: number): number;
+    equal(other: TextRange): boolean;
+    relativeTo(line: number, column: number): TextRange;
+    relativeFrom(line: number, column: number): TextRange;
+    rebaseAfterTextEdit(originalRange: TextRange, editedRange: TextRange): TextRange;
+    toString(): string;
+    /**
+     * Checks whether this {@link TextRange} contains the location identified by the
+     * {@link lineNumber} and {@link columnNumber}. The beginning of the text range is
+     * considered inclusive while the end of the text range is considered exclusive
+     * for this comparison, meaning that for example a range `(0,1)-(1,4)` contains the
+     * location `(0,1)` but does not contain the location `(1,4)`.
+     *
+     * @param lineNumber the location's line offset.
+     * @param columnNumber the location's column offset.
+     * @returns `true` if the location identified by {@link lineNumber} and {@link columnNumber}
+     *          is contained within this text range.
+     */
+    containsLocation(lineNumber: number, columnNumber: number): boolean;
+    get start(): {
+        lineNumber: number;
+        columnNumber: number;
+    };
+    get end(): {
+        lineNumber: number;
+        columnNumber: number;
+    };
+    /**
+     * Checks whether this and `that` {@link TextRange} overlap and if they do, computes the
+     * intersection range. If they don't overlap an empty text range is returned instead (for
+     * which {@link #isEmpty()} yields `true`).
+     *
+     * The beginning of text ranges is considered to be includes while the end of the text
+     * ranges is considered exclusive for the intersection, meaning that for example intersecting
+     * `(0,1)-(1,4)` and `(1,4)-(1,6)` yields an empty range.
+     *
+     * @param that the other text range.
+     * @returns the intersection of this and `that` text range, which might be empty if their don't
+     *          overlap.
+     */
+    intersection(that: TextRange): TextRange;
+}
+export declare class SourceRange {
+    offset: number;
+    length: number;
+    constructor(offset: number, length: number);
+}

package/dist/lib/front_end/models/text_utils/TextUtils.d.ts

@@ -0,0 +1,97 @@
+import { type ContentDataOrError } from './ContentData.js';
+import { SearchMatch } from './ContentProvider.js';
+import type { Text } from './Text.js';
+export declare const Utils: {
+    isSpaceChar: (char: string) => boolean;
+    lineIndent: (line: string) => string;
+    splitStringByRegexes(text: string, regexes: RegExp[]): Array<{
+        value: string;
+        position: number;
+        regexIndex: number;
+        captureGroups: Array<string | undefined>;
+    }>;
+};
+export declare class FilterParser {
+    private readonly keys;
+    constructor(keys: string[]);
+    static cloneFilter(filter: ParsedFilter): ParsedFilter;
+    parse(query: string): ParsedFilter[];
+}
+export declare class BalancedJSONTokenizer {
+    private readonly callback;
+    private index;
+    private balance;
+    private buffer;
+    private findMultiple;
+    private closingDoubleQuoteRegex;
+    private lastBalancedIndex?;
+    constructor(callback: (arg0: string) => void, findMultiple?: boolean);
+    write(chunk: string): boolean;
+    private reportBalanced;
+    remainder(): string;
+}
+/**
+ * Detects the indentation used by a given text document, based on the _Comparing
+ * lines_ approach suggested by Heather Arthur (and also found in Firefox DevTools).
+ *
+ * This implementation differs from the original proposal in that tab indentation
+ * isn't detected by checking if at least 50% of the lines start with a tab, but
+ * instead by comparing the number of lines that start with a tab to the frequency
+ * of the other indentation patterns. This way we also detect small snippets with
+ * long leading comments correctly, when tab indentation is used for the snippets
+ * of code.
+ *
+ * @param lines The input document lines.
+ * @returns The indentation detected for the lines as string or `null` if it's inconclusive.
+ * @see https://heathermoor.medium.com/detecting-code-indentation-eff3ed0fb56b
+ */
+export declare const detectIndentation: (lines: Iterable<string>) => string | null;
+/**
+ * Heuristic to check whether a given text was likely minified. Intended to
+ * be used for HTML, CSS, and JavaScript inputs.
+ *
+ * A text is considered to be the result of minification if the average
+ * line length for the whole text is 80 characters or more.
+ *
+ * @param text The input text to check.
+ * @returns `true` if the heuristic considers `text` to be minified.
+ */
+export declare const isMinified: (text: string) => boolean;
+/**
+ * Small wrapper around {@link performSearchInContent} to reduce boilerplate when searching
+ * in {@link ContentDataOrError}.
+ *
+ * @returns empty search matches if `contentData` is an error or not text content.
+ */
+export declare const performSearchInContentData: (contentData: ContentDataOrError, query: string, caseSensitive: boolean, isRegex: boolean) => SearchMatch[];
+/**
+ * @returns One {@link SearchMatch} per match. Multiple matches on the same line each
+ * result in their own `SearchMatchExact` instance.
+ */
+export declare const performSearchInContent: (text: Text, query: string, caseSensitive: boolean, isRegex: boolean) => SearchMatch[];
+/**
+ * Similar to {@link performSearchInContent} but doesn't search in a whole text but rather
+ * finds the exact matches on a prelminiary search result (i.e. lines with known matches).
+ * @param matches is deliberatedly typed as an object literal so we can pass the
+ *                CDP search result type.
+ */
+export declare const performSearchInSearchMatches: (matches: Array<{
+    lineNumber: number;
+    lineContent: string;
+}>, query: string, caseSensitive: boolean, isRegex: boolean) => SearchMatch[];
+/**
+ * Finds the longest overlapping string segment between the end of the first
+ * string and the beginning of the second string.
+ *
+ * @param s1 The first string (whose suffix will be checked).
+ * @param s2 The second string (whose prefix will be checked).
+ * @returns The overlapping string segment, or an empty string ("")
+ * if no overlap is found.
+ */
+export declare const getOverlap: (s1: string, s2: string) => string | null;
+export interface ParsedFilter {
+    key?: string;
+    text?: string | null;
+    regex?: RegExp;
+    negative: boolean;
+}

package/dist/lib/front_end/models/text_utils/WasmDisassembly.d.ts

@@ -0,0 +1,29 @@
+import { ContentData } from './ContentData.js';
+import type { DeferredContent } from './ContentProvider.js';
+interface FunctionBodyOffset {
+    start: number;
+    end: number;
+}
+/**
+ * Metadata to map between bytecode #offsets and line numbers in the
+ * disassembly for WebAssembly modules.
+ */
+export declare class WasmDisassembly extends ContentData {
+    #private;
+    readonly lines: string[];
+    constructor(lines: string[], offsets: number[], functionBodyOffsets: FunctionBodyOffset[]);
+    get text(): string;
+    get isEmpty(): boolean;
+    get lineNumbers(): number;
+    bytecodeOffsetToLineNumber(bytecodeOffset: number): number;
+    lineNumberToBytecodeOffset(lineNumber: number): number;
+    /**
+     * returns an iterable enumerating all the non-breakable line numbers in the disassembly
+     */
+    nonBreakableLineNumbers(): Iterable<number>;
+    /**
+     * @deprecated Used during migration from `DeferredContent` to `ContentData`.
+     */
+    asDeferedContent(): DeferredContent;
+}
+export {};

package/dist/lib/front_end/models/text_utils/text_utils.d.ts

@@ -0,0 +1,11 @@
+import * as CodeMirrorUtils from './CodeMirrorUtils.js';
+import * as ContentData from './ContentData.js';
+import * as ContentProvider from './ContentProvider.js';
+import * as StaticContentProvider from './StaticContentProvider.js';
+import * as StreamingContentData from './StreamingContentData.js';
+import * as Text from './Text.js';
+import * as TextCursor from './TextCursor.js';
+import * as TextRange from './TextRange.js';
+import * as TextUtils from './TextUtils.js';
+import * as WasmDisassembly from './WasmDisassembly.js';
+export { CodeMirrorUtils, ContentData, ContentProvider, StaticContentProvider, StreamingContentData, Text, TextCursor, TextRange, TextUtils, WasmDisassembly, };

package/dist/lib/front_end/models/trace/EntityMapper.d.ts

@@ -0,0 +1,33 @@
+import type * as Platform from '../../core/platform/platform.js';
+import type * as Protocol from '../../generated/protocol.js';
+import * as Handlers from './handlers/handlers.js';
+import type { ParsedTrace } from './ModelImpl.js';
+import type * as Types from './types/types.js';
+export declare class EntityMapper {
+    #private;
+    constructor(parsedTrace: ParsedTrace);
+    /**
+     * Returns an entity for a given event if any.
+     */
+    entityForEvent(event: Types.Events.Event): Handlers.Helpers.Entity | null;
+    /**
+     * Returns trace events that correspond with a given entity if any.
+     */
+    eventsForEntity(entity: Handlers.Helpers.Entity): Types.Events.Event[];
+    firstPartyEntity(): Handlers.Helpers.Entity | null;
+    thirdPartyEvents(): Types.Events.Event[];
+    mappings(): Handlers.Helpers.EntityMappings;
+    /**
+     * This updates entity mapping given a callFrame and sourceURL (newly resolved),
+     * updating both eventsByEntity and entityByEvent. The call frame provides us the
+     * URL and sourcemap source location that events map to. This describes the exact events we
+     * want to update. We then update the events with the new sourceURL.
+     *
+     * compiledURLs -> the actual file's url (e.g. my-big-bundle.min.js)
+     * sourceURLs -> the resolved urls (e.g. react.development.js, my-app.ts)
+     * @param callFrame
+     * @param sourceURL
+     */
+    updateSourceMapEntities(callFrame: Protocol.Runtime.CallFrame, sourceURL: string): void;
+    updateExtensionEntitiesWithName(executionContextNamesByOrigin: Map<Platform.DevToolsPath.UrlString, string>): void;
+}

package/dist/lib/front_end/models/trace/EventsSerializer.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedTrace } from './ModelImpl.js';
+import * as Types from './types/types.js';
+export declare class EventsSerializer {
+    #private;
+    keyForEvent(event: Types.Events.Event): Types.File.SerializableKey | null;
+    eventForKey(key: Types.File.SerializableKey, parsedTrace: ParsedTrace): Types.Events.Event;
+    static isProfileCallKey(key: Types.File.SerializableKeyValues): key is Types.File.ProfileCallKeyValues;
+    static isLegacyTimelineFrameKey(key: Types.File.SerializableKeyValues): key is Types.File.LegacyTimelineFrameKeyValues;
+    static isRawEventKey(key: Types.File.SerializableKeyValues): key is Types.File.RawEventKeyValues;
+    static isSyntheticEventKey(key: Types.File.SerializableKeyValues): key is Types.File.SyntheticEventKeyValues;
+}