diff --git a/build/lib/compilation.js b/build/lib/compilation.js index 63ddeb2eabd..2270e054ba5 100644 --- a/build/lib/compilation.js +++ b/build/lib/compilation.js @@ -19,7 +19,7 @@ const os = require("os"); const ts = require("typescript"); const File = require("vinyl"); const task = require("./task"); -const mangleTypeScript_1 = require("./mangleTypeScript"); +const index_1 = require("./mangle/index"); const watch = require('./watch'); // --- gulp-tsb: compile and transpile -------------------------------- const reporter = (0, reporter_1.createReporter)(); @@ -105,20 +105,20 @@ function compileTask(src, out, build, options = {}) { // mangle: TypeScript to TypeScript let mangleStream = es.through(); if (build && !options.disableMangle) { - let ts2tsMangler = new mangleTypeScript_1.Mangler(compile.projectPath, (...data) => fancyLog(ansiColors.blue('[mangler]'), ...data)); + let ts2tsMangler = new index_1.Mangler(compile.projectPath, (...data) => fancyLog(ansiColors.blue('[mangler]'), ...data), { mangleExports: true, manglePrivateFields: true }); const newContentsByFileName = ts2tsMangler.computeNewFileContents(new Set(['saveState'])); - mangleStream = es.through(function write(data) { + mangleStream = es.through(async function write(data) { const tsNormalPath = ts.normalizePath(data.path); - const newContents = newContentsByFileName.get(tsNormalPath); + const newContents = (await newContentsByFileName).get(tsNormalPath); if (newContents !== undefined) { data.contents = Buffer.from(newContents.out); data.sourceMap = newContents.sourceMap && JSON.parse(newContents.sourceMap); } this.push(data); - }, function end() { - this.push(null); + }, async function end() { // free resources - newContentsByFileName.clear(); + (await newContentsByFileName).clear(); + this.push(null); ts2tsMangler = undefined; }); } @@ -281,4 +281,4 @@ exports.watchApiProposalNamesTask = task.define('watch-api-proposal-names', () = .pipe(util.debounce(task)) .pipe(gulp.dest('src')); }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compilation.js","sourceRoot":"","sources":["compilation.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compilation.js","sourceRoot":"","sources":["compilation.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/build/lib/compilation.ts b/build/lib/compilation.ts index d5cd1966221..d5da3f1cd89 100644 --- a/build/lib/compilation.ts +++ b/build/lib/compilation.ts @@ -17,7 +17,7 @@ import * as os from 'os'; import ts = require('typescript'); import * as File from 'vinyl'; import * as task from './task'; -import { Mangler } from './mangleTypeScript'; +import { Mangler } from './mangle/index'; import { RawSourceMap } from 'source-map'; const watch = require('./watch'); @@ -124,21 +124,22 @@ export function compileTask(src: string, out: string, build: boolean, options: { // mangle: TypeScript to TypeScript let mangleStream = es.through(); if (build && !options.disableMangle) { - let ts2tsMangler = new Mangler(compile.projectPath, (...data) => fancyLog(ansiColors.blue('[mangler]'), ...data)); + let ts2tsMangler = new Mangler(compile.projectPath, (...data) => fancyLog(ansiColors.blue('[mangler]'), ...data), { mangleExports: true, manglePrivateFields: true }); const newContentsByFileName = ts2tsMangler.computeNewFileContents(new Set(['saveState'])); - mangleStream = es.through(function write(data: File & { sourceMap?: RawSourceMap }) { + mangleStream = es.through(async function write(data: File & { sourceMap?: RawSourceMap }) { type TypeScriptExt = typeof ts & { normalizePath(path: string): string }; const tsNormalPath = (ts).normalizePath(data.path); - const newContents = newContentsByFileName.get(tsNormalPath); + const newContents = (await newContentsByFileName).get(tsNormalPath); if (newContents !== undefined) { data.contents = Buffer.from(newContents.out); data.sourceMap = newContents.sourceMap && JSON.parse(newContents.sourceMap); } this.push(data); - }, function end() { - this.push(null); + }, async function end() { // free resources - newContentsByFileName.clear(); + (await newContentsByFileName).clear(); + + this.push(null); (ts2tsMangler) = undefined; }); } diff --git a/build/lib/mangle/index.js b/build/lib/mangle/index.js new file mode 100644 index 00000000000..8d509b9590d --- /dev/null +++ b/build/lib/mangle/index.js @@ -0,0 +1,665 @@ +"use strict"; +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Mangler = void 0; +const fs = require("fs"); +const path = require("path"); +const process_1 = require("process"); +const source_map_1 = require("source-map"); +const ts = require("typescript"); +const url_1 = require("url"); +const workerpool = require("workerpool"); +const staticLanguageServiceHost_1 = require("./staticLanguageServiceHost"); +const buildfile = require('../../../src/buildfile'); +class ShortIdent { + prefix; + static _keywords = new Set(['await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', + 'default', 'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', + 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return', 'static', 'super', 'switch', 'this', 'throw', + 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']); + static _alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890$_'.split(''); + _value = 0; + constructor(prefix) { + this.prefix = prefix; + } + next(isNameTaken) { + const candidate = this.prefix + ShortIdent.convert(this._value); + this._value++; + if (ShortIdent._keywords.has(candidate) || /^[_0-9]/.test(candidate) || isNameTaken?.(candidate)) { + // try again + return this.next(isNameTaken); + } + return candidate; + } + static convert(n) { + const base = this._alphabet.length; + let result = ''; + do { + const rest = n % base; + result += this._alphabet[rest]; + n = (n / base) | 0; + } while (n > 0); + return result; + } +} +var FieldType; +(function (FieldType) { + FieldType[FieldType["Public"] = 0] = "Public"; + FieldType[FieldType["Protected"] = 1] = "Protected"; + FieldType[FieldType["Private"] = 2] = "Private"; +})(FieldType || (FieldType = {})); +class ClassData { + fileName; + node; + fields = new Map(); + replacements; + parent; + children; + constructor(fileName, node) { + // analyse all fields (properties and methods). Find usages of all protected and + // private ones and keep track of all public ones (to prevent naming collisions) + this.fileName = fileName; + this.node = node; + const candidates = []; + for (const member of node.members) { + if (ts.isMethodDeclaration(member)) { + // method `foo() {}` + candidates.push(member); + } + else if (ts.isPropertyDeclaration(member)) { + // property `foo = 234` + candidates.push(member); + } + else if (ts.isGetAccessor(member)) { + // getter: `get foo() { ... }` + candidates.push(member); + } + else if (ts.isSetAccessor(member)) { + // setter: `set foo() { ... }` + candidates.push(member); + } + else if (ts.isConstructorDeclaration(member)) { + // constructor-prop:`constructor(private foo) {}` + for (const param of member.parameters) { + if (hasModifier(param, ts.SyntaxKind.PrivateKeyword) + || hasModifier(param, ts.SyntaxKind.ProtectedKeyword) + || hasModifier(param, ts.SyntaxKind.PublicKeyword) + || hasModifier(param, ts.SyntaxKind.ReadonlyKeyword)) { + candidates.push(param); + } + } + } + } + for (const member of candidates) { + const ident = ClassData._getMemberName(member); + if (!ident) { + continue; + } + const type = ClassData._getFieldType(member); + this.fields.set(ident, { type, pos: member.name.getStart() }); + } + } + static _getMemberName(node) { + if (!node.name) { + return undefined; + } + const { name } = node; + let ident = name.getText(); + if (name.kind === ts.SyntaxKind.ComputedPropertyName) { + if (name.expression.kind !== ts.SyntaxKind.StringLiteral) { + // unsupported: [Symbol.foo] or [abc + 'field'] + return; + } + // ['foo'] + ident = name.expression.getText().slice(1, -1); + } + return ident; + } + static _getFieldType(node) { + if (hasModifier(node, ts.SyntaxKind.PrivateKeyword)) { + return 2 /* FieldType.Private */; + } + else if (hasModifier(node, ts.SyntaxKind.ProtectedKeyword)) { + return 1 /* FieldType.Protected */; + } + else { + return 0 /* FieldType.Public */; + } + } + static _shouldMangle(type) { + return type === 2 /* FieldType.Private */ + || type === 1 /* FieldType.Protected */; + } + static makeImplicitPublicActuallyPublic(data, reportViolation) { + // TS-HACK + // A subtype can make an inherited protected field public. To prevent accidential + // mangling of public fields we mark the original (protected) fields as public... + for (const [name, info] of data.fields) { + if (info.type !== 0 /* FieldType.Public */) { + continue; + } + let parent = data.parent; + while (parent) { + if (parent.fields.get(name)?.type === 1 /* FieldType.Protected */) { + const parentPos = parent.node.getSourceFile().getLineAndCharacterOfPosition(parent.fields.get(name).pos); + const infoPos = data.node.getSourceFile().getLineAndCharacterOfPosition(info.pos); + reportViolation(name, `'${name}' from ${parent.fileName}:${parentPos.line + 1}`, `${data.fileName}:${infoPos.line + 1}`); + parent.fields.get(name).type = 0 /* FieldType.Public */; + } + parent = parent.parent; + } + } + } + static fillInReplacement(data) { + if (data.replacements) { + // already done + return; + } + // fill in parents first + if (data.parent) { + ClassData.fillInReplacement(data.parent); + } + data.replacements = new Map(); + const isNameTaken = (name) => { + // locally taken + if (data._isNameTaken(name)) { + return true; + } + // parents + let parent = data.parent; + while (parent) { + if (parent._isNameTaken(name)) { + return true; + } + parent = parent.parent; + } + // children + if (data.children) { + const stack = [...data.children]; + while (stack.length) { + const node = stack.pop(); + if (node._isNameTaken(name)) { + return true; + } + if (node.children) { + stack.push(...node.children); + } + } + } + return false; + }; + const identPool = new ShortIdent(''); + for (const [name, info] of data.fields) { + if (ClassData._shouldMangle(info.type)) { + const shortName = identPool.next(isNameTaken); + data.replacements.set(name, shortName); + } + } + } + // a name is taken when a field that doesn't get mangled exists or + // when the name is already in use for replacement + _isNameTaken(name) { + if (this.fields.has(name) && !ClassData._shouldMangle(this.fields.get(name).type)) { + // public field + return true; + } + if (this.replacements) { + for (const shortName of this.replacements.values()) { + if (shortName === name) { + // replaced already (happens wih super types) + return true; + } + } + } + if (isNameTakenInFile(this.node, name)) { + return true; + } + return false; + } + lookupShortName(name) { + let value = this.replacements.get(name); + let parent = this.parent; + while (parent) { + if (parent.replacements.has(name) && parent.fields.get(name)?.type === 1 /* FieldType.Protected */) { + value = parent.replacements.get(name) ?? value; + } + parent = parent.parent; + } + return value; + } + // --- parent chaining + addChild(child) { + this.children ??= []; + this.children.push(child); + child.parent = this; + } +} +function isNameTakenInFile(node, name) { + const identifiers = node.getSourceFile().identifiers; + if (identifiers instanceof Map) { + if (identifiers.has(name)) { + return true; + } + } + return false; +} +const fileIdents = new class { + idents = new ShortIdent('$'); + next() { + return this.idents.next(); + } +}; +const skippedExportMangledFiles = [ + // Build + 'css.build', + 'nls.build', + // Monaco + 'editorCommon', + 'editorOptions', + 'editorZoom', + 'standaloneEditor', + 'standaloneEnums', + 'standaloneLanguages', + // Generated + 'extensionsApiProposals', + // Module passed around as type + 'pfs', + // entry points + ...[ + buildfile.entrypoint('vs/server/node/server.main', []), + buildfile.entrypoint('vs/workbench/workbench.desktop.main', []), + buildfile.base, + buildfile.workerExtensionHost, + buildfile.workerNotebook, + buildfile.workerLanguageDetection, + buildfile.workerLocalFileSearch, + buildfile.workerProfileAnalysis, + buildfile.workbenchDesktop, + buildfile.workbenchWeb, + buildfile.code + ].flat().map(x => x.name), +]; +const skippedExportMangledProjects = [ + // Test projects + 'vscode-api-tests', + // These projects use webpack to dynamically rewrite imports, which messes up our mangling + 'configuration-editing', + 'microsoft-authentication', + 'github-authentication', + 'html-language-features/server', +]; +const skippedExportMangledSymbols = [ + // Don't mangle extension entry points + 'activate', + 'deactivate', +]; +class DeclarationData { + fileName; + node; + service; + replacementName; + constructor(fileName, node, service) { + this.fileName = fileName; + this.node = node; + this.service = service; + // Todo: generate replacement names based on usage count, with more used names getting shorter identifiers + this.replacementName = fileIdents.next(); + } + get locations() { + if (ts.isVariableDeclaration(this.node)) { + // If the const aliases any types, we need to rename those too + const definitionResult = this.service.getDefinitionAndBoundSpan(this.fileName, this.node.name.getStart()); + if (definitionResult?.definitions && definitionResult.definitions.length > 1) { + return definitionResult.definitions.map(x => ({ fileName: x.fileName, offset: x.textSpan.start })); + } + } + return [{ + fileName: this.fileName, + offset: this.node.name.getStart() + }]; + } + shouldMangle(newName) { + const currentName = this.node.name.getText(); + if (currentName.startsWith('$') || skippedExportMangledSymbols.includes(currentName)) { + return false; + } + // New name is longer the existing one :'( + if (newName.length >= currentName.length) { + return false; + } + // Don't mangle functions we've explicitly opted out + if (this.node.getFullText().includes('@skipMangle')) { + return false; + } + return true; + } +} +/** + * TypeScript2TypeScript transformer that mangles all private and protected fields + * + * 1. Collect all class fields (properties, methods) + * 2. Collect all sub and super-type relations between classes + * 3. Compute replacement names for each field + * 4. Lookup rename locations for these fields + * 5. Prepare and apply edits + */ +class Mangler { + projectPath; + log; + config; + allClassDataByKey = new Map(); + allExportedSymbols = new Set(); + service; + renameWorkerPool; + constructor(projectPath, log = () => { }, config) { + this.projectPath = projectPath; + this.log = log; + this.config = config; + this.service = ts.createLanguageService(new staticLanguageServiceHost_1.StaticLanguageServiceHost(projectPath)); + this.renameWorkerPool = workerpool.pool(path.join(__dirname, 'renameWorker.js'), { + maxWorkers: 2, + minWorkers: 'max' + }); + } + async computeNewFileContents(strictImplicitPublicHandling) { + // STEP: + // - Find all classes and their field info. + // - Find exported symbols. + const visit = (node) => { + if (this.config.manglePrivateFields) { + if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { + const anchor = node.name ?? node; + const key = `${node.getSourceFile().fileName}|${anchor.getStart()}`; + if (this.allClassDataByKey.has(key)) { + throw new Error('DUPE?'); + } + this.allClassDataByKey.set(key, new ClassData(node.getSourceFile().fileName, node)); + } + } + if (this.config.mangleExports) { + // Find exported classes, functions, and vars + if (( + // Exported class + ts.isClassDeclaration(node) + && hasModifier(node, ts.SyntaxKind.ExportKeyword) + && node.name) || ( + // Exported function + ts.isFunctionDeclaration(node) + && ts.isSourceFile(node.parent) + && hasModifier(node, ts.SyntaxKind.ExportKeyword) + && node.name && node.body // On named function and not on the overload + ) || ( + // Exported variable + ts.isVariableDeclaration(node) + && hasModifier(node.parent.parent, ts.SyntaxKind.ExportKeyword) // Variable statement is exported + && ts.isSourceFile(node.parent.parent.parent)) + // Disabled for now because we need to figure out how to handle + // enums that are used in monaco or extHost interfaces. + /* || ( + // Exported enum + ts.isEnumDeclaration(node) + && ts.isSourceFile(node.parent) + && hasModifier(node, ts.SyntaxKind.ExportKeyword) + && !hasModifier(node, ts.SyntaxKind.ConstKeyword) // Don't bother mangling const enums because these are inlined + && node.name + */ + ) { + if (isInAmbientContext(node)) { + return; + } + this.allExportedSymbols.add(new DeclarationData(node.getSourceFile().fileName, node, this.service)); + } + } + ts.forEachChild(node, visit); + }; + for (const file of this.service.getProgram().getSourceFiles()) { + if (!file.isDeclarationFile) { + ts.forEachChild(file, visit); + } + } + this.log(`Done collecting. Classes: ${this.allClassDataByKey.size}. Exported symbols: ${this.allExportedSymbols.size}`); + // STEP: connect sub and super-types + const setupParents = (data) => { + const extendsClause = data.node.heritageClauses?.find(h => h.token === ts.SyntaxKind.ExtendsKeyword); + if (!extendsClause) { + // no EXTENDS-clause + return; + } + const info = this.service.getDefinitionAtPosition(data.fileName, extendsClause.types[0].expression.getEnd()); + if (!info || info.length === 0) { + // throw new Error('SUPER type not found'); + return; + } + if (info.length !== 1) { + // inherits from declared/library type + return; + } + const [definition] = info; + const key = `${definition.fileName}|${definition.textSpan.start}`; + const parent = this.allClassDataByKey.get(key); + if (!parent) { + // throw new Error(`SUPER type not found: ${key}`); + return; + } + parent.addChild(data); + }; + for (const data of this.allClassDataByKey.values()) { + setupParents(data); + } + // STEP: make implicit public (actually protected) field really public + const violations = new Map(); + let violationsCauseFailure = false; + for (const data of this.allClassDataByKey.values()) { + ClassData.makeImplicitPublicActuallyPublic(data, (name, what, why) => { + const arr = violations.get(what); + if (arr) { + arr.push(why); + } + else { + violations.set(what, [why]); + } + if (strictImplicitPublicHandling && !strictImplicitPublicHandling.has(name)) { + violationsCauseFailure = true; + } + }); + } + for (const [why, whys] of violations) { + this.log(`WARN: ${why} became PUBLIC because of: ${whys.join(' , ')}`); + } + if (violationsCauseFailure) { + const message = 'Protected fields have been made PUBLIC. This hurts minification and is therefore not allowed. Review the WARN messages further above'; + this.log(`ERROR: ${message}`); + throw new Error(message); + } + // STEP: compute replacement names for each class + for (const data of this.allClassDataByKey.values()) { + ClassData.fillInReplacement(data); + } + this.log(`Done creating class replacements`); + // STEP: prepare rename edits + this.log(`Starting prepare rename edits`); + const editsByFile = new Map(); + const appendEdit = (fileName, edit) => { + const edits = editsByFile.get(fileName); + if (!edits) { + editsByFile.set(fileName, [edit]); + } + else { + edits.push(edit); + } + }; + const appendRename = (newText, loc) => { + appendEdit(loc.fileName, { + newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), + offset: loc.textSpan.start, + length: loc.textSpan.length + }); + }; + const renameResults = []; + const queueRename = (fileName, pos, newName) => { + renameResults.push(Promise.resolve(this.renameWorkerPool.exec('findRenameLocations', [this.projectPath, fileName, pos])) + .then((locations) => ({ newName, locations }))); + }; + for (const data of this.allClassDataByKey.values()) { + if (hasModifier(data.node, ts.SyntaxKind.DeclareKeyword)) { + continue; + } + fields: for (const [name, info] of data.fields) { + if (!ClassData._shouldMangle(info.type)) { + continue fields; + } + // TS-HACK: protected became public via 'some' child + // and because of that we might need to ignore this now + let parent = data.parent; + while (parent) { + if (parent.fields.get(name)?.type === 0 /* FieldType.Public */) { + continue fields; + } + parent = parent.parent; + } + const newName = data.lookupShortName(name); + queueRename(data.fileName, info.pos, newName); + } + } + for (const data of this.allExportedSymbols.values()) { + if (data.fileName.endsWith('.d.ts') + || skippedExportMangledProjects.some(proj => data.fileName.includes(proj)) + || skippedExportMangledFiles.some(file => data.fileName.endsWith(file + '.ts'))) { + continue; + } + if (!data.shouldMangle(data.replacementName)) { + continue; + } + const newText = data.replacementName; + for (const { fileName, offset } of data.locations) { + queueRename(fileName, offset, newText); + } + } + await Promise.all(renameResults).then((result) => { + for (const { newName, locations } of result) { + for (const loc of locations) { + appendRename(newName, loc); + } + } + }); + await this.renameWorkerPool.terminate(); + this.log(`Done preparing edits: ${editsByFile.size} files`); + // STEP: apply all rename edits (per file) + const result = new Map(); + let savedBytes = 0; + for (const item of this.service.getProgram().getSourceFiles()) { + const { mapRoot, sourceRoot } = this.service.getProgram().getCompilerOptions(); + const projectDir = path.dirname(this.projectPath); + const sourceMapRoot = mapRoot ?? (0, url_1.pathToFileURL)(sourceRoot ?? projectDir).toString(); + // source maps + let generator; + let newFullText; + const edits = editsByFile.get(item.fileName); + if (!edits) { + // just copy + newFullText = item.getFullText(); + } + else { + // source map generator + const relativeFileName = normalize(path.relative(projectDir, item.fileName)); + const mappingsByLine = new Map(); + // apply renames + edits.sort((a, b) => b.offset - a.offset); + const characters = item.getFullText().split(''); + let lastEdit; + for (const edit of edits) { + if (lastEdit && lastEdit.offset === edit.offset) { + // + if (lastEdit.length !== edit.length || lastEdit.newText !== edit.newText) { + this.log('ERROR: Overlapping edit', item.fileName, edit.offset, edits); + throw new Error('OVERLAPPING edit'); + } + else { + continue; + } + } + lastEdit = edit; + const mangledName = characters.splice(edit.offset, edit.length, edit.newText).join(''); + savedBytes += mangledName.length - edit.newText.length; + // source maps + const pos = item.getLineAndCharacterOfPosition(edit.offset); + let mappings = mappingsByLine.get(pos.line); + if (!mappings) { + mappings = []; + mappingsByLine.set(pos.line, mappings); + } + mappings.unshift({ + source: relativeFileName, + original: { line: pos.line + 1, column: pos.character }, + generated: { line: pos.line + 1, column: pos.character }, + name: mangledName + }, { + source: relativeFileName, + original: { line: pos.line + 1, column: pos.character + edit.length }, + generated: { line: pos.line + 1, column: pos.character + edit.newText.length }, + }); + } + // source map generation, make sure to get mappings per line correct + generator = new source_map_1.SourceMapGenerator({ file: path.basename(item.fileName), sourceRoot: sourceMapRoot }); + generator.setSourceContent(relativeFileName, item.getFullText()); + for (const [, mappings] of mappingsByLine) { + let lineDelta = 0; + for (const mapping of mappings) { + generator.addMapping({ + ...mapping, + generated: { line: mapping.generated.line, column: mapping.generated.column - lineDelta } + }); + lineDelta += mapping.original.column - mapping.generated.column; + } + } + newFullText = characters.join(''); + } + result.set(item.fileName, { out: newFullText, sourceMap: generator?.toString() }); + } + this.log(`Done: ${savedBytes / 1000}kb saved`); + return result; + } +} +exports.Mangler = Mangler; +// --- ast utils +function hasModifier(node, kind) { + const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined; + return Boolean(modifiers?.find(mode => mode.kind === kind)); +} +function isInAmbientContext(node) { + for (let p = node.parent; p; p = p.parent) { + if (ts.isModuleDeclaration(p)) { + return true; + } + } + return false; +} +function normalize(path) { + return path.replace(/\\/g, '/'); +} +async function _run() { + const root = path.join(__dirname, '..', '..', '..'); + const projectBase = path.join(root, 'src'); + const projectPath = path.join(projectBase, 'tsconfig.json'); + const newProjectBase = path.join(path.dirname(projectBase), path.basename(projectBase) + '2'); + fs.cpSync(projectBase, newProjectBase, { recursive: true }); + const mangler = new Mangler(projectPath, console.log, { + mangleExports: true, + manglePrivateFields: true, + }); + for (const [fileName, contents] of await mangler.computeNewFileContents(new Set(['saveState']))) { + const newFilePath = path.join(newProjectBase, path.relative(projectBase, fileName)); + await fs.promises.mkdir(path.dirname(newFilePath), { recursive: true }); + await fs.promises.writeFile(newFilePath, contents.out); + if (contents.sourceMap) { + await fs.promises.writeFile(newFilePath + '.map', contents.sourceMap); + } + } +} +if (__filename === process_1.argv[1]) { + _run(); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/build/lib/mangleTypeScript.ts b/build/lib/mangle/index.ts similarity index 63% rename from build/lib/mangleTypeScript.ts rename to build/lib/mangle/index.ts index f2707dd3238..c0bfdc9e3ed 100644 --- a/build/lib/mangleTypeScript.ts +++ b/build/lib/mangle/index.ts @@ -3,12 +3,15 @@ * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -import * as ts from 'typescript'; -import * as path from 'path'; import * as fs from 'fs'; +import * as path from 'path'; import { argv } from 'process'; import { Mapping, SourceMapGenerator } from 'source-map'; +import * as ts from 'typescript'; import { pathToFileURL } from 'url'; +import * as workerpool from 'workerpool'; +import { StaticLanguageServiceHost } from './staticLanguageServiceHost'; +const buildfile = require('../../../src/buildfile'); class ShortIdent { @@ -17,21 +20,20 @@ class ShortIdent { 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']); - private static _alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''); + private static _alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890$_'.split(''); private _value = 0; - private readonly _isNameTaken: (name: string) => boolean; - constructor(isNameTaken: (name: string) => boolean) { - this._isNameTaken = name => ShortIdent._keywords.has(name) || isNameTaken(name); - } + constructor( + private readonly prefix: string + ) { } - next(): string { - const candidate = ShortIdent.convert(this._value); + next(isNameTaken?: (name: string) => boolean): string { + const candidate = this.prefix + ShortIdent.convert(this._value); this._value++; - if (this._isNameTaken(candidate)) { + if (ShortIdent._keywords.has(candidate) || /^[_0-9]/.test(candidate) || isNameTaken?.(candidate)) { // try again - return this.next(); + return this.next(isNameTaken); } return candidate; } @@ -181,8 +183,7 @@ class ClassData { data.replacements = new Map(); - const identPool = new ShortIdent(name => { - + const isNameTaken = (name: string) => { // locally taken if (data._isNameTaken(name)) { return true; @@ -212,11 +213,12 @@ class ClassData { } return false; - }); + }; + const identPool = new ShortIdent(''); for (const [name, info] of data.fields) { if (ClassData._shouldMangle(info.type)) { - const shortName = identPool.next(); + const shortName = identPool.next(isNameTaken); data.replacements.set(name, shortName); } } @@ -237,12 +239,11 @@ class ClassData { } } } - if ((this.node.getSourceFile()).identifiers instanceof Map) { - // taken by any other usage - if ((this.node.getSourceFile()).identifiers.has(name)) { - return true; - } + + if (isNameTakenInFile(this.node, name)) { + return true; } + return false; } @@ -267,59 +268,122 @@ class ClassData { } } -class StaticLanguageServiceHost implements ts.LanguageServiceHost { - - private readonly _cmdLine: ts.ParsedCommandLine; - private readonly _scriptSnapshots: Map = new Map(); - - constructor(readonly projectPath: string) { - const existingOptions: Partial = {}; - const parsed = ts.readConfigFile(projectPath, ts.sys.readFile); - if (parsed.error) { - throw parsed.error; - } - this._cmdLine = ts.parseJsonConfigFileContent(parsed.config, ts.sys, path.dirname(projectPath), existingOptions); - if (this._cmdLine.errors.length > 0) { - throw parsed.error; +function isNameTakenInFile(node: ts.Node, name: string): boolean { + const identifiers = (node.getSourceFile()).identifiers; + if (identifiers instanceof Map) { + if (identifiers.has(name)) { + return true; } } - getCompilationSettings(): ts.CompilerOptions { - return this._cmdLine.options; + return false; +} + +const fileIdents = new class { + private readonly idents = new ShortIdent('$'); + + next() { + return this.idents.next(); } - getScriptFileNames(): string[] { - return this._cmdLine.fileNames; +}; + +const skippedExportMangledFiles = [ + // Build + 'css.build', + 'nls.build', + + // Monaco + 'editorCommon', + 'editorOptions', + 'editorZoom', + 'standaloneEditor', + 'standaloneEnums', + 'standaloneLanguages', + + // Generated + 'extensionsApiProposals', + + // Module passed around as type + 'pfs', + + // entry points + ...[ + buildfile.entrypoint('vs/server/node/server.main', []), + buildfile.entrypoint('vs/workbench/workbench.desktop.main', []), + buildfile.base, + buildfile.workerExtensionHost, + buildfile.workerNotebook, + buildfile.workerLanguageDetection, + buildfile.workerLocalFileSearch, + buildfile.workerProfileAnalysis, + buildfile.workbenchDesktop, + buildfile.workbenchWeb, + buildfile.code + ].flat().map(x => x.name), +]; + +const skippedExportMangledProjects = [ + // Test projects + 'vscode-api-tests', + + // These projects use webpack to dynamically rewrite imports, which messes up our mangling + 'configuration-editing', + 'microsoft-authentication', + 'github-authentication', + 'html-language-features/server', +]; + +const skippedExportMangledSymbols = [ + // Don't mangle extension entry points + 'activate', + 'deactivate', +]; + +class DeclarationData { + + readonly replacementName: string; + + constructor( + readonly fileName: string, + readonly node: ts.FunctionDeclaration | ts.ClassDeclaration | ts.EnumDeclaration | ts.VariableDeclaration, + private readonly service: ts.LanguageService, + ) { + // Todo: generate replacement names based on usage count, with more used names getting shorter identifiers + this.replacementName = fileIdents.next(); } - getScriptVersion(_fileName: string): string { - return '1'; - } - getProjectVersion(): string { - return '1'; - } - getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined { - let result: ts.IScriptSnapshot | undefined = this._scriptSnapshots.get(fileName); - if (result === undefined) { - const content = ts.sys.readFile(fileName); - if (content === undefined) { - return undefined; + + get locations(): Iterable<{ fileName: string; offset: number }> { + if (ts.isVariableDeclaration(this.node)) { + // If the const aliases any types, we need to rename those too + const definitionResult = this.service.getDefinitionAndBoundSpan(this.fileName, this.node.name.getStart()); + if (definitionResult?.definitions && definitionResult.definitions.length > 1) { + return definitionResult.definitions.map(x => ({ fileName: x.fileName, offset: x.textSpan.start })); } - result = ts.ScriptSnapshot.fromString(content); - this._scriptSnapshots.set(fileName, result); } - return result; + + return [{ + fileName: this.fileName, + offset: this.node.name!.getStart() + }]; } - getCurrentDirectory(): string { - return path.dirname(this.projectPath); + + shouldMangle(newName: string): boolean { + const currentName = this.node.name!.getText(); + if (currentName.startsWith('$') || skippedExportMangledSymbols.includes(currentName)) { + return false; + } + + // New name is longer the existing one :'( + if (newName.length >= currentName.length) { + return false; + } + + // Don't mangle functions we've explicitly opted out + if (this.node.getFullText().includes('@skipMangle')) { + return false; + } + + return true; } - getDefaultLibFileName(options: ts.CompilerOptions): string { - return ts.getDefaultLibFilePath(options); - } - directoryExists = ts.sys.directoryExists; - getDirectories = ts.sys.getDirectories; - fileExists = ts.sys.fileExists; - readFile = ts.sys.readFile; - readDirectory = ts.sys.readDirectory; - // this is necessary to make source references work. - realpath = ts.sys.realpath; } export interface MangleOutput { @@ -339,26 +403,82 @@ export interface MangleOutput { export class Mangler { private readonly allClassDataByKey = new Map(); + private readonly allExportedSymbols = new Set(); private readonly service: ts.LanguageService; + private readonly renameWorkerPool: workerpool.WorkerPool; - constructor(readonly projectPath: string, readonly log: typeof console.log = () => { }) { + constructor( + private readonly projectPath: string, + private readonly log: typeof console.log = () => { }, + private readonly config: { readonly manglePrivateFields: boolean; readonly mangleExports: boolean }, + ) { this.service = ts.createLanguageService(new StaticLanguageServiceHost(projectPath)); + + this.renameWorkerPool = workerpool.pool(path.join(__dirname, 'renameWorker.js'), { + maxWorkers: 2, + minWorkers: 'max' + }); } - computeNewFileContents(strictImplicitPublicHandling?: Set): Map { + async computeNewFileContents(strictImplicitPublicHandling?: Set): Promise> { - // STEP: find all classes and their field info + // STEP: + // - Find all classes and their field info. + // - Find exported symbols. const visit = (node: ts.Node): void => { - if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { - const anchor = node.name ?? node; - const key = `${node.getSourceFile().fileName}|${anchor.getStart()}`; - if (this.allClassDataByKey.has(key)) { - throw new Error('DUPE?'); + if (this.config.manglePrivateFields) { + if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { + const anchor = node.name ?? node; + const key = `${node.getSourceFile().fileName}|${anchor.getStart()}`; + if (this.allClassDataByKey.has(key)) { + throw new Error('DUPE?'); + } + this.allClassDataByKey.set(key, new ClassData(node.getSourceFile().fileName, node)); } - this.allClassDataByKey.set(key, new ClassData(node.getSourceFile().fileName, node)); } + + if (this.config.mangleExports) { + // Find exported classes, functions, and vars + if ( + ( + // Exported class + ts.isClassDeclaration(node) + && hasModifier(node, ts.SyntaxKind.ExportKeyword) + && node.name + ) || ( + // Exported function + ts.isFunctionDeclaration(node) + && ts.isSourceFile(node.parent) + && hasModifier(node, ts.SyntaxKind.ExportKeyword) + && node.name && node.body // On named function and not on the overload + ) || ( + // Exported variable + ts.isVariableDeclaration(node) + && hasModifier(node.parent.parent, ts.SyntaxKind.ExportKeyword) // Variable statement is exported + && ts.isSourceFile(node.parent.parent.parent) + ) + + // Disabled for now because we need to figure out how to handle + // enums that are used in monaco or extHost interfaces. + /* || ( + // Exported enum + ts.isEnumDeclaration(node) + && ts.isSourceFile(node.parent) + && hasModifier(node, ts.SyntaxKind.ExportKeyword) + && !hasModifier(node, ts.SyntaxKind.ConstKeyword) // Don't bother mangling const enums because these are inlined + && node.name + */ + ) { + if (isInAmbientContext(node)) { + return; + } + + this.allExportedSymbols.add(new DeclarationData(node.getSourceFile().fileName, node, this.service)); + } + } + ts.forEachChild(node, visit); }; @@ -367,7 +487,7 @@ export class Mangler { ts.forEachChild(file, visit); } } - this.log(`Done collecting classes: ${this.allClassDataByKey.size}`); + this.log(`Done collecting. Classes: ${this.allClassDataByKey.size}. Exported symbols: ${this.allExportedSymbols.size}`); // STEP: connect sub and super-types @@ -433,9 +553,11 @@ export class Mangler { for (const data of this.allClassDataByKey.values()) { ClassData.fillInReplacement(data); } - this.log(`Done creating replacements`); + this.log(`Done creating class replacements`); // STEP: prepare rename edits + this.log(`Starting prepare rename edits`); + type Edit = { newText: string; offset: number; length: number }; const editsByFile = new Map(); @@ -447,9 +569,24 @@ export class Mangler { edits.push(edit); } }; + const appendRename = (newText: string, loc: ts.RenameLocation) => { + appendEdit(loc.fileName, { + newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), + offset: loc.textSpan.start, + length: loc.textSpan.length + }); + }; + + type RenameFn = (projectName: string, fileName: string, pos: number) => ts.RenameLocation[]; + + const renameResults: Array> = []; + + const queueRename = (fileName: string, pos: number, newName: string) => { + renameResults.push(Promise.resolve(this.renameWorkerPool.exec('findRenameLocations', [this.projectPath, fileName, pos])) + .then((locations) => ({ newName, locations }))); + }; for (const data of this.allClassDataByKey.values()) { - if (hasModifier(data.node, ts.SyntaxKind.DeclareKeyword)) { continue; } @@ -469,18 +606,39 @@ export class Mangler { parent = parent.parent; } - const newText = data.lookupShortName(name); - const locations = this.service.findRenameLocations(data.fileName, info.pos, false, false, true) ?? []; - for (const loc of locations) { - appendEdit(loc.fileName, { - newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), - offset: loc.textSpan.start, - length: loc.textSpan.length - }); - } + const newName = data.lookupShortName(name); + queueRename(data.fileName, info.pos, newName); } } + for (const data of this.allExportedSymbols.values()) { + if (data.fileName.endsWith('.d.ts') + || skippedExportMangledProjects.some(proj => data.fileName.includes(proj)) + || skippedExportMangledFiles.some(file => data.fileName.endsWith(file + '.ts')) + ) { + continue; + } + + if (!data.shouldMangle(data.replacementName)) { + continue; + } + + const newText = data.replacementName; + for (const { fileName, offset } of data.locations) { + queueRename(fileName, offset, newText); + } + } + + await Promise.all(renameResults).then((result) => { + for (const { newName, locations } of result) { + for (const loc of locations) { + appendRename(newName, loc); + } + } + }); + + await this.renameWorkerPool.terminate(); + this.log(`Done preparing edits: ${editsByFile.size} files`); // STEP: apply all rename edits (per file) @@ -579,17 +737,32 @@ function hasModifier(node: ts.Node, kind: ts.SyntaxKind) { return Boolean(modifiers?.find(mode => mode.kind === kind)); } +function isInAmbientContext(node: ts.Node): boolean { + for (let p = node.parent; p; p = p.parent) { + if (ts.isModuleDeclaration(p)) { + return true; + } + } + return false; +} + function normalize(path: string): string { return path.replace(/\\/g, '/'); } async function _run() { - - const projectPath = path.join(__dirname, '../../src/tsconfig.json'); - const projectBase = path.dirname(projectPath); + const root = path.join(__dirname, '..', '..', '..'); + const projectBase = path.join(root, 'src'); + const projectPath = path.join(projectBase, 'tsconfig.json'); const newProjectBase = path.join(path.dirname(projectBase), path.basename(projectBase) + '2'); - for await (const [fileName, contents] of new Mangler(projectPath, console.log).computeNewFileContents(new Set(['saveState']))) { + fs.cpSync(projectBase, newProjectBase, { recursive: true }); + + const mangler = new Mangler(projectPath, console.log, { + mangleExports: true, + manglePrivateFields: true, + }); + for (const [fileName, contents] of await mangler.computeNewFileContents(new Set(['saveState']))) { const newFilePath = path.join(newProjectBase, path.relative(projectBase, fileName)); await fs.promises.mkdir(path.dirname(newFilePath), { recursive: true }); await fs.promises.writeFile(newFilePath, contents.out); diff --git a/build/lib/mangle/renameWorker.js b/build/lib/mangle/renameWorker.js new file mode 100644 index 00000000000..ce4b96275a3 --- /dev/null +++ b/build/lib/mangle/renameWorker.js @@ -0,0 +1,20 @@ +"use strict"; +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +Object.defineProperty(exports, "__esModule", { value: true }); +const ts = require("typescript"); +const workerpool = require("workerpool"); +const staticLanguageServiceHost_1 = require("./staticLanguageServiceHost"); +let service; // = ts.createLanguageService(new StaticLanguageServiceHost(projectPath)); +function findRenameLocations(projectPath, fileName, position) { + if (!service) { + service = ts.createLanguageService(new staticLanguageServiceHost_1.StaticLanguageServiceHost(projectPath)); + } + return service.findRenameLocations(fileName, position, false, false, true) ?? []; +} +workerpool.worker({ + findRenameLocations +}); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuYW1lV29ya2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsicmVuYW1lV29ya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7O2dHQUdnRzs7QUFFaEcsaUNBQWlDO0FBQ2pDLHlDQUF5QztBQUN6QywyRUFBd0U7QUFFeEUsSUFBSSxPQUF1QyxDQUFDLENBQUEsMEVBQTBFO0FBRXRILFNBQVMsbUJBQW1CLENBQzNCLFdBQW1CLEVBQ25CLFFBQWdCLEVBQ2hCLFFBQWdCO0lBRWhCLElBQUksQ0FBQyxPQUFPLEVBQUU7UUFDYixPQUFPLEdBQUcsRUFBRSxDQUFDLHFCQUFxQixDQUFDLElBQUkscURBQXlCLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztLQUMvRTtJQUVELE9BQU8sT0FBTyxDQUFDLG1CQUFtQixDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7QUFDbEYsQ0FBQztBQUVELFVBQVUsQ0FBQyxNQUFNLENBQUM7SUFDakIsbUJBQW1CO0NBQ25CLENBQUMsQ0FBQyJ9 \ No newline at end of file diff --git a/build/lib/mangle/renameWorker.ts b/build/lib/mangle/renameWorker.ts new file mode 100644 index 00000000000..b5d6bcd5bc9 --- /dev/null +++ b/build/lib/mangle/renameWorker.ts @@ -0,0 +1,26 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import * as ts from 'typescript'; +import * as workerpool from 'workerpool'; +import { StaticLanguageServiceHost } from './staticLanguageServiceHost'; + +let service: ts.LanguageService | undefined;// = ts.createLanguageService(new StaticLanguageServiceHost(projectPath)); + +function findRenameLocations( + projectPath: string, + fileName: string, + position: number, +): readonly ts.RenameLocation[] { + if (!service) { + service = ts.createLanguageService(new StaticLanguageServiceHost(projectPath)); + } + + return service.findRenameLocations(fileName, position, false, false, true) ?? []; +} + +workerpool.worker({ + findRenameLocations +}); diff --git a/build/lib/mangle/staticLanguageServiceHost.js b/build/lib/mangle/staticLanguageServiceHost.js new file mode 100644 index 00000000000..acf48be8442 --- /dev/null +++ b/build/lib/mangle/staticLanguageServiceHost.js @@ -0,0 +1,65 @@ +"use strict"; +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.StaticLanguageServiceHost = void 0; +const ts = require("typescript"); +const path = require("path"); +class StaticLanguageServiceHost { + projectPath; + _cmdLine; + _scriptSnapshots = new Map(); + constructor(projectPath) { + this.projectPath = projectPath; + const existingOptions = {}; + const parsed = ts.readConfigFile(projectPath, ts.sys.readFile); + if (parsed.error) { + throw parsed.error; + } + this._cmdLine = ts.parseJsonConfigFileContent(parsed.config, ts.sys, path.dirname(projectPath), existingOptions); + if (this._cmdLine.errors.length > 0) { + throw parsed.error; + } + } + getCompilationSettings() { + return this._cmdLine.options; + } + getScriptFileNames() { + return this._cmdLine.fileNames; + } + getScriptVersion(_fileName) { + return '1'; + } + getProjectVersion() { + return '1'; + } + getScriptSnapshot(fileName) { + let result = this._scriptSnapshots.get(fileName); + if (result === undefined) { + const content = ts.sys.readFile(fileName); + if (content === undefined) { + return undefined; + } + result = ts.ScriptSnapshot.fromString(content); + this._scriptSnapshots.set(fileName, result); + } + return result; + } + getCurrentDirectory() { + return path.dirname(this.projectPath); + } + getDefaultLibFileName(options) { + return ts.getDefaultLibFilePath(options); + } + directoryExists = ts.sys.directoryExists; + getDirectories = ts.sys.getDirectories; + fileExists = ts.sys.fileExists; + readFile = ts.sys.readFile; + readDirectory = ts.sys.readDirectory; + // this is necessary to make source references work. + realpath = ts.sys.realpath; +} +exports.StaticLanguageServiceHost = StaticLanguageServiceHost; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/build/lib/mangle/staticLanguageServiceHost.ts b/build/lib/mangle/staticLanguageServiceHost.ts new file mode 100644 index 00000000000..c2793342ce3 --- /dev/null +++ b/build/lib/mangle/staticLanguageServiceHost.ts @@ -0,0 +1,62 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import * as ts from 'typescript'; +import * as path from 'path'; + +export class StaticLanguageServiceHost implements ts.LanguageServiceHost { + + private readonly _cmdLine: ts.ParsedCommandLine; + private readonly _scriptSnapshots: Map = new Map(); + + constructor(readonly projectPath: string) { + const existingOptions: Partial = {}; + const parsed = ts.readConfigFile(projectPath, ts.sys.readFile); + if (parsed.error) { + throw parsed.error; + } + this._cmdLine = ts.parseJsonConfigFileContent(parsed.config, ts.sys, path.dirname(projectPath), existingOptions); + if (this._cmdLine.errors.length > 0) { + throw parsed.error; + } + } + getCompilationSettings(): ts.CompilerOptions { + return this._cmdLine.options; + } + getScriptFileNames(): string[] { + return this._cmdLine.fileNames; + } + getScriptVersion(_fileName: string): string { + return '1'; + } + getProjectVersion(): string { + return '1'; + } + getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined { + let result: ts.IScriptSnapshot | undefined = this._scriptSnapshots.get(fileName); + if (result === undefined) { + const content = ts.sys.readFile(fileName); + if (content === undefined) { + return undefined; + } + result = ts.ScriptSnapshot.fromString(content); + this._scriptSnapshots.set(fileName, result); + } + return result; + } + getCurrentDirectory(): string { + return path.dirname(this.projectPath); + } + getDefaultLibFileName(options: ts.CompilerOptions): string { + return ts.getDefaultLibFilePath(options); + } + directoryExists = ts.sys.directoryExists; + getDirectories = ts.sys.getDirectories; + fileExists = ts.sys.fileExists; + readFile = ts.sys.readFile; + readDirectory = ts.sys.readDirectory; + // this is necessary to make source references work. + realpath = ts.sys.realpath; +} diff --git a/build/lib/mangleTypeScript.js b/build/lib/mangleTypeScript.js index 7948e917e31..45b50148d12 100644 --- a/build/lib/mangleTypeScript.js +++ b/build/lib/mangleTypeScript.js @@ -16,18 +16,20 @@ class ShortIdent { 'default', 'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']); - static _alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''); + static _alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890$_'.split(''); _value = 0; _isNameTaken; - constructor(isNameTaken) { - this._isNameTaken = name => ShortIdent._keywords.has(name) || isNameTaken(name); + prefix; + constructor(prefix, isNameTaken) { + this.prefix = prefix; + this._isNameTaken = name => ShortIdent._keywords.has(name) || /^[_0-9]/.test(name) || isNameTaken(name); } - next() { - const candidate = ShortIdent.convert(this._value); + next(localIsNameTaken) { + const candidate = this.prefix + ShortIdent.convert(this._value); this._value++; - if (this._isNameTaken(candidate)) { + if (this._isNameTaken(candidate) || localIsNameTaken?.(candidate)) { // try again - return this.next(); + return this.next(localIsNameTaken); } return candidate; } @@ -160,7 +162,7 @@ class ClassData { ClassData.fillInReplacement(data.parent); } data.replacements = new Map(); - const identPool = new ShortIdent(name => { + const identPool = new ShortIdent('', name => { // locally taken if (data._isNameTaken(name)) { return true; @@ -210,11 +212,8 @@ class ClassData { } } } - if (this.node.getSourceFile().identifiers instanceof Map) { - // taken by any other usage - if (this.node.getSourceFile().identifiers.has(name)) { - return true; - } + if (isNameTakenInFile(this.node, name)) { + return true; } return false; } @@ -236,6 +235,104 @@ class ClassData { child.parent = this; } } +function isNameTakenInFile(node, name) { + const identifiers = node.getSourceFile().identifiers; + if (identifiers instanceof Map) { + if (identifiers.has(name)) { + return true; + } + } + return false; +} +const fileIdents = new class { + idents = new ShortIdent('$', () => false); + next(file) { + return this.idents.next(name => isNameTakenInFile(file, name)); + } +}; +const skippedFiles = [ + // Build + 'css.build.ts', + 'nls.build.ts', + // Monaco + 'editorCommon.ts', + 'editorOptions.ts', + 'editorZoom.ts', + 'standaloneEditor.ts', + 'standaloneLanguages.ts', + // Generated + 'extensionsApiProposals.ts', + // Module passed around as type + 'pfs.ts', +]; +class DeclarationData { + fileName; + node; + replacementName; + constructor(fileName, node) { + this.fileName = fileName; + this.node = node; + this.replacementName = fileIdents.next(node.getSourceFile()); + } + get locations() { + return [{ + fileName: this.fileName, + offset: this.node.name.getStart() + }]; + } + shouldMangle(newName) { + // New name is longer the existing one :'( + if (newName.length >= this.node.name.getText().length) { + return false; + } + // Don't mangle functions we've explicitly opted out + if (this.node.getFullText().includes('@skipMangle')) { + return false; + } + // Don't mangle functions in the monaco editor API. + if (skippedFiles.some(file => this.node.getSourceFile().fileName.endsWith(file))) { + return false; + } + return true; + } +} +class ConstData { + fileName; + statement; + decl; + service; + replacementName; + constructor(fileName, statement, decl, service) { + this.fileName = fileName; + this.statement = statement; + this.decl = decl; + this.service = service; + this.replacementName = fileIdents.next(statement.getSourceFile()); + } + get locations() { + // If the const aliases any types, we need to rename those too + const definitionResult = this.service.getDefinitionAndBoundSpan(this.decl.getSourceFile().fileName, this.decl.name.getStart()); + if (definitionResult?.definitions && definitionResult.definitions.length > 1) { + return definitionResult.definitions.map(x => ({ fileName: x.fileName, offset: x.textSpan.start })); + } + return [{ fileName: this.fileName, offset: this.decl.name.getStart() }]; + } + shouldMangle(newName) { + // New name is longer the existing one :'( + if (newName.length >= this.decl.name.getText().length) { + return false; + } + // Don't mangle functions we've explicitly opted out + if (this.statement.getFullText().includes('@skipMangle')) { + return false; + } + // Don't mangle functions in some files + if (skippedFiles.some(file => this.decl.getSourceFile().fileName.endsWith(file))) { + return false; + } + return true; + } +} class StaticLanguageServiceHost { projectPath; _cmdLine; @@ -303,6 +400,7 @@ class Mangler { projectPath; log; allClassDataByKey = new Map(); + allExportedDeclarationsByKey = new Map(); service; constructor(projectPath, log = () => { }) { this.projectPath = projectPath; @@ -310,7 +408,7 @@ class Mangler { this.service = ts.createLanguageService(new StaticLanguageServiceHost(projectPath)); } computeNewFileContents(strictImplicitPublicHandling) { - // STEP: find all classes and their field info + // STEP find all classes and their field info. Find all exported consts and functions. const visit = (node) => { if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { const anchor = node.name ?? node; @@ -320,6 +418,39 @@ class Mangler { } this.allClassDataByKey.set(key, new ClassData(node.getSourceFile().fileName, node)); } + if (ts.isClassDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) { + if (node.name) { + const anchor = node.name; + const key = `${node.getSourceFile().fileName}|${anchor.getStart()}`; + if (this.allExportedDeclarationsByKey.has(key)) { + throw new Error('DUPE?'); + } + this.allExportedDeclarationsByKey.set(key, new DeclarationData(node.getSourceFile().fileName, node)); + } + } + if (ts.isFunctionDeclaration(node) + && ts.isSourceFile(node.parent) + && hasModifier(node, ts.SyntaxKind.ExportKeyword)) { + if (node.name && node.body) { // On named function and not on the overload + const anchor = node.name; + const key = `${node.getSourceFile().fileName}|${anchor.getStart()}`; + if (this.allExportedDeclarationsByKey.has(key)) { + throw new Error('DUPE?'); + } + this.allExportedDeclarationsByKey.set(key, new DeclarationData(node.getSourceFile().fileName, node)); + } + } + if (ts.isVariableStatement(node) + && ts.isSourceFile(node.parent) + && hasModifier(node, ts.SyntaxKind.ExportKeyword)) { + for (const decl of node.declarationList.declarations) { + const key = `${decl.getSourceFile().fileName}|${decl.name.getStart()}`; + if (this.allExportedDeclarationsByKey.has(key)) { + throw new Error('DUPE?'); + } + this.allExportedDeclarationsByKey.set(key, new ConstData(node.getSourceFile().fileName, node, decl, this.service)); + } + } ts.forEachChild(node, visit); }; for (const file of this.service.getProgram().getSourceFiles()) { @@ -327,7 +458,7 @@ class Mangler { ts.forEachChild(file, visit); } } - this.log(`Done collecting classes: ${this.allClassDataByKey.size}`); + this.log(`Done collecting. Classes: ${this.allClassDataByKey.size}. Exported const/fn: ${this.allExportedDeclarationsByKey.size}`); // STEP: connect sub and super-types const setupParents = (data) => { const extendsClause = data.node.heritageClauses?.find(h => h.token === ts.SyntaxKind.ExtendsKeyword); @@ -385,7 +516,7 @@ class Mangler { for (const data of this.allClassDataByKey.values()) { ClassData.fillInReplacement(data); } - this.log(`Done creating replacements`); + this.log(`Done creating class replacements`); const editsByFile = new Map(); const appendEdit = (fileName, edit) => { const edits = editsByFile.get(fileName); @@ -396,6 +527,13 @@ class Mangler { edits.push(edit); } }; + const appendRename = (newText, loc) => { + appendEdit(loc.fileName, { + newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), + offset: loc.textSpan.start, + length: loc.textSpan.length + }); + }; for (const data of this.allClassDataByKey.values()) { if (hasModifier(data.node, ts.SyntaxKind.DeclareKeyword)) { continue; @@ -416,11 +554,19 @@ class Mangler { const newText = data.lookupShortName(name); const locations = this.service.findRenameLocations(data.fileName, info.pos, false, false, true) ?? []; for (const loc of locations) { - appendEdit(loc.fileName, { - newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), - offset: loc.textSpan.start, - length: loc.textSpan.length - }); + appendRename(newText, loc); + } + } + } + for (const data of this.allExportedDeclarationsByKey.values()) { + if (!data.shouldMangle(data.replacementName)) { + continue; + } + const newText = data.replacementName; + for (const { fileName, offset } of data.locations) { + const locations = this.service.findRenameLocations(fileName, offset, false, false, true) ?? []; + for (const loc of locations) { + appendRename(newText, loc); } } } @@ -514,6 +660,7 @@ async function _run() { const projectPath = path.join(__dirname, '../../src/tsconfig.json'); const projectBase = path.dirname(projectPath); const newProjectBase = path.join(path.dirname(projectBase), path.basename(projectBase) + '2'); + fs.cpSync(projectBase, newProjectBase, { recursive: true }); for await (const [fileName, contents] of new Mangler(projectPath, console.log).computeNewFileContents(new Set(['saveState']))) { const newFilePath = path.join(newProjectBase, path.relative(projectBase, fileName)); await fs.promises.mkdir(path.dirname(newFilePath), { recursive: true }); @@ -526,4 +673,4 @@ async function _run() { if (__filename === process_1.argv[1]) { _run(); } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mangleTypeScript.js","sourceRoot":"","sources":["mangleTypeScript.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mangleTypeScript.js","sourceRoot":"","sources":["mangleTypeScript.ts"],"names":[],"mappings":";AAAA;;;gGAGgG;;;AAEhG,iCAAiC;AACjC,6BAA6B;AAC7B,yBAAyB;AACzB,qCAA+B;AAC/B,2CAAyD;AACzD,6BAAoC;AAEpC,MAAM,UAAU;IAEP,MAAM,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU;QAC9G,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI;QACnG,QAAQ,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO;QAC1G,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAE5D,MAAM,CAAC,SAAS,GAAG,kEAAkE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAEhG,MAAM,GAAG,CAAC,CAAC;IACF,YAAY,CAA4B;IACxC,MAAM,CAAS;IAEhC,YAAY,MAAc,EAAE,WAAsC;QACjE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;IACzG,CAAC;IAED,IAAI,CAAC,gBAA4C;QAChD,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,gBAAgB,EAAE,CAAC,SAAS,CAAC,EAAE;YAClE,YAAY;YACZ,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;SACnC;QACD,OAAO,SAAS,CAAC;IAClB,CAAC;IAEO,MAAM,CAAC,OAAO,CAAC,CAAS;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;QACnC,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,GAAG;YACF,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC;YACtB,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;SACnB,QAAQ,CAAC,GAAG,CAAC,EAAE;QAChB,OAAO,MAAM,CAAC;IACf,CAAC;;AAGF,IAAW,SAIV;AAJD,WAAW,SAAS;IACnB,6CAAM,CAAA;IACN,mDAAS,CAAA;IACT,+CAAO,CAAA;AACR,CAAC,EAJU,SAAS,KAAT,SAAS,QAInB;AAED,MAAM,SAAS;IAUJ;IACA;IATV,MAAM,GAAG,IAAI,GAAG,EAA4C,CAAC;IAErD,YAAY,CAAkC;IAEtD,MAAM,CAAwB;IAC9B,QAAQ,CAA0B;IAElC,YACU,QAAgB,EAChB,IAA8C;QAEvD,gFAAgF;QAChF,gFAAgF;QAJvE,aAAQ,GAAR,QAAQ,CAAQ;QAChB,SAAI,GAAJ,IAAI,CAA0C;QAKvD,MAAM,UAAU,GAA4B,EAAE,CAAC;QAC/C,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;YAClC,IAAI,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE;gBACnC,oBAAoB;gBACpB,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAExB;iBAAM,IAAI,EAAE,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE;gBAC5C,uBAAuB;gBACvB,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAExB;iBAAM,IAAI,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE;gBACpC,8BAA8B;gBAC9B,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAExB;iBAAM,IAAI,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE;gBACpC,8BAA8B;gBAC9B,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAExB;iBAAM,IAAI,EAAE,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE;gBAC/C,iDAAiD;gBACjD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,UAAU,EAAE;oBACtC,IAAI,WAAW,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;2BAChD,WAAW,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;2BAClD,WAAW,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;2BAC/C,WAAW,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EACnD;wBACD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;qBACvB;iBACD;aACD;SACD;QACD,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE;YAChC,MAAM,KAAK,GAAG,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAC/C,IAAI,CAAC,KAAK,EAAE;gBACX,SAAS;aACT;YACD,MAAM,IAAI,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC7C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,IAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;SAC/D;IACF,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,IAAyB;QACtD,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YACf,OAAO,SAAS,CAAC;SACjB;QACD,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;QACtB,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB,EAAE;YACrD,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,EAAE;gBACzD,+CAA+C;gBAC/C,OAAO;aACP;YACD,UAAU;YACV,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SAC/C;QAED,OAAO,KAAK,CAAC;IACd,CAAC;IAEO,MAAM,CAAC,aAAa,CAAC,IAAa;QACzC,IAAI,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;YACpD,iCAAyB;SACzB;aAAM,IAAI,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE;YAC7D,mCAA2B;SAC3B;aAAM;YACN,gCAAwB;SACxB;IACF,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,IAAe;QACnC,OAAO,IAAI,8BAAsB;eAC7B,IAAI,gCAAwB,CAC9B;IACH,CAAC;IAED,MAAM,CAAC,gCAAgC,CAAC,IAAe,EAAE,eAAkE;QAC1H,UAAU;QACV,iFAAiF;QACjF,iFAAiF;QACjF,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE;YACvC,IAAI,IAAI,CAAC,IAAI,6BAAqB,EAAE;gBACnC,SAAS;aACT;YACD,IAAI,MAAM,GAA0B,IAAI,CAAC,MAAM,CAAC;YAChD,OAAO,MAAM,EAAE;gBACd,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,gCAAwB,EAAE;oBAC1D,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,6BAA6B,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,GAAG,CAAC,CAAC;oBAC1G,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,6BAA6B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBAClF,eAAe,CAAC,IAAI,EAAE,IAAI,IAAI,UAAU,MAAM,CAAC,QAAQ,IAAI,SAAS,CAAC,IAAI,GAAG,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC,CAAC;oBAEzH,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,IAAI,2BAAmB,CAAC;iBACjD;gBACD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;aACvB;SACD;IACF,CAAC;IAED,MAAM,CAAC,iBAAiB,CAAC,IAAe;QAEvC,IAAI,IAAI,CAAC,YAAY,EAAE;YACtB,eAAe;YACf,OAAO;SACP;QAED,wBAAwB;QACxB,IAAI,IAAI,CAAC,MAAM,EAAE;YAChB,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACzC;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAAE,CAAC;QAE9B,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;YAE3C,gBAAgB;YAChB,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;gBAC5B,OAAO,IAAI,CAAC;aACZ;YAED,UAAU;YACV,IAAI,MAAM,GAA0B,IAAI,CAAC,MAAM,CAAC;YAChD,OAAO,MAAM,EAAE;gBACd,IAAI,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;oBAC9B,OAAO,IAAI,CAAC;iBACZ;gBACD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;aACvB;YAED,WAAW;YACX,IAAI,IAAI,CAAC,QAAQ,EAAE;gBAClB,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACjC,OAAO,KAAK,CAAC,MAAM,EAAE;oBACpB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;oBAC1B,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;wBAC5B,OAAO,IAAI,CAAC;qBACZ;oBACD,IAAI,IAAI,CAAC,QAAQ,EAAE;wBAClB,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;qBAC7B;iBACD;aACD;YAED,OAAO,KAAK,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE;YACvC,IAAI,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACvC,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;gBACnC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;aACvC;SACD;IACF,CAAC;IAED,kEAAkE;IAClE,kDAAkD;IAC1C,YAAY,CAAC,IAAY;QAChC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,IAAI,CAAC,EAAE;YACnF,eAAe;YACf,OAAO,IAAI,CAAC;SACZ;QACD,IAAI,IAAI,CAAC,YAAY,EAAE;YACtB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE;gBACnD,IAAI,SAAS,KAAK,IAAI,EAAE;oBACvB,6CAA6C;oBAC7C,OAAO,IAAI,CAAC;iBACZ;aACD;SACD;QAED,IAAI,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE;YACvC,OAAO,IAAI,CAAC;SACZ;QAED,OAAO,KAAK,CAAC;IACd,CAAC;IAED,eAAe,CAAC,IAAY;QAC3B,IAAI,KAAK,GAAG,IAAI,CAAC,YAAa,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;QAC1C,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,OAAO,MAAM,EAAE;YACd,IAAI,MAAM,CAAC,YAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,gCAAwB,EAAE;gBAC5F,KAAK,GAAG,MAAM,CAAC,YAAa,CAAC,GAAG,CAAC,IAAI,CAAE,IAAI,KAAK,CAAC;aACjD;YACD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;SACvB;QACD,OAAO,KAAK,CAAC;IACd,CAAC;IAED,sBAAsB;IAEtB,QAAQ,CAAC,KAAgB;QACxB,IAAI,CAAC,QAAQ,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC;CACD;AAED,SAAS,iBAAiB,CAAC,IAAa,EAAE,IAAY;IACrD,MAAM,WAAW,GAAS,IAAI,CAAC,aAAa,EAAG,CAAC,WAAW,CAAC;IAC5D,IAAI,WAAW,YAAY,GAAG,EAAE;QAC/B,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC;SACZ;KACD;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED,MAAM,UAAU,GAAG,IAAI;IACL,MAAM,GAAG,IAAI,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;IAE3D,IAAI,CAAC,IAAmB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,CAAC;CACD,CAAC;AAEF,MAAM,YAAY,GAAG;IACpB,QAAQ;IACR,cAAc;IACd,cAAc;IAEd,SAAS;IACT,iBAAiB;IACjB,kBAAkB;IAClB,eAAe;IACf,qBAAqB;IACrB,wBAAwB;IAExB,YAAY;IACZ,2BAA2B;IAE3B,+BAA+B;IAC/B,QAAQ;CACR,CAAC;AAEF,MAAM,eAAe;IAKV;IACA;IAJD,eAAe,CAAS;IAEjC,YACU,QAAgB,EAChB,IAAkD;QADlD,aAAQ,GAAR,QAAQ,CAAQ;QAChB,SAAI,GAAJ,IAAI,CAA8C;QAE3D,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,SAAS;QACZ,OAAO,CAAC;gBACP,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,IAAK,CAAC,QAAQ,EAAE;aAClC,CAAC,CAAC;IACJ,CAAC;IAED,YAAY,CAAC,OAAe;QAC3B,0CAA0C;QAC1C,IAAI,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,IAAK,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE;YACvD,OAAO,KAAK,CAAC;SACb;QAED,oDAAoD;QACpD,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACpD,OAAO,KAAK,CAAC;SACb;QAED,mDAAmD;QACnD,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE;YACjF,OAAO,KAAK,CAAC;SACb;QAED,OAAO,IAAI,CAAC;IACb,CAAC;CACD;AAED,MAAM,SAAS;IAKJ;IACA;IACA;IACQ;IANT,eAAe,CAAS;IAEjC,YACU,QAAgB,EAChB,SAA+B,EAC/B,IAA4B,EACpB,OAA2B;QAHnC,aAAQ,GAAR,QAAQ,CAAQ;QAChB,cAAS,GAAT,SAAS,CAAsB;QAC/B,SAAI,GAAJ,IAAI,CAAwB;QACpB,YAAO,GAAP,OAAO,CAAoB;QAE5C,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,SAAS;QACZ,8DAA8D;QAC9D,MAAM,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC/H,IAAI,gBAAgB,EAAE,WAAW,IAAI,gBAAgB,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7E,OAAO,gBAAgB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;SACnG;QAED,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,YAAY,CAAC,OAAe;QAC3B,0CAA0C;QAC1C,IAAI,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE;YACtD,OAAO,KAAK,CAAC;SACb;QAED,oDAAoD;QACpD,IAAI,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACzD,OAAO,KAAK,CAAC;SACb;QAED,uCAAuC;QACvC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE;YACjF,OAAO,KAAK,CAAC;SACb;QAED,OAAO,IAAI,CAAC;IACb,CAAC;CACD;AAED,MAAM,yBAAyB;IAKT;IAHJ,QAAQ,CAAuB;IAC/B,gBAAgB,GAAoC,IAAI,GAAG,EAAE,CAAC;IAE/E,YAAqB,WAAmB;QAAnB,gBAAW,GAAX,WAAW,CAAQ;QACvC,MAAM,eAAe,GAAgC,EAAE,CAAC;QACxD,MAAM,MAAM,GAAG,EAAE,CAAC,cAAc,CAAC,WAAW,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC/D,IAAI,MAAM,CAAC,KAAK,EAAE;YACjB,MAAM,MAAM,CAAC,KAAK,CAAC;SACnB;QACD,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,0BAA0B,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC,CAAC;QACjH,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACpC,MAAM,MAAM,CAAC,KAAK,CAAC;SACnB;IACF,CAAC;IACD,sBAAsB;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;IAC9B,CAAC;IACD,kBAAkB;QACjB,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;IAChC,CAAC;IACD,gBAAgB,CAAC,SAAiB;QACjC,OAAO,GAAG,CAAC;IACZ,CAAC;IACD,iBAAiB;QAChB,OAAO,GAAG,CAAC;IACZ,CAAC;IACD,iBAAiB,CAAC,QAAgB;QACjC,IAAI,MAAM,GAAmC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACjF,IAAI,MAAM,KAAK,SAAS,EAAE;YACzB,MAAM,OAAO,GAAG,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC1C,IAAI,OAAO,KAAK,SAAS,EAAE;gBAC1B,OAAO,SAAS,CAAC;aACjB;YACD,MAAM,GAAG,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAC/C,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;SAC5C;QACD,OAAO,MAAM,CAAC;IACf,CAAC;IACD,mBAAmB;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;IACD,qBAAqB,CAAC,OAA2B;QAChD,OAAO,EAAE,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IACD,eAAe,GAAG,EAAE,CAAC,GAAG,CAAC,eAAe,CAAC;IACzC,cAAc,GAAG,EAAE,CAAC,GAAG,CAAC,cAAc,CAAC;IACvC,UAAU,GAAG,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;IAC/B,QAAQ,GAAG,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC;IAC3B,aAAa,GAAG,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC;IACrC,oDAAoD;IACpD,QAAQ,GAAG,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC;CAC3B;AAOD;;;;;;;;GAQG;AACH,MAAa,OAAO;IAOE;IAA8B;IALlC,iBAAiB,GAAG,IAAI,GAAG,EAAqB,CAAC;IACjD,4BAA4B,GAAG,IAAI,GAAG,EAAuC,CAAC;IAE9E,OAAO,CAAqB;IAE7C,YAAqB,WAAmB,EAAW,MAA0B,GAAG,EAAE,GAAG,CAAC;QAAjE,gBAAW,GAAX,WAAW,CAAQ;QAAW,QAAG,GAAH,GAAG,CAAgC;QACrF,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,qBAAqB,CAAC,IAAI,yBAAyB,CAAC,WAAW,CAAC,CAAC,CAAC;IACrF,CAAC;IAED,sBAAsB,CAAC,4BAA0C;QAEhE,sFAAsF;QAEtF,MAAM,KAAK,GAAG,CAAC,IAAa,EAAQ,EAAE;YACrC,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE;gBAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;gBACjC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;gBACpE,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;oBACpC,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;iBACzB;gBACD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;aACpF;YAED,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;gBAClF,IAAI,IAAI,CAAC,IAAI,EAAE;oBACd,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC;oBACzB,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;oBACpE,IAAI,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;wBAC/C,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;qBACzB;oBACD,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,eAAe,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;iBACrG;aACD;YAED,IAAI,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC;mBAC9B,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC;mBAC5B,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAChD;gBACD,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,EAAE,4CAA4C;oBACzE,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC;oBACzB,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;oBACpE,IAAI,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;wBAC/C,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;qBACzB;oBACD,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,eAAe,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;iBACrG;aACD;YAED,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC;mBAC5B,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC;mBAC5B,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAChD;gBACD,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE;oBACrD,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;oBACvE,IAAI,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;wBAC/C,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;qBACzB;oBACD,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;iBACnH;aACD;YAED,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAG,CAAC,cAAc,EAAE,EAAE;YAC/D,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;gBAC5B,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;aAC7B;SACD;QACD,IAAI,CAAC,GAAG,CAAC,6BAA6B,IAAI,CAAC,iBAAiB,CAAC,IAAI,wBAAwB,IAAI,CAAC,4BAA4B,CAAC,IAAI,EAAE,CAAC,CAAC;QAGnI,qCAAqC;QAErC,MAAM,YAAY,GAAG,CAAC,IAAe,EAAE,EAAE;YACxC,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;YACrG,IAAI,CAAC,aAAa,EAAE;gBACnB,oBAAoB;gBACpB,OAAO;aACP;YAED,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;YAC7G,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC/B,2CAA2C;gBAC3C,OAAO;aACP;YAED,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;gBACtB,sCAAsC;gBACtC,OAAO;aACP;YAED,MAAM,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;YAC1B,MAAM,GAAG,GAAG,GAAG,UAAU,CAAC,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YAClE,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC/C,IAAI,CAAC,MAAM,EAAE;gBACZ,mDAAmD;gBACnD,OAAO;aACP;YACD,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC,CAAC;QACF,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE;YACnD,YAAY,CAAC,IAAI,CAAC,CAAC;SACnB;QAED,uEAAuE;QACvE,MAAM,UAAU,GAAG,IAAI,GAAG,EAAoB,CAAC;QAC/C,IAAI,sBAAsB,GAAG,KAAK,CAAC;QACnC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE;YACnD,SAAS,CAAC,gCAAgC,CAAC,IAAI,EAAE,CAAC,IAAY,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;gBAC5E,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACjC,IAAI,GAAG,EAAE;oBACR,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBACd;qBAAM;oBACN,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;iBAC5B;gBAED,IAAI,4BAA4B,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;oBAC5E,sBAAsB,GAAG,IAAI,CAAC;iBAC9B;YACF,CAAC,CAAC,CAAC;SACH;QACD,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,UAAU,EAAE;YACrC,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,8BAA8B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;SACvE;QACD,IAAI,sBAAsB,EAAE;YAC3B,MAAM,OAAO,GAAG,sIAAsI,CAAC;YACvJ,IAAI,CAAC,GAAG,CAAC,UAAU,OAAO,EAAE,CAAC,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;SACzB;QAED,iDAAiD;QACjD,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE;YACnD,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;SAClC;QACD,IAAI,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;QAI7C,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;QAE9C,MAAM,UAAU,GAAG,CAAC,QAAgB,EAAE,IAAU,EAAE,EAAE;YACnD,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACxC,IAAI,CAAC,KAAK,EAAE;gBACX,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;aAClC;iBAAM;gBACN,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACjB;QACF,CAAC,CAAC;QACF,MAAM,YAAY,GAAG,CAAC,OAAe,EAAE,GAAsB,EAAE,EAAE;YAChE,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE;gBACxB,OAAO,EAAE,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC,GAAG,OAAO,GAAG,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;gBAClE,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,KAAK;gBAC1B,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM;aAC3B,CAAC,CAAC;QACJ,CAAC,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE;YAEnD,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;gBACzD,SAAS;aACT;YAED,MAAM,EAAE,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE;gBAC/C,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;oBACxC,SAAS,MAAM,CAAC;iBAChB;gBAED,oDAAoD;gBACpD,uDAAuD;gBACvD,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;gBACzB,OAAO,MAAM,EAAE;oBACd,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,6BAAqB,EAAE;wBACvD,SAAS,MAAM,CAAC;qBAChB;oBACD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;iBACvB;gBAED,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;gBAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;gBACtG,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE;oBAC5B,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;iBAC3B;aACD;SACD;QAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,4BAA4B,CAAC,MAAM,EAAE,EAAE;YAC9D,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE;gBAC7C,SAAS;aACT;YAED,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC;YACrC,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC/F,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE;oBAC5B,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;iBAC3B;aACD;SACD;QAED,IAAI,CAAC,GAAG,CAAC,yBAAyB,WAAW,CAAC,IAAI,QAAQ,CAAC,CAAC;QAE5D,0CAA0C;QAC1C,MAAM,MAAM,GAAG,IAAI,GAAG,EAAwB,CAAC;QAC/C,IAAI,UAAU,GAAG,CAAC,CAAC;QAEnB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAG,CAAC,cAAc,EAAE,EAAE;YAE/D,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAG,CAAC,kBAAkB,EAAE,CAAC;YAChF,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAClD,MAAM,aAAa,GAAG,OAAO,IAAI,IAAA,mBAAa,EAAC,UAAU,IAAI,UAAU,CAAC,CAAC,QAAQ,EAAE,CAAC;YAEpF,cAAc;YACd,IAAI,SAAyC,CAAC;YAE9C,IAAI,WAAmB,CAAC;YACxB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7C,IAAI,CAAC,KAAK,EAAE;gBACX,YAAY;gBACZ,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;aAEjC;iBAAM;gBACN,uBAAuB;gBACvB,MAAM,gBAAgB,GAAG,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC7E,MAAM,cAAc,GAAG,IAAI,GAAG,EAAqB,CAAC;gBAEpD,gBAAgB;gBAChB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;gBAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAEhD,IAAI,QAA0B,CAAC;gBAE/B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;oBACzB,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,EAAE;wBAChD,EAAE;wBACF,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,EAAE;4BACzE,IAAI,CAAC,GAAG,CAAC,yBAAyB,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;4BACvE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;yBACpC;6BAAM;4BACN,SAAS;yBACT;qBACD;oBACD,QAAQ,GAAG,IAAI,CAAC;oBAChB,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBACvF,UAAU,IAAI,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;oBAEvD,cAAc;oBACd,MAAM,GAAG,GAAG,IAAI,CAAC,6BAA6B,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAG5D,IAAI,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBAC5C,IAAI,CAAC,QAAQ,EAAE;wBACd,QAAQ,GAAG,EAAE,CAAC;wBACd,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;qBACvC;oBACD,QAAQ,CAAC,OAAO,CAAC;wBAChB,MAAM,EAAE,gBAAgB;wBACxB,QAAQ,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,SAAS,EAAE;wBACvD,SAAS,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,SAAS,EAAE;wBACxD,IAAI,EAAE,WAAW;qBACjB,EAAE;wBACF,MAAM,EAAE,gBAAgB;wBACxB,QAAQ,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,EAAE;wBACrE,SAAS,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;qBAC9E,CAAC,CAAC;iBACH;gBAED,oEAAoE;gBACpE,SAAS,GAAG,IAAI,+BAAkB,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAC;gBACtG,SAAS,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;gBACjE,KAAK,MAAM,CAAC,EAAE,QAAQ,CAAC,IAAI,cAAc,EAAE;oBAC1C,IAAI,SAAS,GAAG,CAAC,CAAC;oBAClB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;wBAC/B,SAAS,CAAC,UAAU,CAAC;4BACpB,GAAG,OAAO;4BACV,SAAS,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,SAAS,EAAE;yBACzF,CAAC,CAAC;wBACH,SAAS,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC;qBAChE;iBACD;gBAED,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aAClC;YACD,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;SAClF;QAED,IAAI,CAAC,GAAG,CAAC,SAAS,UAAU,GAAG,IAAI,UAAU,CAAC,CAAC;QAC/C,OAAO,MAAM,CAAC;IACf,CAAC;CACD;AAnSD,0BAmSC;AAED,gBAAgB;AAEhB,SAAS,WAAW,CAAC,IAAa,EAAE,IAAmB;IACtD,MAAM,SAAS,GAAG,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAChF,OAAO,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;AAC7D,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AACjC,CAAC;AAED,KAAK,UAAU,IAAI;IAElB,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,yBAAyB,CAAC,CAAC;IACpE,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC9C,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC,CAAC;IAE9F,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE5D,IAAI,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,sBAAsB,CAAC,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE;QAC9H,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;QACpF,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxE,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACvD,IAAI,QAAQ,CAAC,SAAS,EAAE;YACvB,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,WAAW,GAAG,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;SACtE;KACD;AACF,CAAC;AAED,IAAI,UAAU,KAAK,cAAI,CAAC,CAAC,CAAC,EAAE;IAC3B,IAAI,EAAE,CAAC;CACP"} \ No newline at end of file diff --git a/build/package.json b/build/package.json index 44eec832d64..df7b7799a24 100644 --- a/build/package.json +++ b/build/package.json @@ -38,6 +38,7 @@ "@types/through2": "^2.0.36", "@types/tmp": "^0.2.1", "@types/underscore": "^1.8.9", + "@types/workerpool": "^6.4.0", "@types/xml2js": "0.0.33", "@vscode/iconv-lite-umd": "0.7.0", "@vscode/vsce": "^2.16.0", @@ -70,5 +71,8 @@ "tree-sitter": "https://github.com/joaomoreno/node-tree-sitter/releases/download/v0.20.0/tree-sitter-0.20.0.tgz", "tree-sitter-typescript": "^0.20.1", "vscode-gulp-watch": "^5.0.3" + }, + "dependencies": { + "workerpool": "^6.4.0" } } diff --git a/build/yarn.lock b/build/yarn.lock index 8aa0f5f21cf..c29bf14c70a 100644 --- a/build/yarn.lock +++ b/build/yarn.lock @@ -646,6 +646,13 @@ dependencies: "@types/node" "*" +"@types/workerpool@^6.4.0": + version "6.4.0" + resolved "https://registry.yarnpkg.com/@types/workerpool/-/workerpool-6.4.0.tgz#c79292915dd08350d10e78e74687b6f401f270b8" + integrity sha512-SIF2/169pDsLKeM8GQGHkOFifGalDbZgiBSaLUnnlVSRsAOenkAvQ6h4uhV2W+PZZczS+8LQxACwNkSykdT91A== + dependencies: + "@types/node" "*" + "@types/xml2js@0.0.33": version "0.0.33" resolved "https://registry.yarnpkg.com/@types/xml2js/-/xml2js-0.0.33.tgz#20c5dd6460245284d64a55690015b95e409fb7de" @@ -3017,6 +3024,11 @@ wide-align@^1.1.0: dependencies: string-width "^1.0.2 || 2 || 3 || 4" +workerpool@^6.4.0: + version "6.4.0" + resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.4.0.tgz#f8d5cfb45fde32fa3b7af72ad617c3369567a462" + integrity sha512-i3KR1mQMNwY2wx20ozq2EjISGtQWDIfV56We+yGJ5yDs8jTwQiLLaqHlkBHITlCuJnYlVRmXegxFxZg7gqI++A== + wrappy@1: version "1.0.2" resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" diff --git a/extensions/mangle-loader.js b/extensions/mangle-loader.js index fa4fb1e36fc..46877444525 100644 --- a/extensions/mangle-loader.js +++ b/extensions/mangle-loader.js @@ -8,12 +8,12 @@ const fs = require('fs'); const webpack = require('webpack'); const fancyLog = require('fancy-log'); const ansiColors = require('ansi-colors'); -const { Mangler } = require('../build/lib/mangleTypeScript'); +const { Mangler } = require('../build/lib/mangle/index'); /** * Map of project paths to mangled file contents * - * @type {Map>} + * @type {Map>>} */ const mangleMap = new Map(); @@ -55,7 +55,7 @@ module.exports = async function (source, sourceMap, meta) { const callback = this.async(); - const fileContentsMap = getMangledFileContents(options.configFile); + const fileContentsMap = await getMangledFileContents(options.configFile); const newContents = fileContentsMap.get(this.resourcePath); callback(null, newContents?.out ?? source, sourceMap, meta); diff --git a/src/vs/base/common/errors.ts b/src/vs/base/common/errors.ts index 63f5a2f8c51..a558a0b06d8 100644 --- a/src/vs/base/common/errors.ts +++ b/src/vs/base/common/errors.ts @@ -74,6 +74,7 @@ export class ErrorHandler { export const errorHandler = new ErrorHandler(); +/** @skipMangle */ export function setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void { errorHandler.setUnexpectedErrorHandler(newUnexpectedErrorHandler); } diff --git a/src/vs/base/common/process.ts b/src/vs/base/common/process.ts index cfa3c1c5a41..a50f849b5af 100644 --- a/src/vs/base/common/process.ts +++ b/src/vs/base/common/process.ts @@ -48,6 +48,8 @@ else { * environments. * * Note: in web, this property is hardcoded to be `/`. + * + * @skipMangle */ export const cwd = safeProcess.cwd; diff --git a/src/vs/base/common/stripComments.d.ts b/src/vs/base/common/stripComments.d.ts index 69e662e9759..af5b182b5bf 100644 --- a/src/vs/base/common/stripComments.d.ts +++ b/src/vs/base/common/stripComments.d.ts @@ -10,5 +10,5 @@ * supported in JSON. * @param content the content to strip comments from * @returns the content without comments - */ +*/ export function stripComments(content: string): string; diff --git a/src/vs/base/common/worker/simpleWorker.ts b/src/vs/base/common/worker/simpleWorker.ts index deefcb96396..924dbf3ad7d 100644 --- a/src/vs/base/common/worker/simpleWorker.ts +++ b/src/vs/base/common/worker/simpleWorker.ts @@ -558,6 +558,7 @@ export class SimpleWorkerServer { /** * Called on the worker side + * @skipMangle */ export function create(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void): SimpleWorkerServer { return new SimpleWorkerServer(postMessage, null); diff --git a/src/vs/css.ts b/src/vs/css.ts index 4a5ea48d174..5337b4f2136 100644 --- a/src/vs/css.ts +++ b/src/vs/css.ts @@ -9,6 +9,8 @@ interface ICSSPluginConfig { /** * Invoked by the loader at run-time + * + * @skipMangle */ export function load(name: string, req: AMDLoader.IRelativeRequire, load: AMDLoader.IPluginLoadCallback, config: AMDLoader.IConfigurationOptions): void { config = config || {}; diff --git a/src/vs/editor/browser/controller/textAreaHandler.ts b/src/vs/editor/browser/controller/textAreaHandler.ts index 8c7a15121e9..0d5c3317051 100644 --- a/src/vs/editor/browser/controller/textAreaHandler.ts +++ b/src/vs/editor/browser/controller/textAreaHandler.ts @@ -297,7 +297,12 @@ export class TextAreaHandler extends ViewPart { }; const textAreaWrapper = this._register(new TextAreaWrapper(this.textArea.domNode)); - this._textAreaInput = this._register(new TextAreaInput(textAreaInputHost, textAreaWrapper, platform.OS, browser)); + this._textAreaInput = this._register(new TextAreaInput(textAreaInputHost, textAreaWrapper, platform.OS, { + isAndroid: browser.isAndroid, + isChrome: browser.isChrome, + isFirefox: browser.isFirefox, + isSafari: browser.isSafari, + })); this._register(this._textAreaInput.onKeyDown((e: IKeyboardEvent) => { this._viewController.emitKeyDown(e); diff --git a/src/vs/editor/test/browser/controller/imeTester.ts b/src/vs/editor/test/browser/controller/imeTester.ts index bf85dd9c5bf..b44da204b52 100644 --- a/src/vs/editor/test/browser/controller/imeTester.ts +++ b/src/vs/editor/test/browser/controller/imeTester.ts @@ -121,7 +121,12 @@ function doCreateTest(description: string, inputStr: string, expectedStr: string } }; - const handler = new TextAreaInput(textAreaInputHost, new TextAreaWrapper(input), platform.OS, browser); + const handler = new TextAreaInput(textAreaInputHost, new TextAreaWrapper(input), platform.OS, { + isAndroid: browser.isAndroid, + isFirefox: browser.isFirefox, + isChrome: browser.isChrome, + isSafari: browser.isSafari, + }); const output = document.createElement('pre'); output.className = 'output'; diff --git a/src/vs/nls.ts b/src/vs/nls.ts index 7ec0e246f8f..db57b98d67b 100644 --- a/src/vs/nls.ts +++ b/src/vs/nls.ts @@ -123,6 +123,9 @@ export function localize(info: ILocalizeInfo, message: string, ...args: (string */ export function localize(key: string, message: string, ...args: (string | number | boolean | undefined | null)[]): string; +/** + * @skipMangle + */ export function localize(data: ILocalizeInfo | string, message: string, ...args: (string | number | boolean | undefined | null)[]): string { return _format(message, args); } @@ -133,18 +136,25 @@ export function localize(data: ILocalizeInfo | string, message: string, ...args: * in order to ensure the loader plugin has been initialized before this function is called. */ export function getConfiguredDefaultLocale(stringFromLocalizeCall: string): string | undefined; +/** + * @skipMangle + */ export function getConfiguredDefaultLocale(_: string): string | undefined { // This returns undefined because this implementation isn't used and is overwritten by the loader // when loaded. return undefined; } +/** + * @skipMangle + */ export function setPseudoTranslation(value: boolean) { isPseudo = value; } /** * Invoked in a built product at run-time + * @skipMangle */ export function create(key: string, data: IBundledStrings & IConsumerAPI): IConsumerAPI { return { @@ -155,10 +165,12 @@ export function create(key: string, data: IBundledStrings & IConsumerAPI): ICons /** * Invoked by the loader at run-time + * @skipMangle */ export function load(name: string, req: AMDLoader.IRelativeRequire, load: AMDLoader.IPluginLoadCallback, config: AMDLoader.IConfigurationOptions): void { const pluginConfig: INLSPluginConfig = config['vs/nls'] ?? {}; if (!name || name.length === 0) { + // TODO: We need to give back the mangled names here return load({ localize: localize, getConfiguredDefaultLocale: () => pluginConfig.availableLanguages?.['*'] diff --git a/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.ts b/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.ts index 0d1ac1c4a65..14d6a473c09 100644 --- a/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.ts +++ b/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.ts @@ -11,7 +11,6 @@ import { IV8Profile, Utils } from 'vs/platform/profiling/common/profiling'; import { IProfileModel, BottomUpSample, buildModel, BottomUpNode, processNode, CdpCallFrame } from 'vs/platform/profiling/common/profilingModel'; import { BottomUpAnalysis, IProfileAnalysisWorker, ProfilingOutput } from 'vs/platform/profiling/electron-sandbox/profileAnalysisWorkerService'; - export function create(): IRequestHandler { return new ProfileAnalysisWorker(); } diff --git a/src/vs/workbench/test/common/utils.ts b/src/vs/workbench/test/common/utils.ts index c343653722c..498c5c499fe 100644 --- a/src/vs/workbench/test/common/utils.ts +++ b/src/vs/workbench/test/common/utils.ts @@ -12,6 +12,8 @@ import { LanguagesRegistry } from 'vs/editor/common/services/languagesRegistry'; * and can be used to add assertions. e.g. that registries are empty, etc. * * !! This is called directly by the testing framework. + * + * @skipMangle */ export function assertCleanState(): void { // If this test fails, it is a clear indication that