@wix/cli
Version:
CLI tool for building Wix sites and applications
1,058 lines (1,055 loc) • 9.92 MB
JavaScript
import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
require_source_map
} from "./chunk-TQF2C25T.js";
import {
__commonJS,
__dirname,
__filename,
__require,
init_esm_shims
} from "./chunk-EXLZF52D.js";
// ../../node_modules/buffer-from/index.js
var require_buffer_from = __commonJS({
"../../node_modules/buffer-from/index.js"(exports, module) {
"use strict";
init_esm_shims();
var toString = Object.prototype.toString;
var isModern = typeof Buffer !== "undefined" && typeof Buffer.alloc === "function" && typeof Buffer.allocUnsafe === "function" && typeof Buffer.from === "function";
function isArrayBuffer(input) {
return toString.call(input).slice(8, -1) === "ArrayBuffer";
}
function fromArrayBuffer(obj, byteOffset, length) {
byteOffset >>>= 0;
var maxLength = obj.byteLength - byteOffset;
if (maxLength < 0) {
throw new RangeError("'offset' is out of bounds");
}
if (length === void 0) {
length = maxLength;
} else {
length >>>= 0;
if (length > maxLength) {
throw new RangeError("'length' is out of bounds");
}
}
return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
}
function fromString(string, encoding) {
if (typeof encoding !== "string" || encoding === "") {
encoding = "utf8";
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('"encoding" must be a valid string encoding');
}
return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
}
function bufferFrom(value, encodingOrOffset, length) {
if (typeof value === "number") {
throw new TypeError('"value" argument must not be a number');
}
if (isArrayBuffer(value)) {
return fromArrayBuffer(value, encodingOrOffset, length);
}
if (typeof value === "string") {
return fromString(value, encodingOrOffset);
}
return isModern ? Buffer.from(value) : new Buffer(value);
}
module.exports = bufferFrom;
}
});
// ../../node_modules/source-map-support/source-map-support.js
var require_source_map_support = __commonJS({
"../../node_modules/source-map-support/source-map-support.js"(exports) {
"use strict";
init_esm_shims();
var SourceMapConsumer = require_source_map().SourceMapConsumer;
var path = __require("path");
var fs;
try {
fs = __require("fs");
if (!fs.existsSync || !fs.readFileSync) {
fs = null;
}
} catch (err) {
}
var bufferFrom = require_buffer_from();
var errorFormatterInstalled = false;
var uncaughtShimInstalled = false;
var emptyCacheBetweenOperations = false;
var environment = "auto";
var fileContentsCache = {};
var sourceMapCache = {};
var reSourceMap = /^data:application\/json[^,]+base64,/;
var retrieveFileHandlers = [];
var retrieveMapHandlers = [];
function isInBrowser() {
if (environment === "browser")
return true;
if (environment === "node")
return false;
return typeof window !== "undefined" && typeof XMLHttpRequest === "function" && !(window.require && window.module && window.process && window.process.type === "renderer");
}
function hasGlobalProcessEventEmitter() {
return typeof process === "object" && process !== null && typeof process.on === "function";
}
function handlerExec(list) {
return function(arg) {
for (var i = 0; i < list.length; i++) {
var ret = list[i](arg);
if (ret) {
return ret;
}
}
return null;
};
}
var retrieveFile = handlerExec(retrieveFileHandlers);
retrieveFileHandlers.push(function(path2) {
path2 = path2.trim();
if (/^file:/.test(path2)) {
path2 = path2.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
return drive ? "" : (
// file:///C:/dir/file -> C:/dir/file
"/"
);
});
}
if (path2 in fileContentsCache) {
return fileContentsCache[path2];
}
var contents = "";
try {
if (!fs) {
var xhr = new XMLHttpRequest();
xhr.open(
"GET",
path2,
/** async */
false
);
xhr.send(null);
if (xhr.readyState === 4 && xhr.status === 200) {
contents = xhr.responseText;
}
} else if (fs.existsSync(path2)) {
contents = fs.readFileSync(path2, "utf8");
}
} catch (er) {
}
return fileContentsCache[path2] = contents;
});
function supportRelativeURL(file, url) {
if (!file) return url;
var dir = path.dirname(file);
var match = /^\w+:\/\/[^\/]*/.exec(dir);
var protocol = match ? match[0] : "";
var startPath = dir.slice(protocol.length);
if (protocol && /^\/\w\:/.test(startPath)) {
protocol += "/";
return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
}
return protocol + path.resolve(dir.slice(protocol.length), url);
}
function retrieveSourceMapURL(source) {
var fileData;
if (isInBrowser()) {
try {
var xhr = new XMLHttpRequest();
xhr.open("GET", source, false);
xhr.send(null);
fileData = xhr.readyState === 4 ? xhr.responseText : null;
var sourceMapHeader = xhr.getResponseHeader("SourceMap") || xhr.getResponseHeader("X-SourceMap");
if (sourceMapHeader) {
return sourceMapHeader;
}
} catch (e) {
}
}
fileData = retrieveFile(source);
var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
var lastMatch, match;
while (match = re.exec(fileData)) lastMatch = match;
if (!lastMatch) return null;
return lastMatch[1];
}
var retrieveSourceMap = handlerExec(retrieveMapHandlers);
retrieveMapHandlers.push(function(source) {
var sourceMappingURL = retrieveSourceMapURL(source);
if (!sourceMappingURL) return null;
var sourceMapData;
if (reSourceMap.test(sourceMappingURL)) {
var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
sourceMapData = bufferFrom(rawData, "base64").toString();
sourceMappingURL = source;
} else {
sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
sourceMapData = retrieveFile(sourceMappingURL);
}
if (!sourceMapData) {
return null;
}
return {
url: sourceMappingURL,
map: sourceMapData
};
});
function mapSourcePosition(position) {
var sourceMap = sourceMapCache[position.source];
if (!sourceMap) {
var urlAndMap = retrieveSourceMap(position.source);
if (urlAndMap) {
sourceMap = sourceMapCache[position.source] = {
url: urlAndMap.url,
map: new SourceMapConsumer(urlAndMap.map)
};
if (sourceMap.map.sourcesContent) {
sourceMap.map.sources.forEach(function(source, i) {
var contents = sourceMap.map.sourcesContent[i];
if (contents) {
var url = supportRelativeURL(sourceMap.url, source);
fileContentsCache[url] = contents;
}
});
}
} else {
sourceMap = sourceMapCache[position.source] = {
url: null,
map: null
};
}
}
if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === "function") {
var originalPosition = sourceMap.map.originalPositionFor(position);
if (originalPosition.source !== null) {
originalPosition.source = supportRelativeURL(
sourceMap.url,
originalPosition.source
);
return originalPosition;
}
}
return position;
}
function mapEvalOrigin(origin) {
var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
if (match) {
var position = mapSourcePosition({
source: match[2],
line: +match[3],
column: match[4] - 1
});
return "eval at " + match[1] + " (" + position.source + ":" + position.line + ":" + (position.column + 1) + ")";
}
match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
if (match) {
return "eval at " + match[1] + " (" + mapEvalOrigin(match[2]) + ")";
}
return origin;
}
function CallSiteToString() {
var fileName;
var fileLocation = "";
if (this.isNative()) {
fileLocation = "native";
} else {
fileName = this.getScriptNameOrSourceURL();
if (!fileName && this.isEval()) {
fileLocation = this.getEvalOrigin();
fileLocation += ", ";
}
if (fileName) {
fileLocation += fileName;
} else {
fileLocation += "<anonymous>";
}
var lineNumber = this.getLineNumber();
if (lineNumber != null) {
fileLocation += ":" + lineNumber;
var columnNumber = this.getColumnNumber();
if (columnNumber) {
fileLocation += ":" + columnNumber;
}
}
}
var line = "";
var functionName = this.getFunctionName();
var addSuffix = true;
var isConstructor = this.isConstructor();
var isMethodCall = !(this.isToplevel() || isConstructor);
if (isMethodCall) {
var typeName = this.getTypeName();
if (typeName === "[object Object]") {
typeName = "null";
}
var methodName = this.getMethodName();
if (functionName) {
if (typeName && functionName.indexOf(typeName) != 0) {
line += typeName + ".";
}
line += functionName;
if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
line += " [as " + methodName + "]";
}
} else {
line += typeName + "." + (methodName || "<anonymous>");
}
} else if (isConstructor) {
line += "new " + (functionName || "<anonymous>");
} else if (functionName) {
line += functionName;
} else {
line += fileLocation;
addSuffix = false;
}
if (addSuffix) {
line += " (" + fileLocation + ")";
}
return line;
}
function cloneCallSite(frame) {
var object = {};
Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
object[name] = /^(?:is|get)/.test(name) ? function() {
return frame[name].call(frame);
} : frame[name];
});
object.toString = CallSiteToString;
return object;
}
function wrapCallSite(frame) {
if (frame.isNative()) {
return frame;
}
var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
if (source) {
var line = frame.getLineNumber();
var column = frame.getColumnNumber() - 1;
var headerLength = 62;
if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
column -= headerLength;
}
var position = mapSourcePosition({
source,
line,
column
});
frame = cloneCallSite(frame);
var originalFunctionName = frame.getFunctionName;
frame.getFunctionName = function() {
return position.name || originalFunctionName();
};
frame.getFileName = function() {
return position.source;
};
frame.getLineNumber = function() {
return position.line;
};
frame.getColumnNumber = function() {
return position.column + 1;
};
frame.getScriptNameOrSourceURL = function() {
return position.source;
};
return frame;
}
var origin = frame.isEval() && frame.getEvalOrigin();
if (origin) {
origin = mapEvalOrigin(origin);
frame = cloneCallSite(frame);
frame.getEvalOrigin = function() {
return origin;
};
return frame;
}
return frame;
}
function prepareStackTrace(error, stack) {
if (emptyCacheBetweenOperations) {
fileContentsCache = {};
sourceMapCache = {};
}
var name = error.name || "Error";
var message = error.message || "";
var errorString = name + ": " + message;
return errorString + stack.map(function(frame) {
return "\n at " + wrapCallSite(frame);
}).join("");
}
function getErrorSource(error) {
var match = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
if (match) {
var source = match[1];
var line = +match[2];
var column = +match[3];
var contents = fileContentsCache[source];
if (!contents && fs && fs.existsSync(source)) {
try {
contents = fs.readFileSync(source, "utf8");
} catch (er) {
contents = "";
}
}
if (contents) {
var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
if (code) {
return source + ":" + line + "\n" + code + "\n" + new Array(column).join(" ") + "^";
}
}
}
return null;
}
function printErrorAndExit(error) {
var source = getErrorSource(error);
if (process.stderr._handle && process.stderr._handle.setBlocking) {
process.stderr._handle.setBlocking(true);
}
if (source) {
console.error();
console.error(source);
}
console.error(error.stack);
process.exit(1);
}
function shimEmitUncaughtException() {
var origEmit = process.emit;
process.emit = function(type) {
if (type === "uncaughtException") {
var hasStack = arguments[1] && arguments[1].stack;
var hasListeners = this.listeners(type).length > 0;
if (hasStack && !hasListeners) {
return printErrorAndExit(arguments[1]);
}
}
return origEmit.apply(this, arguments);
};
}
var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
exports.wrapCallSite = wrapCallSite;
exports.getErrorSource = getErrorSource;
exports.mapSourcePosition = mapSourcePosition;
exports.retrieveSourceMap = retrieveSourceMap;
exports.install = function(options) {
options = options || {};
if (options.environment) {
environment = options.environment;
if (["node", "browser", "auto"].indexOf(environment) === -1) {
throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}");
}
}
if (options.retrieveFile) {
if (options.overrideRetrieveFile) {
retrieveFileHandlers.length = 0;
}
retrieveFileHandlers.unshift(options.retrieveFile);
}
if (options.retrieveSourceMap) {
if (options.overrideRetrieveSourceMap) {
retrieveMapHandlers.length = 0;
}
retrieveMapHandlers.unshift(options.retrieveSourceMap);
}
if (options.hookRequire && !isInBrowser()) {
var Module;
try {
Module = __require("module");
} catch (err) {
}
var $compile = Module.prototype._compile;
if (!$compile.__sourceMapSupport) {
Module.prototype._compile = function(content, filename) {
fileContentsCache[filename] = content;
sourceMapCache[filename] = void 0;
return $compile.call(this, content, filename);
};
Module.prototype._compile.__sourceMapSupport = true;
}
}
if (!emptyCacheBetweenOperations) {
emptyCacheBetweenOperations = "emptyCacheBetweenOperations" in options ? options.emptyCacheBetweenOperations : false;
}
if (!errorFormatterInstalled) {
errorFormatterInstalled = true;
Error.prepareStackTrace = prepareStackTrace;
}
if (!uncaughtShimInstalled) {
var installHandler = "handleUncaughtExceptions" in options ? options.handleUncaughtExceptions : true;
if (installHandler && hasGlobalProcessEventEmitter()) {
uncaughtShimInstalled = true;
shimEmitUncaughtException();
}
}
};
exports.resetRetrieveHandlers = function() {
retrieveFileHandlers.length = 0;
retrieveMapHandlers.length = 0;
retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
retrieveSourceMap = handlerExec(retrieveMapHandlers);
retrieveFile = handlerExec(retrieveFileHandlers);
};
}
});
// ../../node_modules/typescript/lib/typescript.js
var require_typescript = __commonJS({
"../../node_modules/typescript/lib/typescript.js"(exports, module) {
init_esm_shims();
var ts = {};
((module2) => {
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => (__copyProps, mod);
var typescript_exports = {};
__export(typescript_exports, {
ANONYMOUS: () => ANONYMOUS,
AccessFlags: () => AccessFlags,
AssertionLevel: () => AssertionLevel,
AssignmentDeclarationKind: () => AssignmentDeclarationKind,
AssignmentKind: () => AssignmentKind,
Associativity: () => Associativity,
BreakpointResolver: () => ts_BreakpointResolver_exports,
BuilderFileEmit: () => BuilderFileEmit,
BuilderProgramKind: () => BuilderProgramKind,
BuilderState: () => BuilderState,
CallHierarchy: () => ts_CallHierarchy_exports,
CharacterCodes: () => CharacterCodes,
CheckFlags: () => CheckFlags,
CheckMode: () => CheckMode,
ClassificationType: () => ClassificationType,
ClassificationTypeNames: () => ClassificationTypeNames,
CommentDirectiveType: () => CommentDirectiveType,
Comparison: () => Comparison,
CompletionInfoFlags: () => CompletionInfoFlags,
CompletionTriggerKind: () => CompletionTriggerKind,
Completions: () => ts_Completions_exports,
ContainerFlags: () => ContainerFlags,
ContextFlags: () => ContextFlags,
Debug: () => Debug,
DiagnosticCategory: () => DiagnosticCategory,
Diagnostics: () => Diagnostics,
DocumentHighlights: () => DocumentHighlights,
ElementFlags: () => ElementFlags,
EmitFlags: () => EmitFlags,
EmitHint: () => EmitHint,
EmitOnly: () => EmitOnly,
EndOfLineState: () => EndOfLineState,
ExitStatus: () => ExitStatus,
ExportKind: () => ExportKind,
Extension: () => Extension,
ExternalEmitHelpers: () => ExternalEmitHelpers,
FileIncludeKind: () => FileIncludeKind,
FilePreprocessingDiagnosticsKind: () => FilePreprocessingDiagnosticsKind,
FileSystemEntryKind: () => FileSystemEntryKind,
FileWatcherEventKind: () => FileWatcherEventKind,
FindAllReferences: () => ts_FindAllReferences_exports,
FlattenLevel: () => FlattenLevel,
FlowFlags: () => FlowFlags,
ForegroundColorEscapeSequences: () => ForegroundColorEscapeSequences,
FunctionFlags: () => FunctionFlags,
GeneratedIdentifierFlags: () => GeneratedIdentifierFlags,
GetLiteralTextFlags: () => GetLiteralTextFlags,
GoToDefinition: () => ts_GoToDefinition_exports,
HighlightSpanKind: () => HighlightSpanKind,
IdentifierNameMap: () => IdentifierNameMap,
ImportKind: () => ImportKind,
ImportsNotUsedAsValues: () => ImportsNotUsedAsValues,
IndentStyle: () => IndentStyle,
IndexFlags: () => IndexFlags,
IndexKind: () => IndexKind,
InferenceFlags: () => InferenceFlags,
InferencePriority: () => InferencePriority,
InlayHintKind: () => InlayHintKind2,
InlayHints: () => ts_InlayHints_exports,
InternalEmitFlags: () => InternalEmitFlags,
InternalNodeBuilderFlags: () => InternalNodeBuilderFlags,
InternalSymbolName: () => InternalSymbolName,
IntersectionFlags: () => IntersectionFlags,
InvalidatedProjectKind: () => InvalidatedProjectKind,
JSDocParsingMode: () => JSDocParsingMode,
JsDoc: () => ts_JsDoc_exports,
JsTyping: () => ts_JsTyping_exports,
JsxEmit: () => JsxEmit,
JsxFlags: () => JsxFlags,
JsxReferenceKind: () => JsxReferenceKind,
LanguageFeatureMinimumTarget: () => LanguageFeatureMinimumTarget,
LanguageServiceMode: () => LanguageServiceMode,
LanguageVariant: () => LanguageVariant,
LexicalEnvironmentFlags: () => LexicalEnvironmentFlags,
ListFormat: () => ListFormat,
LogLevel: () => LogLevel,
MapCode: () => ts_MapCode_exports,
MemberOverrideStatus: () => MemberOverrideStatus,
ModifierFlags: () => ModifierFlags,
ModuleDetectionKind: () => ModuleDetectionKind,
ModuleInstanceState: () => ModuleInstanceState,
ModuleKind: () => ModuleKind,
ModuleResolutionKind: () => ModuleResolutionKind,
ModuleSpecifierEnding: () => ModuleSpecifierEnding,
NavigateTo: () => ts_NavigateTo_exports,
NavigationBar: () => ts_NavigationBar_exports,
NewLineKind: () => NewLineKind,
NodeBuilderFlags: () => NodeBuilderFlags,
NodeCheckFlags: () => NodeCheckFlags,
NodeFactoryFlags: () => NodeFactoryFlags,
NodeFlags: () => NodeFlags,
NodeResolutionFeatures: () => NodeResolutionFeatures,
ObjectFlags: () => ObjectFlags,
OperationCanceledException: () => OperationCanceledException,
OperatorPrecedence: () => OperatorPrecedence,
OrganizeImports: () => ts_OrganizeImports_exports,
OrganizeImportsMode: () => OrganizeImportsMode,
OuterExpressionKinds: () => OuterExpressionKinds,
OutliningElementsCollector: () => ts_OutliningElementsCollector_exports,
OutliningSpanKind: () => OutliningSpanKind,
OutputFileType: () => OutputFileType,
PackageJsonAutoImportPreference: () => PackageJsonAutoImportPreference,
PackageJsonDependencyGroup: () => PackageJsonDependencyGroup,
PatternMatchKind: () => PatternMatchKind,
PollingInterval: () => PollingInterval,
PollingWatchKind: () => PollingWatchKind,
PragmaKindFlags: () => PragmaKindFlags,
PredicateSemantics: () => PredicateSemantics,
PreparePasteEdits: () => ts_preparePasteEdits_exports,
PrivateIdentifierKind: () => PrivateIdentifierKind,
ProcessLevel: () => ProcessLevel,
ProgramUpdateLevel: () => ProgramUpdateLevel,
QuotePreference: () => QuotePreference,
RegularExpressionFlags: () => RegularExpressionFlags,
RelationComparisonResult: () => RelationComparisonResult,
Rename: () => ts_Rename_exports,
ScriptElementKind: () => ScriptElementKind,
ScriptElementKindModifier: () => ScriptElementKindModifier,
ScriptKind: () => ScriptKind,
ScriptSnapshot: () => ScriptSnapshot,
ScriptTarget: () => ScriptTarget,
SemanticClassificationFormat: () => SemanticClassificationFormat,
SemanticMeaning: () => SemanticMeaning,
SemicolonPreference: () => SemicolonPreference,
SignatureCheckMode: () => SignatureCheckMode,
SignatureFlags: () => SignatureFlags,
SignatureHelp: () => ts_SignatureHelp_exports,
SignatureInfo: () => SignatureInfo,
SignatureKind: () => SignatureKind,
SmartSelectionRange: () => ts_SmartSelectionRange_exports,
SnippetKind: () => SnippetKind,
StatisticType: () => StatisticType,
StructureIsReused: () => StructureIsReused,
SymbolAccessibility: () => SymbolAccessibility,
SymbolDisplay: () => ts_SymbolDisplay_exports,
SymbolDisplayPartKind: () => SymbolDisplayPartKind,
SymbolFlags: () => SymbolFlags,
SymbolFormatFlags: () => SymbolFormatFlags,
SyntaxKind: () => SyntaxKind,
Ternary: () => Ternary,
ThrottledCancellationToken: () => ThrottledCancellationToken,
TokenClass: () => TokenClass,
TokenFlags: () => TokenFlags,
TransformFlags: () => TransformFlags,
TypeFacts: () => TypeFacts,
TypeFlags: () => TypeFlags,
TypeFormatFlags: () => TypeFormatFlags,
TypeMapKind: () => TypeMapKind,
TypePredicateKind: () => TypePredicateKind,
TypeReferenceSerializationKind: () => TypeReferenceSerializationKind,
UnionReduction: () => UnionReduction,
UpToDateStatusType: () => UpToDateStatusType,
VarianceFlags: () => VarianceFlags,
Version: () => Version,
VersionRange: () => VersionRange,
WatchDirectoryFlags: () => WatchDirectoryFlags,
WatchDirectoryKind: () => WatchDirectoryKind,
WatchFileKind: () => WatchFileKind,
WatchLogLevel: () => WatchLogLevel,
WatchType: () => WatchType,
accessPrivateIdentifier: () => accessPrivateIdentifier,
addEmitFlags: () => addEmitFlags,
addEmitHelper: () => addEmitHelper,
addEmitHelpers: () => addEmitHelpers,
addInternalEmitFlags: () => addInternalEmitFlags,
addNodeFactoryPatcher: () => addNodeFactoryPatcher,
addObjectAllocatorPatcher: () => addObjectAllocatorPatcher,
addRange: () => addRange,
addRelatedInfo: () => addRelatedInfo,
addSyntheticLeadingComment: () => addSyntheticLeadingComment,
addSyntheticTrailingComment: () => addSyntheticTrailingComment,
addToSeen: () => addToSeen,
advancedAsyncSuperHelper: () => advancedAsyncSuperHelper,
affectsDeclarationPathOptionDeclarations: () => affectsDeclarationPathOptionDeclarations,
affectsEmitOptionDeclarations: () => affectsEmitOptionDeclarations,
allKeysStartWithDot: () => allKeysStartWithDot,
altDirectorySeparator: () => altDirectorySeparator,
and: () => and,
append: () => append,
appendIfUnique: () => appendIfUnique,
arrayFrom: () => arrayFrom,
arrayIsEqualTo: () => arrayIsEqualTo,
arrayIsHomogeneous: () => arrayIsHomogeneous,
arrayOf: () => arrayOf,
arrayReverseIterator: () => arrayReverseIterator,
arrayToMap: () => arrayToMap,
arrayToMultiMap: () => arrayToMultiMap,
arrayToNumericMap: () => arrayToNumericMap,
assertType: () => assertType,
assign: () => assign,
asyncSuperHelper: () => asyncSuperHelper,
attachFileToDiagnostics: () => attachFileToDiagnostics,
base64decode: () => base64decode,
base64encode: () => base64encode,
binarySearch: () => binarySearch,
binarySearchKey: () => binarySearchKey,
bindSourceFile: () => bindSourceFile,
breakIntoCharacterSpans: () => breakIntoCharacterSpans,
breakIntoWordSpans: () => breakIntoWordSpans,
buildLinkParts: () => buildLinkParts,
buildOpts: () => buildOpts,
buildOverload: () => buildOverload,
bundlerModuleNameResolver: () => bundlerModuleNameResolver,
canBeConvertedToAsync: () => canBeConvertedToAsync,
canHaveDecorators: () => canHaveDecorators,
canHaveExportModifier: () => canHaveExportModifier,
canHaveFlowNode: () => canHaveFlowNode,
canHaveIllegalDecorators: () => canHaveIllegalDecorators,
canHaveIllegalModifiers: () => canHaveIllegalModifiers,
canHaveIllegalType: () => canHaveIllegalType,
canHaveIllegalTypeParameters: () => canHaveIllegalTypeParameters,
canHaveJSDoc: () => canHaveJSDoc,
canHaveLocals: () => canHaveLocals,
canHaveModifiers: () => canHaveModifiers,
canHaveModuleSpecifier: () => canHaveModuleSpecifier,
canHaveSymbol: () => canHaveSymbol,
canIncludeBindAndCheckDiagnostics: () => canIncludeBindAndCheckDiagnostics,
canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
canProduceDiagnostics: () => canProduceDiagnostics,
canUsePropertyAccess: () => canUsePropertyAccess,
canWatchAffectingLocation: () => canWatchAffectingLocation,
canWatchAtTypes: () => canWatchAtTypes,
canWatchDirectoryOrFile: () => canWatchDirectoryOrFile,
canWatchDirectoryOrFilePath: () => canWatchDirectoryOrFilePath,
cartesianProduct: () => cartesianProduct,
cast: () => cast,
chainBundle: () => chainBundle,
chainDiagnosticMessages: () => chainDiagnosticMessages,
changeAnyExtension: () => changeAnyExtension,
changeCompilerHostLikeToUseCache: () => changeCompilerHostLikeToUseCache,
changeExtension: () => changeExtension,
changeFullExtension: () => changeFullExtension,
changesAffectModuleResolution: () => changesAffectModuleResolution,
changesAffectingProgramStructure: () => changesAffectingProgramStructure,
characterCodeToRegularExpressionFlag: () => characterCodeToRegularExpressionFlag,
childIsDecorated: () => childIsDecorated,
classElementOrClassElementParameterIsDecorated: () => classElementOrClassElementParameterIsDecorated,
classHasClassThisAssignment: () => classHasClassThisAssignment,
classHasDeclaredOrExplicitlyAssignedName: () => classHasDeclaredOrExplicitlyAssignedName,
classHasExplicitlyAssignedName: () => classHasExplicitlyAssignedName,
classOrConstructorParameterIsDecorated: () => classOrConstructorParameterIsDecorated,
classicNameResolver: () => classicNameResolver,
classifier: () => ts_classifier_exports,
cleanExtendedConfigCache: () => cleanExtendedConfigCache,
clear: () => clear,
clearMap: () => clearMap,
clearSharedExtendedConfigFileWatcher: () => clearSharedExtendedConfigFileWatcher,
climbPastPropertyAccess: () => climbPastPropertyAccess,
clone: () => clone,
cloneCompilerOptions: () => cloneCompilerOptions,
closeFileWatcher: () => closeFileWatcher,
closeFileWatcherOf: () => closeFileWatcherOf,
codefix: () => ts_codefix_exports,
collapseTextChangeRangesAcrossMultipleVersions: () => collapseTextChangeRangesAcrossMultipleVersions,
collectExternalModuleInfo: () => collectExternalModuleInfo,
combine: () => combine,
combinePaths: () => combinePaths,
commandLineOptionOfCustomType: () => commandLineOptionOfCustomType,
commentPragmas: () => commentPragmas,
commonOptionsWithBuild: () => commonOptionsWithBuild,
compact: () => compact,
compareBooleans: () => compareBooleans,
compareDataObjects: () => compareDataObjects,
compareDiagnostics: () => compareDiagnostics,
compareEmitHelpers: () => compareEmitHelpers,
compareNumberOfDirectorySeparators: () => compareNumberOfDirectorySeparators,
comparePaths: () => comparePaths,
comparePathsCaseInsensitive: () => comparePathsCaseInsensitive,
comparePathsCaseSensitive: () => comparePathsCaseSensitive,
comparePatternKeys: () => comparePatternKeys,
compareProperties: () => compareProperties,
compareStringsCaseInsensitive: () => compareStringsCaseInsensitive,
compareStringsCaseInsensitiveEslintCompatible: () => compareStringsCaseInsensitiveEslintCompatible,
compareStringsCaseSensitive: () => compareStringsCaseSensitive,
compareStringsCaseSensitiveUI: () => compareStringsCaseSensitiveUI,
compareTextSpans: () => compareTextSpans,
compareValues: () => compareValues,
compilerOptionsAffectDeclarationPath: () => compilerOptionsAffectDeclarationPath,
compilerOptionsAffectEmit: () => compilerOptionsAffectEmit,
compilerOptionsAffectSemanticDiagnostics: () => compilerOptionsAffectSemanticDiagnostics,
compilerOptionsDidYouMeanDiagnostics: () => compilerOptionsDidYouMeanDiagnostics,
compilerOptionsIndicateEsModules: () => compilerOptionsIndicateEsModules,
computeCommonSourceDirectoryOfFilenames: () => computeCommonSourceDirectoryOfFilenames,
computeLineAndCharacterOfPosition: () => computeLineAndCharacterOfPosition,
computeLineOfPosition: () => computeLineOfPosition,
computeLineStarts: () => computeLineStarts,
computePositionOfLineAndCharacter: () => computePositionOfLineAndCharacter,
computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
computedOptions: () => computedOptions,
concatenate: () => concatenate,
concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
consumesNodeCoreModules: () => consumesNodeCoreModules,
contains: () => contains,
containsIgnoredPath: () => containsIgnoredPath,
containsObjectRestOrSpread: () => containsObjectRestOrSpread,
containsParseError: () => containsParseError,
containsPath: () => containsPath,
convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry,
convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
convertJsonOption: () => convertJsonOption,
convertToBase64: () => convertToBase64,
convertToJson: () => convertToJson,
convertToObject: () => convertToObject,
convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
convertToRelativePath: () => convertToRelativePath,
convertToTSConfig: () => convertToTSConfig,
convertTypeAcquisitionFromJson: () => convertTypeAcquisitionFromJson,
copyComments: () => copyComments,
copyEntries: () => copyEntries,
copyLeadingComments: () => copyLeadingComments,
copyProperties: () => copyProperties,
copyTrailingAsLeadingComments: () => copyTrailingAsLeadingComments,
copyTrailingComments: () => copyTrailingComments,
couldStartTrivia: () => couldStartTrivia,
countWhere: () => countWhere,
createAbstractBuilder: () => createAbstractBuilder,
createAccessorPropertyBackingField: () => createAccessorPropertyBackingField,
createAccessorPropertyGetRedirector: () => createAccessorPropertyGetRedirector,
createAccessorPropertySetRedirector: () => createAccessorPropertySetRedirector,
createBaseNodeFactory: () => createBaseNodeFactory,
createBinaryExpressionTrampoline: () => createBinaryExpressionTrampoline,
createBuilderProgram: () => createBuilderProgram,
createBuilderProgramUsingIncrementalBuildInfo: () => createBuilderProgramUsingIncrementalBuildInfo,
createBuilderStatusReporter: () => createBuilderStatusReporter,
createCacheableExportInfoMap: () => createCacheableExportInfoMap,
createCachedDirectoryStructureHost: () => createCachedDirectoryStructureHost,
createClassifier: () => createClassifier,
createCommentDirectivesMap: () => createCommentDirectivesMap,
createCompilerDiagnostic: () => createCompilerDiagnostic,
createCompilerDiagnosticForInvalidCustomType: () => createCompilerDiagnosticForInvalidCustomType,
createCompilerDiagnosticFromMessageChain: () => createCompilerDiagnosticFromMessageChain,
createCompilerHost: () => createCompilerHost,
createCompilerHostFromProgramHost: () => createCompilerHostFromProgramHost,
createCompilerHostWorker: () => createCompilerHostWorker,
createDetachedDiagnostic: () => createDetachedDiagnostic,
createDiagnosticCollection: () => createDiagnosticCollection,
createDiagnosticForFileFromMessageChain: () => createDiagnosticForFileFromMessageChain,
createDiagnosticForNode: () => createDiagnosticForNode,
createDiagnosticForNodeArray: () => createDiagnosticForNodeArray,
createDiagnosticForNodeArrayFromMessageChain: () => createDiagnosticForNodeArrayFromMessageChain,
createDiagnosticForNodeFromMessageChain: () => createDiagnosticForNodeFromMessageChain,
createDiagnosticForNodeInSourceFile: () => createDiagnosticForNodeInSourceFile,
createDiagnosticForRange: () => createDiagnosticForRange,
createDiagnosticMessageChainFromDiagnostic: () => createDiagnosticMessageChainFromDiagnostic,
createDiagnosticReporter: () => createDiagnosticReporter,
createDocumentPositionMapper: () => createDocumentPositionMapper,
createDocumentRegistry: () => createDocumentRegistry,
createDocumentRegistryInternal: () => createDocumentRegistryInternal,
createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
createEmitHelperFactory: () => createEmitHelperFactory,
createEmptyExports: () => createEmptyExports,
createEvaluator: () => createEvaluator,
createExpressionForJsxElement: () => createExpressionForJsxElement,
createExpressionForJsxFragment: () => createExpressionForJsxFragment,
createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
createExpressionForPropertyName: () => createExpressionForPropertyName,
createExpressionFromEntityName: () => createExpressionFromEntityName,
createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded,
createFileDiagnostic: () => createFileDiagnostic,
createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
createFlowNode: () => createFlowNode,
createForOfBindingStatement: () => createForOfBindingStatement,
createFutureSourceFile: () => createFutureSourceFile,
createGetCanonicalFileName: () => createGetCanonicalFileName,
createGetIsolatedDeclarationErrors: () => createGetIsolatedDeclarationErrors,
createGetSourceFile: () => createGetSourceFile,
createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
createGetSymbolAccessibilityDiagnosticForNodeName: () => createGetSymbolAccessibilityDiagnosticForNodeName,
createGetSymbolWalker: () => createGetSymbolWalker,
createIncrementalCompilerHost: () => createIncrementalCompilerHost,
createIncrementalProgram: () => createIncrementalProgram,
createJsxFactoryExpression: () => createJsxFactoryExpression,
createLanguageService: () => createLanguageService,
createLanguageServiceSourceFile: () => createLanguageServiceSourceFile,
createMemberAccessForPropertyName: () => createMemberAccessForPropertyName,
createModeAwareCache: () => createModeAwareCache,
createModeAwareCacheKey: () => createModeAwareCacheKey,
createModeMismatchDetails: () => createModeMismatchDetails,
createModuleNotFoundChain: () => createModuleNotFoundChain,
createModuleResolutionCache: () => createModuleResolutionCache,
createModuleResolutionLoader: () => createModuleResolutionLoader,
createModuleResolutionLoaderUsingGlobalCache: () => createModuleResolutionLoaderUsingGlobalCache,
createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost,
createMultiMap: () => createMultiMap,
createNameResolver: () => createNameResolver,
createNodeConverters: () => createNodeConverters,
createNodeFactory: () => createNodeFactory,
createOptionNameMap: () => createOptionNameMap,
createOverload: () => createOverload,
createPackageJsonImportFilter: () => createPackageJsonImportFilter,
createPackageJsonInfo: () => createPackageJsonInfo,
createParenthesizerRules: () => createParenthesizerRules,
createPatternMatcher: () => createPatternMatcher,
createPrinter: () => createPrinter,
createPrinterWithDefaults: () => createPrinterWithDefaults,
createPrinterWithRemoveComments: () => createPrinterWithRemoveComments,
createPrinterWithRemoveCommentsNeverAsciiEscape: () => createPrinterWithRemoveCommentsNeverAsciiEscape,
createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => createPrinterWithRemoveCommentsOmitTrailingSemicolon,
createProgram: () => createProgram,
createProgramDiagnostics: () => createProgramDiagnostics,
createProgramHost: () => createProgramHost,
createPropertyNameNodeForIdentifierOrLiteral: () => createPropertyNameNodeForIdentifierOrLiteral,
createQueue: () => createQueue,
createRange: () => createRange,
createRedirectedBuilderProgram: () => createRedirectedBuilderProgram,
createResolutionCache: () => createResolutionCache,
createRuntimeTypeSerializer: () => createRuntimeTypeSerializer,
createScanner: () => createScanner,
createSemanticDiagnosticsBuilderProgram: () => createSemanticDiagnosticsBuilderProgram,
createSet: () => createSet,
createSolutionBuilder: () => createSolutionBuilder,
createSolutionBuilderHost: () => createSolutionBuilderHost,
createSolutionBuilderWithWatch: () => createSolutionBuilderWithWatch,
createSolutionBuilderWithWatchHost: () => createSolutionBuilderWithWatchHost,
createSortedArray: () => createSortedArray,
createSourceFile: () => createSourceFile,
createSourceMapGenerator: () => createSourceMapGenerator,
createSourceMapSource: () => createSourceMapSource,
createSuperAccessVariableStatement: () => createSuperAccessVariableStatement,
createSymbolTable: () => createSymbolTable,
createSymlinkCache: () => createSymlinkCache,
createSyntacticTypeNodeBuilder: () => createSyntacticTypeNodeBuilder,
createSystemWatchFunctions: () => createSystemWatchFunctions,
createTextChange: () => createTextChange,
createTextChangeFromStartLength: () => createTextChangeFromStartLength,
createTextChangeRange: () => createTextChangeRange,
createTextRangeFromNode: () => createTextRangeFromNode,
createTextRangeFromSpan: () => createTextRangeFromSpan,
createTextSpan: () => createTextSpan,
createTextSpanFromBounds: () => createTextSpanFromBounds,
createTextSpanFromNode: () => createTextSpanFromNode,
createTextSpanFromRange: () => createTextSpanFromRange,
createTextSpanFromStringLiteralLikeContent: () => createTextSpanFromStringLiteralLikeContent,
createTextWriter: () => createTextWriter,
createTokenRange: () => createTokenRange,
createTypeChecker: () => createTypeChecker,
createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
createWatchCompilerHost: () => createWatchCompilerHost2,
createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,
createWatchCompilerHostOfFilesAndCompilerOptions: () => createWatchCompilerHostOfFilesAndCompilerOptions,
createWatchFactory: () => createWatchFactory,
createWatchHost: () => createWatchHost,
createWatchProgram: () => createWatchProgram,
createWatchStatusReporter: () => createWatchStatusReporter,
createWriteFileMeasuringIO: () => createWriteFileMeasuringIO,
declarationNameToString: () => declarationNameToString,
decodeMappings: () => decodeMappings,
decodedTextSpanIntersectsWith: () => decodedTextSpanIntersectsWith,
deduplicate: () => deduplicate,
defaultInitCompilerOptions: () => defaultInitCompilerOptions,
defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
diagnosticCategoryName: () => diagnosticCategoryName,
diagnosticToString: () => diagnosticToString,
diagnosticsEqualityComparer: () => diagnosticsEqualityComparer,
directoryProbablyExists: () => directoryProbablyExists,
directorySeparator: () => directorySeparator,
displayPart: () => displayPart,
displayPartsToString: () => displayPartsToString,
disposeEmitNodes: () => disposeEmitNodes,
documentSpansEqual: () => documentSpansEqual,
dumpTracingLegend: () => dumpTracingLegend,
elementAt: () => elementAt,
elideNodes: () => elideNodes,
emitDetachedComments: () => emitDetachedComments,
emitFiles: () => emitFiles,
emitFilesAndReportErrors: () => emitFilesAndReportErrors,
emitFilesAndReportErrorsAndGetExitStatus: () => emitFilesAndReportErrorsAndGetExitStatus,
emitModuleKindIsNonNodeESM: () => emitModuleKindIsNonNodeESM,
emitNewLineBeforeLeadingCommentOfPosition: () => emitNewLineBeforeLeadingCommentOfPosition,
emitResolverSkipsTypeChecking: () => emitResolverSkipsTypeChecking,
emitSkippedWithNoDiagnostics: () => emitSkippedWithNoDiagnostics,
emptyArray: () => emptyArray,
emptyFileSystemEntries: () => emptyFileSystemEntries,
emptyMap: () => emptyMap,
emptyOptions: () => emptyOptions,
endsWith: () => endsWith,
ensurePathIsNonModuleName: () => ensurePathIsNonModuleName,
ensureScriptKind: () => ensureScriptKind,
ensureTrailingDirectorySeparator: () => ensureTrailingDirectorySeparator,
entityNameToString: () => entityNameToString,
enumerateInsertsAndDeletes: () => enumerateInsertsAndDeletes,
equalOwnProperties: () => equalOwnProperties,
equateStringsCaseInsensitive: () => equateStringsCaseInsensitive,
equateStringsCaseSensitive: () => equateStringsCaseSensitive,
equateValues: () => equateValues,
escapeJsxAttributeString: () => escapeJsxAttributeString,
escapeLeadingUnderscores: () => escapeLeadingUnderscores,
escapeNonAsciiString: () => escapeNonAsciiString,
escapeSnippetText: () => escapeSnippetText,
escapeString: () => escapeString,
escapeTemplateSubstitution: () => escapeTemplateSubstitution,
evaluatorResult: () => evaluatorResult,
every: () => every,
exclusivelyPrefixedNodeCoreModules: () => exclusivelyPrefixedNodeCoreModules,
executeCommandLine: () => executeCommandLine,
expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
explainFiles: () => explainFiles,
explainIfFileIsRedirectAndImpliedFormat: () => explainIfFileIsRedirectAndImpliedFormat,
exportAssignmentIsAlias: () => exportAssignmentIsAlias,
expressionResultIsUnused: () => expressionResultIsUnused,
extend: () => extend,
extensionFromPath: () => extensionFromPath,
extensionIsTS: () => extensionIsTS,
extensionsNotSupportingExtensionlessResolution: () => extensionsNotSupportingExtensionlessResolution,
externalHelpersModuleNameText: () => externalHelpersModuleNameText,
factory: () => factory,
fileExtensionIs: () => fileExtensionIs,
fileExtensionIsOneOf: () => fileExtensionIsOneOf,
fileIncludeReasonToDiagnostics: () => fileIncludeReasonToDiagnostics,
fileShouldUseJavaScriptRequire: () => fileShouldUseJavaScriptRequire,
filter: () => filter,
filterMutate: () => filterMutate,
filterSemanticDiagnostics: () => filterSemanticDiagnostics,
find: () => find,
findAncestor: () => findAncestor,
findBestPatternMatch: () => findBestPatternMatch,
findChildOfKind: () => findChildOfKind,
findComputedPropertyNameCacheAssignment: () => findComputedPropertyNameCacheAssignment,
findConfigFile: () => findConfigFile,
findConstructorDeclaration: () => findConstructorDeclaration,
findContainingList: () => findContainingList,
findDiagnosticForNode: () => findDiagnosticForNode,
findFirstNonJsxWhitespaceToken: () => findFirstNonJsxWhitespaceToken,
findIndex: () => findIndex,
findLast: () => findLast,
findLastIndex: () => findLastIndex,
findListItemInfo: () => findListItemInfo,
findModifier: () => findModifier,
findNextToken: () => findNextToken,
findPackageJson: () => findPackageJson,
findPackageJsons: () => findPackageJsons,
findPrecedingMatchingTok