Vihren Atlas

htmlContent.ts ×20

Code frontier

unlabeled · c_af8908c3821e

1859 tests · 7278 LOC · 38 files · introduces 0 tests · 102 LOC · 1 file

Introduces — evidence that enters the hierarchy at this concept

Code
20 ranges102 lines · 1 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
892 ranges7278 lines · 38 files · Browse complete extent
All tests (intent)
1859 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

1 file ranked by introduced lines: 102 introduced LOC across 20 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/base/common/htmlContent.ts 102 introduced LOC · 20 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- htmlContent.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { illegalArgument } from './errors.js';
7 > import { escapeIcons } from './iconLabels.js';
8 > import { Schemas } from './network.js';
9 > import { isEqual } from './resources.js';
10 > import { escapeRegExpCharacters } from './strings.js';
11 > import { URI, UriComponents } from './uri.js';
12 >
13 > export interface MarkdownStringTrustedOptions {
14 > readonly enabledCommands: readonly string[];
15 > }
16 >
17 > export interface IMarkdownString {
18 > readonly value: string;
19 > readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
20 > readonly supportThemeIcons?: boolean;
21 > readonly supportHtml?: boolean;
22 > /** @internal */
23 > readonly supportAlertSyntax?: boolean;
24 > readonly baseUri?: UriComponents;
25 > uris?: { [href: string]: UriComponents };
26 > }
27 >
28 > export const enum MarkdownStringTextNewlineStyle {
29 > Paragraph = 0,
30 > Break = 1,
31 > }
32 >
33 > export class MarkdownString implements IMarkdownString {
34 >
35 > public value: string;
36 > public isTrusted?: boolean | MarkdownStringTrustedOptions;
37 > public supportThemeIcons?: boolean;
38 > public supportHtml?: boolean;
39 > public supportAlertSyntax?: boolean;
40 > public baseUri?: URI;
41 > public uris?: { [href: string]: UriComponents } | undefined;
42 >
43 > public static lift(dto: IMarkdownString): MarkdownString {
44 const markdownString = new MarkdownString(dto.value, dto);
45 markdownString.uris = dto.uris;
47 return markdownString;
48 }
49 > htmlContent.ts
50 > constructor(
51 value: string = '',
52 isTrustedOrOptions: boolean | { isTrusted?: boolean | MarkdownStringTrustedOptions; supportThemeIcons?: boolean; supportHtml?: boolean; supportAlertSyntax?: boolean } = false,
70 }
71 }
72 > htmlContent.ts
73 > appendText(value: string, newlineStyle: MarkdownStringTextNewlineStyle = MarkdownStringTextNewlineStyle.Paragraph): MarkdownString {
74 this.value += escapeMarkdownSyntaxTokens(this.supportThemeIcons ? escapeIcons(value) : value) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
75 .replace(/([ \t]+)/g, (_match, g1) => ' '.repeat(g1.length)) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
79 return this;
80 }
81 > htmlContent.ts
82 > appendMarkdown(value: string): MarkdownString {
83 this.value += value;
84 return this;
85 }
86 > htmlContent.ts
87 > appendCodeblock(langId: string, code: string): MarkdownString {
88 this.value += `\n${appendEscapedMarkdownCodeBlockFence(code, langId)}\n`;
89 return this;
90 }
91 > htmlContent.ts
92 > appendLink(target: URI | string, label: string, title?: string): MarkdownString {
93 this.value += '[';
94 this.value += this._escape(label, ']');
101 return this;
102 }
103 > htmlContent.ts
104 > private _escape(value: string, ch: string): string {
105 const r = new RegExp(escapeRegExpCharacters(ch), 'g');
106 return value.replace(r, (match, offset) => {
112 });
113 }
114 > } htmlContent.ts
115 >
116 > export function isEmptyMarkdownString(oneOrMany: IMarkdownString | IMarkdownString[] | null | undefined): boolean {
117 if (isMarkdownString(oneOrMany)) {
118 return !oneOrMany.value;
123 }
124 }
125 > htmlContent.ts
126 > export function isMarkdownString(thing: unknown): thing is IMarkdownString {
127 if (thing instanceof MarkdownString) {
128 return true;
135 return false;
136 }
137 > htmlContent.ts
138 > export function markdownStringEqual(a: IMarkdownString, b: IMarkdownString): boolean {
139 if (a === b) {
140 return true;
150 }
151 }
152 > htmlContent.ts
153 > export function escapeMarkdownSyntaxTokens(text: string): string {
154 // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
155 return text
157 .replace(/^([ \t]*)-/gm, '$1\\-'); // CodeQL [SM02383] Backslash is escaped in the character class
158 }
159 > htmlContent.ts
160 > /**
161 > * Escapes only the characters that would break out of markdown link text
162 > * (`[label](url)`) syntax: `\` and `]`. Use this when the escaped string is
163 > * displayed as the visible label of a link, since renderers that extract the
164 > * link text without re-parsing markdown (e.g. the chat inline anchor / skill
165 > * pill) would otherwise show full `escapeMarkdownSyntaxTokens` backslashes
166 > * (`\-`, `\.`, ...) verbatim.
167 > */
168 > export function escapeMarkdownLinkLabel(text: string): string {
169 return text.replace(/[\\\]]/g, '\\$&');
170 }
171 > htmlContent.ts
172 > /**
173 > * @see https://github.com/microsoft/vscode/issues/193746
174 > */
175 > export function appendEscapedMarkdownCodeBlockFence(code: string, langId: string) {
176 const longestFenceLength =
177 code.match(/^`+/gm)?.reduce((a, b) => (a.length > b.length ? a : b)).length ??
187 ].join('\n');
188 }
189 > htmlContent.ts
190 > /**
191 > * Wraps arbitrary text in a markdown inline code span using a backtick fence
192 > * long enough to safely contain any backtick sequences present in the text.
193 > *
194 > * Backticks inside an inline code span cannot be backslash-escaped per the
195 > * CommonMark spec — the only safe way is to choose a delimiter run longer
196 > * than any run of backticks in the content (and pad with spaces if the
197 > * content begins or ends with a backtick).
198 > */
199 > export function appendEscapedMarkdownInlineCode(text: string): string {
200 const longestBacktickRun = Math.max(0, ...(text.match(/`+/g) ?? []).map(m => m.length));
201 const fence = '`'.repeat(longestBacktickRun + 1);
204 return `${fence}${content}${fence}`;
205 }
206 > htmlContent.ts
207 > export function escapeDoubleQuotes(input: string) {
208 return input.replace(/"/g, '"');
209 }
210 > htmlContent.ts
211 > export function removeMarkdownEscapes(text: string): string {
212 if (!text) {
213 return text;
215 return text.replace(/\\([\\`*_{}[\]()#+\-.!~])/g, '$1');
216 }
217 > htmlContent.ts
218 > export function parseHrefAndDimensions(href: string): { href: string; dimensions: string[] } {
219 const dimensions: string[] = [];
220 const splitted = href.split('|').map(s => s.trim());
237 return { href, dimensions };
238 }
239 > htmlContent.ts
240 > export function createMarkdownLink(text: string, href: string, title?: string, escapeTokens = true): string {
241 return `[${escapeTokens ? escapeMarkdownSyntaxTokens(text) : text}](${href}${title ? ` "${escapeMarkdownSyntaxTokens(title)}"` : ''})`;
242 }
243 > htmlContent.ts
244 > export function createMarkdownCommandLink(command: { text: string; id: string; arguments?: unknown[]; tooltip: string }, escapeTokens = true): string {
245 const uri = createCommandUri(command.id, ...(command.arguments || [])).toString();
246 return createMarkdownLink(command.text, uri, command.tooltip, escapeTokens);
247 }
248 > htmlContent.ts
249 > export function createCommandUri(commandId: string, ...commandArgs: unknown[]): URI {
250 return URI.from({
251 scheme: Schemas.command,

Direct hierarchy

Parents

Children