summaryrefslogtreecommitdiff
path: root/cli/js2
diff options
context:
space:
mode:
Diffstat (limited to 'cli/js2')
-rw-r--r--cli/js2/99_main_compiler.js1867
-rw-r--r--cli/js2/lib.deno.ns.d.ts2028
-rw-r--r--cli/js2/lib.deno.shared_globals.d.ts1657
-rw-r--r--cli/js2/lib.deno.unstable.d.ts1217
-rw-r--r--cli/js2/lib.deno.window.d.ts25
-rw-r--r--cli/js2/lib.deno.worker.d.ts43
6 files changed, 0 insertions, 6837 deletions
diff --git a/cli/js2/99_main_compiler.js b/cli/js2/99_main_compiler.js
deleted file mode 100644
index d64896862..000000000
--- a/cli/js2/99_main_compiler.js
+++ /dev/null
@@ -1,1867 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-
-// This module is the entry point for "compiler" isolate, ie. the one
-// that is created when Deno needs to compile TS/WASM to JS.
-//
-// It provides a single functions that should be called by Rust:
-// - `bootstrapTsCompilerRuntime`
-// This functions must be called when creating isolate
-// to properly setup runtime.
-
-// Removes the `__proto__` for security reasons. This intentionally makes
-// Deno non compliant with ECMA-262 Annex B.2.2.1
-//
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-delete Object.prototype.__proto__;
-
-((window) => {
- const core = Deno.core;
- const { bold, cyan, yellow } = window.__bootstrap.colors;
- const { assert, log, notImplemented } = window.__bootstrap.util;
- const { DiagnosticCategory } = window.__bootstrap.diagnostics;
-
- const unstableDenoGlobalProperties = [
- "umask",
- "linkSync",
- "link",
- "symlinkSync",
- "symlink",
- "loadavg",
- "osRelease",
- "openPlugin",
- "DiagnosticCategory",
- "DiagnosticMessageChain",
- "DiagnosticItem",
- "Diagnostic",
- "formatDiagnostics",
- "CompilerOptions",
- "TranspileOnlyResult",
- "transpileOnly",
- "compile",
- "bundle",
- "Location",
- "applySourceMap",
- "LinuxSignal",
- "MacOSSignal",
- "Signal",
- "SignalStream",
- "signal",
- "signals",
- "setRaw",
- "utimeSync",
- "utime",
- "ShutdownMode",
- "shutdown",
- "DatagramConn",
- "UnixListenOptions",
- "listen",
- "listenDatagram",
- "UnixConnectOptions",
- "connect",
- "StartTlsOptions",
- "startTls",
- "kill",
- "PermissionName",
- "PermissionState",
- "RunPermissionDescriptor",
- "ReadPermissionDescriptor",
- "WritePermissionDescriptor",
- "NetPermissionDescriptor",
- "EnvPermissionDescriptor",
- "PluginPermissionDescriptor",
- "HrtimePermissionDescriptor",
- "PermissionDescriptor",
- "Permissions",
- "PermissionStatus",
- "hostname",
- "ppid",
- ];
-
- function transformMessageText(messageText, code) {
- switch (code) {
- case 2339: {
- const property = messageText
- .replace(/^Property '/, "")
- .replace(/' does not exist on type 'typeof Deno'\./, "");
-
- if (
- messageText.endsWith("on type 'typeof Deno'.") &&
- unstableDenoGlobalProperties.includes(property)
- ) {
- return `${messageText} 'Deno.${property}' is an unstable API. Did you forget to run with the '--unstable' flag?`;
- }
- break;
- }
- case 2551: {
- const suggestionMessagePattern = / Did you mean '(.+)'\?$/;
- const property = messageText
- .replace(/^Property '/, "")
- .replace(/' does not exist on type 'typeof Deno'\./, "")
- .replace(suggestionMessagePattern, "");
- const suggestion = messageText.match(suggestionMessagePattern);
- const replacedMessageText = messageText.replace(
- suggestionMessagePattern,
- "",
- );
- if (suggestion && unstableDenoGlobalProperties.includes(property)) {
- const suggestedProperty = suggestion[1];
- return `${replacedMessageText} 'Deno.${property}' is an unstable API. Did you forget to run with the '--unstable' flag, or did you mean '${suggestedProperty}'?`;
- }
- break;
- }
- }
-
- return messageText;
- }
-
- function fromDiagnosticCategory(
- category,
- ) {
- switch (category) {
- case ts.DiagnosticCategory.Error:
- return DiagnosticCategory.Error;
- case ts.DiagnosticCategory.Message:
- return DiagnosticCategory.Info;
- case ts.DiagnosticCategory.Suggestion:
- return DiagnosticCategory.Suggestion;
- case ts.DiagnosticCategory.Warning:
- return DiagnosticCategory.Warning;
- default:
- throw new Error(
- `Unexpected DiagnosticCategory: "${category}"/"${
- ts.DiagnosticCategory[category]
- }"`,
- );
- }
- }
-
- function getSourceInformation(
- sourceFile,
- start,
- length,
- ) {
- const scriptResourceName = sourceFile.fileName;
- const {
- line: lineNumber,
- character: startColumn,
- } = sourceFile.getLineAndCharacterOfPosition(start);
- const endPosition = sourceFile.getLineAndCharacterOfPosition(
- start + length,
- );
- const endColumn = lineNumber === endPosition.line
- ? endPosition.character
- : startColumn;
- const lastLineInFile = sourceFile.getLineAndCharacterOfPosition(
- sourceFile.text.length,
- ).line;
- const lineStart = sourceFile.getPositionOfLineAndCharacter(lineNumber, 0);
- const lineEnd = lineNumber < lastLineInFile
- ? sourceFile.getPositionOfLineAndCharacter(lineNumber + 1, 0)
- : sourceFile.text.length;
- const sourceLine = sourceFile.text
- .slice(lineStart, lineEnd)
- .replace(/\s+$/g, "")
- .replace("\t", " ");
- return {
- sourceLine,
- lineNumber,
- scriptResourceName,
- startColumn,
- endColumn,
- };
- }
-
- function fromDiagnosticMessageChain(
- messageChain,
- ) {
- if (!messageChain) {
- return undefined;
- }
-
- return messageChain.map(({ messageText, code, category, next }) => {
- const message = transformMessageText(messageText, code);
- return {
- message,
- code,
- category: fromDiagnosticCategory(category),
- next: fromDiagnosticMessageChain(next),
- };
- });
- }
-
- function parseDiagnostic(
- item,
- ) {
- const {
- messageText,
- category: sourceCategory,
- code,
- file,
- start: startPosition,
- length,
- } = item;
- const sourceInfo = file && startPosition && length
- ? getSourceInformation(file, startPosition, length)
- : undefined;
- const endPosition = startPosition && length
- ? startPosition + length
- : undefined;
- const category = fromDiagnosticCategory(sourceCategory);
-
- let message;
- let messageChain;
- if (typeof messageText === "string") {
- message = transformMessageText(messageText, code);
- } else {
- message = transformMessageText(messageText.messageText, messageText.code);
- messageChain = fromDiagnosticMessageChain([messageText])[0];
- }
-
- const base = {
- message,
- messageChain,
- code,
- category,
- startPosition,
- endPosition,
- };
-
- return sourceInfo ? { ...base, ...sourceInfo } : base;
- }
-
- function parseRelatedInformation(
- relatedInformation,
- ) {
- const result = [];
- for (const item of relatedInformation) {
- result.push(parseDiagnostic(item));
- }
- return result;
- }
-
- function fromTypeScriptDiagnostic(
- diagnostics,
- ) {
- const items = [];
- for (const sourceDiagnostic of diagnostics) {
- const item = parseDiagnostic(sourceDiagnostic);
- if (sourceDiagnostic.relatedInformation) {
- item.relatedInformation = parseRelatedInformation(
- sourceDiagnostic.relatedInformation,
- );
- }
- items.push(item);
- }
- return { items };
- }
-
- // We really don't want to depend on JSON dispatch during snapshotting, so
- // this op exchanges strings with Rust as raw byte arrays.
- function getAsset(name) {
- const opId = core.ops()["op_fetch_asset"];
- const sourceCodeBytes = core.dispatch(opId, core.encode(name));
- return core.decode(sourceCodeBytes);
- }
-
- // Constants used by `normalizeString` and `resolvePath`
- const CHAR_DOT = 46; /* . */
- const CHAR_FORWARD_SLASH = 47; /* / */
- // Using incremental compile APIs requires that all
- // paths must be either relative or absolute. Since
- // analysis in Rust operates on fully resolved URLs,
- // it makes sense to use the same scheme here.
- const ASSETS = "asset://";
- const OUT_DIR = "deno://";
- // This constant is passed to compiler settings when
- // doing incremental compiles. Contents of this
- // file are passed back to Rust and saved to $DENO_DIR.
- const TS_BUILD_INFO = "cache:///tsbuildinfo.json";
-
- // TODO(Bartlomieju): this check should be done in Rust
- const IGNORED_COMPILER_OPTIONS = [
- "allowSyntheticDefaultImports",
- "allowUmdGlobalAccess",
- "assumeChangesOnlyAffectDirectDependencies",
- "baseUrl",
- "build",
- "composite",
- "declaration",
- "declarationDir",
- "declarationMap",
- "diagnostics",
- "downlevelIteration",
- "emitBOM",
- "emitDeclarationOnly",
- "esModuleInterop",
- "extendedDiagnostics",
- "forceConsistentCasingInFileNames",
- "generateCpuProfile",
- "help",
- "importHelpers",
- "incremental",
- "inlineSourceMap",
- "inlineSources",
- "init",
- "listEmittedFiles",
- "listFiles",
- "mapRoot",
- "maxNodeModuleJsDepth",
- "module",
- "moduleResolution",
- "newLine",
- "noEmit",
- "noEmitHelpers",
- "noEmitOnError",
- "noLib",
- "noResolve",
- "out",
- "outDir",
- "outFile",
- "paths",
- "preserveSymlinks",
- "preserveWatchOutput",
- "pretty",
- "rootDir",
- "rootDirs",
- "showConfig",
- "skipDefaultLibCheck",
- "skipLibCheck",
- "sourceMap",
- "sourceRoot",
- "stripInternal",
- "target",
- "traceResolution",
- "tsBuildInfoFile",
- "types",
- "typeRoots",
- "version",
- "watch",
- ];
-
- const DEFAULT_BUNDLER_OPTIONS = {
- allowJs: true,
- inlineSourceMap: false,
- module: ts.ModuleKind.System,
- outDir: undefined,
- outFile: `${OUT_DIR}/bundle.js`,
- // disabled until we have effective way to modify source maps
- sourceMap: false,
- };
-
- const DEFAULT_INCREMENTAL_COMPILE_OPTIONS = {
- allowJs: false,
- allowNonTsExtensions: true,
- checkJs: false,
- esModuleInterop: true,
- incremental: true,
- inlineSourceMap: true,
- jsx: ts.JsxEmit.React,
- module: ts.ModuleKind.ESNext,
- outDir: OUT_DIR,
- resolveJsonModule: true,
- sourceMap: false,
- strict: true,
- stripComments: true,
- target: ts.ScriptTarget.ESNext,
- tsBuildInfoFile: TS_BUILD_INFO,
- };
-
- const DEFAULT_COMPILE_OPTIONS = {
- allowJs: false,
- allowNonTsExtensions: true,
- checkJs: false,
- esModuleInterop: true,
- jsx: ts.JsxEmit.React,
- module: ts.ModuleKind.ESNext,
- outDir: OUT_DIR,
- sourceMap: true,
- strict: true,
- removeComments: true,
- target: ts.ScriptTarget.ESNext,
- };
-
- const DEFAULT_TRANSPILE_OPTIONS = {
- esModuleInterop: true,
- inlineSourceMap: true,
- jsx: ts.JsxEmit.React,
- module: ts.ModuleKind.ESNext,
- removeComments: true,
- target: ts.ScriptTarget.ESNext,
- };
-
- const DEFAULT_RUNTIME_COMPILE_OPTIONS = {
- outDir: undefined,
- };
-
- const DEFAULT_RUNTIME_TRANSPILE_OPTIONS = {
- esModuleInterop: true,
- module: ts.ModuleKind.ESNext,
- sourceMap: true,
- scriptComments: true,
- target: ts.ScriptTarget.ESNext,
- };
-
- const CompilerHostTarget = {
- Main: "main",
- Runtime: "runtime",
- Worker: "worker",
- };
-
- // Warning! The values in this enum are duplicated in `cli/msg.rs`
- // Update carefully!
- const MediaType = {
- 0: "JavaScript",
- 1: "JSX",
- 2: "TypeScript",
- 3: "TSX",
- 4: "Json",
- 5: "Wasm",
- 6: "Unknown",
- JavaScript: 0,
- JSX: 1,
- TypeScript: 2,
- TSX: 3,
- Json: 4,
- Wasm: 5,
- Unknown: 6,
- };
-
- function getExtension(fileName, mediaType) {
- switch (mediaType) {
- case MediaType.JavaScript:
- return ts.Extension.Js;
- case MediaType.JSX:
- return ts.Extension.Jsx;
- case MediaType.TypeScript:
- return fileName.endsWith(".d.ts") ? ts.Extension.Dts : ts.Extension.Ts;
- case MediaType.TSX:
- return ts.Extension.Tsx;
- case MediaType.Wasm:
- // Custom marker for Wasm type.
- return ts.Extension.Js;
- case MediaType.Unknown:
- default:
- throw TypeError(
- `Cannot resolve extension for "${fileName}" with mediaType "${
- MediaType[mediaType]
- }".`,
- );
- }
- }
-
- /** A global cache of module source files that have been loaded.
- * This cache will be rewritten to be populated on compiler startup
- * with files provided from Rust in request message.
- */
- const SOURCE_FILE_CACHE = new Map();
- /** A map of maps which cache resolved specifier for each import in a file.
- * This cache is used so `resolveModuleNames` ops is called as few times
- * as possible.
- *
- * First map's key is "referrer" URL ("file://a/b/c/mod.ts")
- * Second map's key is "raw" import specifier ("./foo.ts")
- * Second map's value is resolved import URL ("file:///a/b/c/foo.ts")
- */
- const RESOLVED_SPECIFIER_CACHE = new Map();
-
- function configure(
- defaultOptions,
- source,
- path,
- cwd,
- ) {
- const { config, error } = ts.parseConfigFileTextToJson(path, source);
- if (error) {
- return { diagnostics: [error], options: defaultOptions };
- }
- const { options, errors } = ts.convertCompilerOptionsFromJson(
- config.compilerOptions,
- cwd,
- );
- const ignoredOptions = [];
- for (const key of Object.keys(options)) {
- if (
- IGNORED_COMPILER_OPTIONS.includes(key) &&
- (!(key in defaultOptions) || options[key] !== defaultOptions[key])
- ) {
- ignoredOptions.push(key);
- delete options[key];
- }
- }
- return {
- options: Object.assign({}, defaultOptions, options),
- ignoredOptions: ignoredOptions.length ? ignoredOptions : undefined,
- diagnostics: errors.length ? errors : undefined,
- };
- }
-
- class SourceFile {
- constructor(json) {
- this.processed = false;
- Object.assign(this, json);
- this.extension = getExtension(this.url, this.mediaType);
- }
-
- static addToCache(json) {
- if (SOURCE_FILE_CACHE.has(json.url)) {
- throw new TypeError("SourceFile already exists");
- }
- const sf = new SourceFile(json);
- SOURCE_FILE_CACHE.set(sf.url, sf);
- return sf;
- }
-
- static getCached(url) {
- return SOURCE_FILE_CACHE.get(url);
- }
-
- static cacheResolvedUrl(
- resolvedUrl,
- rawModuleSpecifier,
- containingFile,
- ) {
- containingFile = containingFile || "";
- let innerCache = RESOLVED_SPECIFIER_CACHE.get(containingFile);
- if (!innerCache) {
- innerCache = new Map();
- RESOLVED_SPECIFIER_CACHE.set(containingFile, innerCache);
- }
- innerCache.set(rawModuleSpecifier, resolvedUrl);
- }
-
- static getResolvedUrl(
- moduleSpecifier,
- containingFile,
- ) {
- const containingCache = RESOLVED_SPECIFIER_CACHE.get(containingFile);
- if (containingCache) {
- return containingCache.get(moduleSpecifier);
- }
- return undefined;
- }
- }
-
- function getAssetInternal(filename) {
- const lastSegment = filename.split("/").pop();
- const url = ts.libMap.has(lastSegment)
- ? ts.libMap.get(lastSegment)
- : lastSegment;
- const sourceFile = SourceFile.getCached(url);
- if (sourceFile) {
- return sourceFile;
- }
- const name = url.includes(".") ? url : `${url}.d.ts`;
- const sourceCode = getAsset(name);
- return SourceFile.addToCache({
- url,
- filename: `${ASSETS}/${name}`,
- mediaType: MediaType.TypeScript,
- versionHash: "1",
- sourceCode,
- });
- }
-
- class Host {
- #options = DEFAULT_COMPILE_OPTIONS;
- #target = "";
- #writeFile = null;
- /* Deno specific APIs */
-
- constructor({
- bundle = false,
- incremental = false,
- target,
- unstable,
- writeFile,
- }) {
- this.#target = target;
- this.#writeFile = writeFile;
- if (bundle) {
- // options we need to change when we are generating a bundle
- Object.assign(this.#options, DEFAULT_BUNDLER_OPTIONS);
- } else if (incremental) {
- Object.assign(this.#options, DEFAULT_INCREMENTAL_COMPILE_OPTIONS);
- }
- if (unstable) {
- this.#options.lib = [
- target === CompilerHostTarget.Worker
- ? "lib.deno.worker.d.ts"
- : "lib.deno.window.d.ts",
- "lib.deno.unstable.d.ts",
- ];
- }
- }
-
- get options() {
- return this.#options;
- }
-
- configure(
- cwd,
- path,
- configurationText,
- ) {
- log("compiler::host.configure", path);
- const { options, ...result } = configure(
- this.#options,
- configurationText,
- path,
- cwd,
- );
- this.#options = options;
- return result;
- }
-
- mergeOptions(...options) {
- Object.assign(this.#options, ...options);
- return Object.assign({}, this.#options);
- }
-
- /* TypeScript CompilerHost APIs */
-
- fileExists(_fileName) {
- return notImplemented();
- }
-
- getCanonicalFileName(fileName) {
- return fileName;
- }
-
- getCompilationSettings() {
- log("compiler::host.getCompilationSettings()");
- return this.#options;
- }
-
- getCurrentDirectory() {
- return "";
- }
-
- getDefaultLibFileName(_options) {
- log("compiler::host.getDefaultLibFileName()");
- switch (this.#target) {
- case CompilerHostTarget.Main:
- case CompilerHostTarget.Runtime:
- return `${ASSETS}/lib.deno.window.d.ts`;
- case CompilerHostTarget.Worker:
- return `${ASSETS}/lib.deno.worker.d.ts`;
- }
- }
-
- getNewLine() {
- return "\n";
- }
-
- getSourceFile(
- fileName,
- languageVersion,
- onError,
- shouldCreateNewSourceFile,
- ) {
- log("compiler::host.getSourceFile", fileName);
- try {
- assert(!shouldCreateNewSourceFile);
- const sourceFile = fileName.startsWith(ASSETS)
- ? getAssetInternal(fileName)
- : SourceFile.getCached(fileName);
- assert(sourceFile != null);
- if (!sourceFile.tsSourceFile) {
- assert(sourceFile.sourceCode != null);
- const tsSourceFileName = fileName.startsWith(ASSETS)
- ? sourceFile.filename
- : fileName;
-
- sourceFile.tsSourceFile = ts.createSourceFile(
- tsSourceFileName,
- sourceFile.sourceCode,
- languageVersion,
- );
- sourceFile.tsSourceFile.version = sourceFile.versionHash;
- delete sourceFile.sourceCode;
- }
- return sourceFile.tsSourceFile;
- } catch (e) {
- if (onError) {
- onError(String(e));
- } else {
- throw e;
- }
- return undefined;
- }
- }
-
- readFile(_fileName) {
- return notImplemented();
- }
-
- resolveModuleNames(
- moduleNames,
- containingFile,
- ) {
- log("compiler::host.resolveModuleNames", {
- moduleNames,
- containingFile,
- });
- const resolved = moduleNames.map((specifier) => {
- const maybeUrl = SourceFile.getResolvedUrl(specifier, containingFile);
-
- log("compiler::host.resolveModuleNames maybeUrl", {
- specifier,
- maybeUrl,
- });
-
- let sourceFile = undefined;
-
- if (specifier.startsWith(ASSETS)) {
- sourceFile = getAssetInternal(specifier);
- } else if (typeof maybeUrl !== "undefined") {
- sourceFile = SourceFile.getCached(maybeUrl);
- }
-
- if (!sourceFile) {
- return undefined;
- }
-
- return {
- resolvedFileName: sourceFile.url,
- isExternalLibraryImport: specifier.startsWith(ASSETS),
- extension: sourceFile.extension,
- };
- });
- log(resolved);
- return resolved;
- }
-
- useCaseSensitiveFileNames() {
- return true;
- }
-
- writeFile(
- fileName,
- data,
- _writeByteOrderMark,
- _onError,
- sourceFiles,
- ) {
- log("compiler::host.writeFile", fileName);
- this.#writeFile(fileName, data, sourceFiles);
- }
- }
-
- class IncrementalCompileHost extends Host {
- #buildInfo = "";
-
- constructor(options) {
- super({ ...options, incremental: true });
- const { buildInfo } = options;
- if (buildInfo) {
- this.#buildInfo = buildInfo;
- }
- }
-
- readFile(fileName) {
- if (fileName == TS_BUILD_INFO) {
- return this.#buildInfo;
- }
- throw new Error("unreachable");
- }
- }
-
- // NOTE: target doesn't really matter here,
- // this is in fact a mock host created just to
- // load all type definitions and snapshot them.
- let SNAPSHOT_HOST = new Host({
- target: CompilerHostTarget.Main,
- writeFile() {},
- });
- const SNAPSHOT_COMPILER_OPTIONS = SNAPSHOT_HOST.getCompilationSettings();
-
- // This is a hacky way of adding our libs to the libs available in TypeScript()
- // as these are internal APIs of TypeScript which maintain valid libs
- ts.libs.push("deno.ns", "deno.window", "deno.worker", "deno.shared_globals");
- ts.libMap.set("deno.ns", "lib.deno.ns.d.ts");
- ts.libMap.set("deno.window", "lib.deno.window.d.ts");
- ts.libMap.set("deno.worker", "lib.deno.worker.d.ts");
- ts.libMap.set("deno.shared_globals", "lib.deno.shared_globals.d.ts");
- ts.libMap.set("deno.unstable", "lib.deno.unstable.d.ts");
-
- // this pre-populates the cache at snapshot time of our library files, so they
- // are available in the future when needed.
- SNAPSHOT_HOST.getSourceFile(
- `${ASSETS}/lib.deno.ns.d.ts`,
- ts.ScriptTarget.ESNext,
- );
- SNAPSHOT_HOST.getSourceFile(
- `${ASSETS}/lib.deno.window.d.ts`,
- ts.ScriptTarget.ESNext,
- );
- SNAPSHOT_HOST.getSourceFile(
- `${ASSETS}/lib.deno.worker.d.ts`,
- ts.ScriptTarget.ESNext,
- );
- SNAPSHOT_HOST.getSourceFile(
- `${ASSETS}/lib.deno.shared_globals.d.ts`,
- ts.ScriptTarget.ESNext,
- );
- SNAPSHOT_HOST.getSourceFile(
- `${ASSETS}/lib.deno.unstable.d.ts`,
- ts.ScriptTarget.ESNext,
- );
-
- // We never use this program; it's only created
- // during snapshotting to hydrate and populate
- // source file cache with lib declaration files.
- const _TS_SNAPSHOT_PROGRAM = ts.createProgram({
- rootNames: [`${ASSETS}/bootstrap.ts`],
- options: SNAPSHOT_COMPILER_OPTIONS,
- host: SNAPSHOT_HOST,
- });
-
- // Derference the snapshot host so it can be GCed
- SNAPSHOT_HOST = undefined;
-
- // This function is called only during snapshotting process
- const SYSTEM_LOADER = getAsset("system_loader.js");
- const SYSTEM_LOADER_ES5 = getAsset("system_loader_es5.js");
-
- function buildLocalSourceFileCache(
- sourceFileMap,
- ) {
- for (const entry of Object.values(sourceFileMap)) {
- assert(entry.sourceCode.length > 0);
- SourceFile.addToCache({
- url: entry.url,
- filename: entry.url,
- mediaType: entry.mediaType,
- sourceCode: entry.sourceCode,
- versionHash: entry.versionHash,
- });
-
- for (const importDesc of entry.imports) {
- let mappedUrl = importDesc.resolvedSpecifier;
- const importedFile = sourceFileMap[importDesc.resolvedSpecifier];
- assert(importedFile);
- const isJsOrJsx = importedFile.mediaType === MediaType.JavaScript ||
- importedFile.mediaType === MediaType.JSX;
- // If JS or JSX perform substitution for types if available
- if (isJsOrJsx) {
- if (importedFile.typeHeaders.length > 0) {
- const typeHeaders = importedFile.typeHeaders[0];
- mappedUrl = typeHeaders.resolvedSpecifier;
- } else if (importDesc.resolvedTypeDirective) {
- mappedUrl = importDesc.resolvedTypeDirective;
- } else if (importedFile.typesDirectives.length > 0) {
- const typeDirective = importedFile.typesDirectives[0];
- mappedUrl = typeDirective.resolvedSpecifier;
- }
- }
-
- mappedUrl = mappedUrl.replace("memory://", "");
- SourceFile.cacheResolvedUrl(mappedUrl, importDesc.specifier, entry.url);
- }
- for (const fileRef of entry.referencedFiles) {
- SourceFile.cacheResolvedUrl(
- fileRef.resolvedSpecifier.replace("memory://", ""),
- fileRef.specifier,
- entry.url,
- );
- }
- for (const fileRef of entry.libDirectives) {
- SourceFile.cacheResolvedUrl(
- fileRef.resolvedSpecifier.replace("memory://", ""),
- fileRef.specifier,
- entry.url,
- );
- }
- }
- }
-
- function buildSourceFileCache(
- sourceFileMap,
- ) {
- for (const entry of Object.values(sourceFileMap)) {
- SourceFile.addToCache({
- url: entry.url,
- filename: entry.url,
- mediaType: entry.mediaType,
- sourceCode: entry.sourceCode,
- versionHash: entry.versionHash,
- });
-
- for (const importDesc of entry.imports) {
- let mappedUrl = importDesc.resolvedSpecifier;
- const importedFile = sourceFileMap[importDesc.resolvedSpecifier];
- // IMPORTANT: due to HTTP redirects we might end up in situation
- // where URL points to a file with completely different URL.
- // In that case we take value of `redirect` field and cache
- // resolved specifier pointing to the value of the redirect.
- // It's not very elegant solution and should be rethinked.
- assert(importedFile);
- if (importedFile.redirect) {
- mappedUrl = importedFile.redirect;
- }
- const isJsOrJsx = importedFile.mediaType === MediaType.JavaScript ||
- importedFile.mediaType === MediaType.JSX;
- // If JS or JSX perform substitution for types if available
- if (isJsOrJsx) {
- if (importedFile.typeHeaders.length > 0) {
- const typeHeaders = importedFile.typeHeaders[0];
- mappedUrl = typeHeaders.resolvedSpecifier;
- } else if (importDesc.resolvedTypeDirective) {
- mappedUrl = importDesc.resolvedTypeDirective;
- } else if (importedFile.typesDirectives.length > 0) {
- const typeDirective = importedFile.typesDirectives[0];
- mappedUrl = typeDirective.resolvedSpecifier;
- }
- }
-
- SourceFile.cacheResolvedUrl(mappedUrl, importDesc.specifier, entry.url);
- }
- for (const fileRef of entry.referencedFiles) {
- SourceFile.cacheResolvedUrl(
- fileRef.resolvedSpecifier,
- fileRef.specifier,
- entry.url,
- );
- }
- for (const fileRef of entry.libDirectives) {
- SourceFile.cacheResolvedUrl(
- fileRef.resolvedSpecifier,
- fileRef.specifier,
- entry.url,
- );
- }
- }
- }
-
- // Warning! The values in this enum are duplicated in `cli/msg.rs`
- // Update carefully!
- const CompilerRequestType = {
- Compile: 0,
- Transpile: 1,
- Bundle: 2,
- RuntimeCompile: 3,
- RuntimeBundle: 4,
- RuntimeTranspile: 5,
- };
-
- function createBundleWriteFile(state) {
- return function writeFile(
- _fileName,
- data,
- sourceFiles,
- ) {
- assert(sourceFiles != null);
- assert(state.host);
- // we only support single root names for bundles
- assert(state.rootNames.length === 1);
- state.bundleOutput = buildBundle(
- state.rootNames[0],
- data,
- sourceFiles,
- state.host.options.target ?? ts.ScriptTarget.ESNext,
- );
- };
- }
-
- function createCompileWriteFile(
- state,
- ) {
- return function writeFile(
- fileName,
- data,
- sourceFiles,
- ) {
- const isBuildInfo = fileName === TS_BUILD_INFO;
-
- if (isBuildInfo) {
- assert(isBuildInfo);
- state.buildInfo = data;
- return;
- }
-
- assert(sourceFiles);
- assert(sourceFiles.length === 1);
- state.emitMap[fileName] = {
- filename: sourceFiles[0].fileName,
- contents: data,
- };
- };
- }
-
- function createRuntimeCompileWriteFile(
- state,
- ) {
- return function writeFile(
- fileName,
- data,
- sourceFiles,
- ) {
- assert(sourceFiles);
- assert(sourceFiles.length === 1);
- state.emitMap[fileName] = {
- filename: sourceFiles[0].fileName,
- contents: data,
- };
- };
- }
-
- function convertCompilerOptions(str) {
- const options = JSON.parse(str);
- const out = {};
- const keys = Object.keys(options);
- const files = [];
- for (const key of keys) {
- switch (key) {
- case "jsx":
- const value = options[key];
- if (value === "preserve") {
- out[key] = ts.JsxEmit.Preserve;
- } else if (value === "react") {
- out[key] = ts.JsxEmit.React;
- } else {
- out[key] = ts.JsxEmit.ReactNative;
- }
- break;
- case "module":
- switch (options[key]) {
- case "amd":
- out[key] = ts.ModuleKind.AMD;
- break;
- case "commonjs":
- out[key] = ts.ModuleKind.CommonJS;
- break;
- case "es2015":
- case "es6":
- out[key] = ts.ModuleKind.ES2015;
- break;
- case "esnext":
- out[key] = ts.ModuleKind.ESNext;
- break;
- case "none":
- out[key] = ts.ModuleKind.None;
- break;
- case "system":
- out[key] = ts.ModuleKind.System;
- break;
- case "umd":
- out[key] = ts.ModuleKind.UMD;
- break;
- default:
- throw new TypeError("Unexpected module type");
- }
- break;
- case "target":
- switch (options[key]) {
- case "es3":
- out[key] = ts.ScriptTarget.ES3;
- break;
- case "es5":
- out[key] = ts.ScriptTarget.ES5;
- break;
- case "es6":
- case "es2015":
- out[key] = ts.ScriptTarget.ES2015;
- break;
- case "es2016":
- out[key] = ts.ScriptTarget.ES2016;
- break;
- case "es2017":
- out[key] = ts.ScriptTarget.ES2017;
- break;
- case "es2018":
- out[key] = ts.ScriptTarget.ES2018;
- break;
- case "es2019":
- out[key] = ts.ScriptTarget.ES2019;
- break;
- case "es2020":
- out[key] = ts.ScriptTarget.ES2020;
- break;
- case "esnext":
- out[key] = ts.ScriptTarget.ESNext;
- break;
- default:
- throw new TypeError("Unexpected emit target.");
- }
- break;
- case "types":
- const types = options[key];
- assert(types);
- files.push(...types);
- break;
- default:
- out[key] = options[key];
- }
- }
- return {
- options: out,
- files: files.length ? files : undefined,
- };
- }
-
- const ignoredDiagnostics = [
- // TS2306: File 'file:///Users/rld/src/deno/cli/tests/subdir/amd_like.js' is
- // not a module.
- 2306,
- // TS1375: 'await' expressions are only allowed at the top level of a file
- // when that file is a module, but this file has no imports or exports.
- // Consider adding an empty 'export {}' to make this file a module.
- 1375,
- // TS1103: 'for-await-of' statement is only allowed within an async function
- // or async generator.
- 1103,
- // TS2691: An import path cannot end with a '.ts' extension. Consider
- // importing 'bad-module' instead.
- 2691,
- // TS5009: Cannot find the common subdirectory path for the input files.
- 5009,
- // TS5055: Cannot write file
- // 'http://localhost:4545/cli/tests/subdir/mt_application_x_javascript.j4.js'
- // because it would overwrite input file.
- 5055,
- // TypeScript is overly opinionated that only CommonJS modules kinds can
- // support JSON imports. Allegedly this was fixed in
- // Microsoft/TypeScript#26825 but that doesn't seem to be working here,
- // so we will ignore complaints about this compiler setting.
- 5070,
- // TS7016: Could not find a declaration file for module '...'. '...'
- // implicitly has an 'any' type. This is due to `allowJs` being off by
- // default but importing of a JavaScript module.
- 7016,
- ];
-
- const stats = [];
- let statsStart = 0;
-
- function performanceStart() {
- stats.length = 0;
- // TODO(kitsonk) replace with performance.mark() when landed
- statsStart = performance.now();
- ts.performance.enable();
- }
-
- function performanceProgram({
- program,
- fileCount,
- }) {
- if (program) {
- if ("getProgram" in program) {
- program = program.getProgram();
- }
- stats.push({ key: "Files", value: program.getSourceFiles().length });
- stats.push({ key: "Nodes", value: program.getNodeCount() });
- stats.push({ key: "Identifiers", value: program.getIdentifierCount() });
- stats.push({ key: "Symbols", value: program.getSymbolCount() });
- stats.push({ key: "Types", value: program.getTypeCount() });
- stats.push({
- key: "Instantiations",
- value: program.getInstantiationCount(),
- });
- } else if (fileCount != null) {
- stats.push({ key: "Files", value: fileCount });
- }
- const programTime = ts.performance.getDuration("Program");
- const bindTime = ts.performance.getDuration("Bind");
- const checkTime = ts.performance.getDuration("Check");
- const emitTime = ts.performance.getDuration("Emit");
- stats.push({ key: "Parse time", value: programTime });
- stats.push({ key: "Bind time", value: bindTime });
- stats.push({ key: "Check time", value: checkTime });
- stats.push({ key: "Emit time", value: emitTime });
- stats.push({
- key: "Total TS time",
- value: programTime + bindTime + checkTime + emitTime,
- });
- }
-
- function performanceEnd() {
- // TODO(kitsonk) replace with performance.measure() when landed
- const duration = performance.now() - statsStart;
- stats.push({ key: "Compile time", value: duration });
- return stats;
- }
-
- // TODO(Bartlomieju): this check should be done in Rust; there should be no
- function processConfigureResponse(
- configResult,
- configPath,
- ) {
- const { ignoredOptions, diagnostics } = configResult;
- if (ignoredOptions) {
- console.warn(
- yellow(`Unsupported compiler options in "${configPath}"\n`) +
- cyan(` The following options were ignored:\n`) +
- ` ${ignoredOptions.map((value) => bold(value)).join(", ")}`,
- );
- }
- return diagnostics;
- }
-
- function normalizeString(path) {
- let res = "";
- let lastSegmentLength = 0;
- let lastSlash = -1;
- let dots = 0;
- let code;
- for (let i = 0, len = path.length; i <= len; ++i) {
- if (i < len) code = path.charCodeAt(i);
- else if (code === CHAR_FORWARD_SLASH) break;
- else code = CHAR_FORWARD_SLASH;
-
- if (code === CHAR_FORWARD_SLASH) {
- if (lastSlash === i - 1 || dots === 1) {
- // NOOP
- } else if (lastSlash !== i - 1 && dots === 2) {
- if (
- res.length < 2 ||
- lastSegmentLength !== 2 ||
- res.charCodeAt(res.length - 1) !== CHAR_DOT ||
- res.charCodeAt(res.length - 2) !== CHAR_DOT
- ) {
- if (res.length > 2) {
- const lastSlashIndex = res.lastIndexOf("/");
- if (lastSlashIndex === -1) {
- res = "";
- lastSegmentLength = 0;
- } else {
- res = res.slice(0, lastSlashIndex);
- lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
- }
- lastSlash = i;
- dots = 0;
- continue;
- } else if (res.length === 2 || res.length === 1) {
- res = "";
- lastSegmentLength = 0;
- lastSlash = i;
- dots = 0;
- continue;
- }
- }
- } else {
- if (res.length > 0) res += "/" + path.slice(lastSlash + 1, i);
- else res = path.slice(lastSlash + 1, i);
- lastSegmentLength = i - lastSlash - 1;
- }
- lastSlash = i;
- dots = 0;
- } else if (code === CHAR_DOT && dots !== -1) {
- ++dots;
- } else {
- dots = -1;
- }
- }
- return res;
- }
-
- function commonPath(paths, sep = "/") {
- const [first = "", ...remaining] = paths;
- if (first === "" || remaining.length === 0) {
- return first.substring(0, first.lastIndexOf(sep) + 1);
- }
- const parts = first.split(sep);
-
- let endOfPrefix = parts.length;
- for (const path of remaining) {
- const compare = path.split(sep);
- for (let i = 0; i < endOfPrefix; i++) {
- if (compare[i] !== parts[i]) {
- endOfPrefix = i;
- }
- }
-
- if (endOfPrefix === 0) {
- return "";
- }
- }
- const prefix = parts.slice(0, endOfPrefix).join(sep);
- return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
- }
-
- let rootExports;
-
- function normalizeUrl(rootName) {
- const match = /^(\S+:\/{2,3})(.+)$/.exec(rootName);
- if (match) {
- const [, protocol, path] = match;
- return `${protocol}${normalizeString(path)}`;
- } else {
- return rootName;
- }
- }
-
- function buildBundle(
- rootName,
- data,
- sourceFiles,
- target,
- ) {
- // when outputting to AMD and a single outfile, TypeScript makes up the module
- // specifiers which are used to define the modules, and doesn't expose them
- // publicly, so we have to try to replicate
- const sources = sourceFiles.map((sf) => sf.fileName);
- const sharedPath = commonPath(sources);
- rootName = normalizeUrl(rootName)
- .replace(sharedPath, "")
- .replace(/\.\w+$/i, "");
- // If one of the modules requires support for top-level-await, TypeScript will
- // emit the execute function as an async function. When this is the case we
- // need to bubble up the TLA to the instantiation, otherwise we instantiate
- // synchronously.
- const hasTla = data.match(/execute:\sasync\sfunction\s/);
- let instantiate;
- if (rootExports && rootExports.length) {
- instantiate = hasTla
- ? `const __exp = await __instantiate("${rootName}", true);\n`
- : `const __exp = __instantiate("${rootName}", false);\n`;
- for (const rootExport of rootExports) {
- if (rootExport === "default") {
- instantiate += `export default __exp["${rootExport}"];\n`;
- } else {
- instantiate +=
- `export const ${rootExport} = __exp["${rootExport}"];\n`;
- }
- }
- } else {
- instantiate = hasTla
- ? `await __instantiate("${rootName}", true);\n`
- : `__instantiate("${rootName}", false);\n`;
- }
- const es5Bundle = target === ts.ScriptTarget.ES3 ||
- target === ts.ScriptTarget.ES5 ||
- target === ts.ScriptTarget.ES2015 ||
- target === ts.ScriptTarget.ES2016;
- return `${
- es5Bundle ? SYSTEM_LOADER_ES5 : SYSTEM_LOADER
- }\n${data}\n${instantiate}`;
- }
-
- function setRootExports(program, rootModule) {
- // get a reference to the type checker, this will let us find symbols from
- // the AST.
- const checker = program.getTypeChecker();
- // get a reference to the main source file for the bundle
- const mainSourceFile = program.getSourceFile(rootModule);
- assert(mainSourceFile);
- // retrieve the internal TypeScript symbol for this AST node
- const mainSymbol = checker.getSymbolAtLocation(mainSourceFile);
- if (!mainSymbol) {
- return;
- }
- rootExports = checker
- .getExportsOfModule(mainSymbol)
- // .getExportsOfModule includes type only symbols which are exported from
- // the module, so we need to try to filter those out. While not critical
- // someone looking at the bundle would think there is runtime code behind
- // that when there isn't. There appears to be no clean way of figuring that
- // out, so inspecting SymbolFlags that might be present that are type only
- .filter(
- (sym) =>
- sym.flags & ts.SymbolFlags.Class ||
- !(
- sym.flags & ts.SymbolFlags.Interface ||
- sym.flags & ts.SymbolFlags.TypeLiteral ||
- sym.flags & ts.SymbolFlags.Signature ||
- sym.flags & ts.SymbolFlags.TypeParameter ||
- sym.flags & ts.SymbolFlags.TypeAlias ||
- sym.flags & ts.SymbolFlags.Type ||
- sym.flags & ts.SymbolFlags.Namespace ||
- sym.flags & ts.SymbolFlags.InterfaceExcludes ||
- sym.flags & ts.SymbolFlags.TypeParameterExcludes ||
- sym.flags & ts.SymbolFlags.TypeAliasExcludes
- ),
- )
- .map((sym) => sym.getName());
- }
-
- function compile({
- allowJs,
- buildInfo,
- config,
- configPath,
- rootNames,
- target,
- unstable,
- cwd,
- sourceFileMap,
- type,
- performance,
- }) {
- if (performance) {
- performanceStart();
- }
- log(">>> compile start", { rootNames, type: CompilerRequestType[type] });
-
- // When a programme is emitted, TypeScript will call `writeFile` with
- // each file that needs to be emitted. The Deno compiler host delegates
- // this, to make it easier to perform the right actions, which vary
- // based a lot on the request.
- const state = {
- rootNames,
- emitMap: {},
- };
- const host = new IncrementalCompileHost({
- bundle: false,
- target,
- unstable,
- writeFile: createCompileWriteFile(state),
- rootNames,
- buildInfo,
- });
- let diagnostics = [];
-
- host.mergeOptions({ allowJs });
-
- // if there is a configuration supplied, we need to parse that
- if (config && config.length && configPath) {
- const configResult = host.configure(cwd, configPath, config);
- diagnostics = processConfigureResponse(configResult, configPath) || [];
- }
-
- buildSourceFileCache(sourceFileMap);
- // if there was a configuration and no diagnostics with it, we will continue
- // to generate the program and possibly emit it.
- if (diagnostics.length === 0) {
- const options = host.getCompilationSettings();
- const program = ts.createIncrementalProgram({
- rootNames,
- options,
- host,
- });
-
- // TODO(bartlomieju): check if this is ok
- diagnostics = [
- ...program.getConfigFileParsingDiagnostics(),
- ...program.getSyntacticDiagnostics(),
- ...program.getOptionsDiagnostics(),
- ...program.getGlobalDiagnostics(),
- ...program.getSemanticDiagnostics(),
- ];
- diagnostics = diagnostics.filter(
- ({ code }) => !ignoredDiagnostics.includes(code),
- );
-
- // We will only proceed with the emit if there are no diagnostics.
- if (diagnostics.length === 0) {
- const emitResult = program.emit();
- // If `checkJs` is off we still might be compiling entry point JavaScript file
- // (if it has `.ts` imports), but it won't be emitted. In that case we skip
- // assertion.
- if (options.checkJs) {
- assert(
- emitResult.emitSkipped === false,
- "Unexpected skip of the emit.",
- );
- }
- // emitResult.diagnostics is `readonly` in TS3.5+ and can't be assigned
- // without casting.
- diagnostics = emitResult.diagnostics;
- }
- performanceProgram({ program });
- }
-
- log("<<< compile end", { rootNames, type: CompilerRequestType[type] });
- const stats = performance ? performanceEnd() : undefined;
-
- return {
- emitMap: state.emitMap,
- buildInfo: state.buildInfo,
- diagnostics: fromTypeScriptDiagnostic(diagnostics),
- stats,
- };
- }
-
- function transpile({
- config: configText,
- configPath,
- cwd,
- performance,
- sourceFiles,
- }) {
- if (performance) {
- performanceStart();
- }
- log(">>> transpile start");
- let compilerOptions;
- if (configText && configPath && cwd) {
- const { options, ...response } = configure(
- DEFAULT_TRANSPILE_OPTIONS,
- configText,
- configPath,
- cwd,
- );
- const diagnostics = processConfigureResponse(response, configPath);
- if (diagnostics && diagnostics.length) {
- return {
- diagnostics: fromTypeScriptDiagnostic(diagnostics),
- emitMap: {},
- };
- }
- compilerOptions = options;
- } else {
- compilerOptions = Object.assign({}, DEFAULT_TRANSPILE_OPTIONS);
- }
- const emitMap = {};
- let diagnostics = [];
- for (const { sourceCode, fileName } of sourceFiles) {
- const {
- outputText,
- sourceMapText,
- diagnostics: diags,
- } = ts.transpileModule(sourceCode, {
- fileName,
- compilerOptions,
- reportDiagnostics: true,
- });
- if (diags) {
- diagnostics = diagnostics.concat(...diags);
- }
- emitMap[`${fileName}.js`] = { filename: fileName, contents: outputText };
- // currently we inline source maps, but this is good logic to have if this
- // ever changes
- if (sourceMapText) {
- emitMap[`${fileName}.map`] = {
- filename: fileName,
- contents: sourceMapText,
- };
- }
- }
- performanceProgram({ fileCount: sourceFiles.length });
- const stats = performance ? performanceEnd() : undefined;
- log("<<< transpile end");
- return {
- diagnostics: fromTypeScriptDiagnostic(diagnostics),
- emitMap,
- stats,
- };
- }
-
- function bundle({
- config,
- configPath,
- rootNames,
- target,
- unstable,
- cwd,
- sourceFileMap,
- type,
- }) {
- if (performance) {
- performanceStart();
- }
- log(">>> bundle start", {
- rootNames,
- type: CompilerRequestType[type],
- });
-
- // When a programme is emitted, TypeScript will call `writeFile` with
- // each file that needs to be emitted. The Deno compiler host delegates
- // this, to make it easier to perform the right actions, which vary
- // based a lot on the request.
- const state = {
- rootNames,
- bundleOutput: undefined,
- };
- const host = new Host({
- bundle: true,
- target,
- unstable,
- writeFile: createBundleWriteFile(state),
- });
- state.host = host;
- let diagnostics = [];
-
- // if there is a configuration supplied, we need to parse that
- if (config && config.length && configPath) {
- const configResult = host.configure(cwd, configPath, config);
- diagnostics = processConfigureResponse(configResult, configPath) || [];
- }
-
- buildSourceFileCache(sourceFileMap);
- // if there was a configuration and no diagnostics with it, we will continue
- // to generate the program and possibly emit it.
- if (diagnostics.length === 0) {
- const options = host.getCompilationSettings();
- const program = ts.createProgram({
- rootNames,
- options,
- host,
- });
-
- diagnostics = ts
- .getPreEmitDiagnostics(program)
- .filter(({ code }) => !ignoredDiagnostics.includes(code));
-
- // We will only proceed with the emit if there are no diagnostics.
- if (diagnostics.length === 0) {
- // we only support a single root module when bundling
- assert(rootNames.length === 1);
- setRootExports(program, rootNames[0]);
- const emitResult = program.emit();
- assert(
- emitResult.emitSkipped === false,
- "Unexpected skip of the emit.",
- );
- // emitResult.diagnostics is `readonly` in TS3.5+ and can't be assigned
- // without casting.
- diagnostics = emitResult.diagnostics;
- }
- if (performance) {
- performanceProgram({ program });
- }
- }
-
- let bundleOutput;
-
- if (diagnostics.length === 0) {
- assert(state.bundleOutput);
- bundleOutput = state.bundleOutput;
- }
-
- const stats = performance ? performanceEnd() : undefined;
-
- const result = {
- bundleOutput,
- diagnostics: fromTypeScriptDiagnostic(diagnostics),
- stats,
- };
-
- log("<<< bundle end", {
- rootNames,
- type: CompilerRequestType[type],
- });
-
- return result;
- }
-
- function runtimeCompile(
- request,
- ) {
- const { options, rootNames, target, unstable, sourceFileMap } = request;
-
- log(">>> runtime compile start", {
- rootNames,
- });
-
- // if there are options, convert them into TypeScript compiler options,
- // and resolve any external file references
- let convertedOptions;
- if (options) {
- const result = convertCompilerOptions(options);
- convertedOptions = result.options;
- }
-
- buildLocalSourceFileCache(sourceFileMap);
-
- const state = {
- rootNames,
- emitMap: {},
- };
- const host = new Host({
- bundle: false,
- target,
- writeFile: createRuntimeCompileWriteFile(state),
- });
- const compilerOptions = [DEFAULT_RUNTIME_COMPILE_OPTIONS];
- if (convertedOptions) {
- compilerOptions.push(convertedOptions);
- }
- if (unstable) {
- compilerOptions.push({
- lib: [
- "deno.unstable",
- ...((convertedOptions && convertedOptions.lib) || ["deno.window"]),
- ],
- });
- }
-
- host.mergeOptions(...compilerOptions);
-
- const program = ts.createProgram({
- rootNames,
- options: host.getCompilationSettings(),
- host,
- });
-
- const diagnostics = ts
- .getPreEmitDiagnostics(program)
- .filter(({ code }) => !ignoredDiagnostics.includes(code));
-
- const emitResult = program.emit();
-
- assert(emitResult.emitSkipped === false, "Unexpected skip of the emit.");
-
- log("<<< runtime compile finish", {
- rootNames,
- emitMap: Object.keys(state.emitMap),
- });
-
- const maybeDiagnostics = diagnostics.length
- ? fromTypeScriptDiagnostic(diagnostics).items
- : [];
-
- return {
- diagnostics: maybeDiagnostics,
- emitMap: state.emitMap,
- };
- }
-
- function runtimeBundle(request) {
- const { options, rootNames, target, unstable, sourceFileMap } = request;
-
- log(">>> runtime bundle start", {
- rootNames,
- });
-
- // if there are options, convert them into TypeScript compiler options,
- // and resolve any external file references
- let convertedOptions;
- if (options) {
- const result = convertCompilerOptions(options);
- convertedOptions = result.options;
- }
-
- buildLocalSourceFileCache(sourceFileMap);
-
- const state = {
- rootNames,
- bundleOutput: undefined,
- };
- const host = new Host({
- bundle: true,
- target,
- writeFile: createBundleWriteFile(state),
- });
- state.host = host;
-
- const compilerOptions = [DEFAULT_RUNTIME_COMPILE_OPTIONS];
- if (convertedOptions) {
- compilerOptions.push(convertedOptions);
- }
- if (unstable) {
- compilerOptions.push({
- lib: [
- "deno.unstable",
- ...((convertedOptions && convertedOptions.lib) || ["deno.window"]),
- ],
- });
- }
- compilerOptions.push(DEFAULT_BUNDLER_OPTIONS);
- host.mergeOptions(...compilerOptions);
-
- const program = ts.createProgram({
- rootNames,
- options: host.getCompilationSettings(),
- host,
- });
-
- setRootExports(program, rootNames[0]);
- const diagnostics = ts
- .getPreEmitDiagnostics(program)
- .filter(({ code }) => !ignoredDiagnostics.includes(code));
-
- const emitResult = program.emit();
-
- assert(emitResult.emitSkipped === false, "Unexpected skip of the emit.");
-
- log("<<< runtime bundle finish", {
- rootNames,
- });
-
- const maybeDiagnostics = diagnostics.length
- ? fromTypeScriptDiagnostic(diagnostics).items
- : [];
-
- return {
- diagnostics: maybeDiagnostics,
- output: state.bundleOutput,
- };
- }
-
- function runtimeTranspile(
- request,
- ) {
- const result = {};
- const { sources, options } = request;
- const compilerOptions = options
- ? Object.assign(
- {},
- DEFAULT_RUNTIME_TRANSPILE_OPTIONS,
- convertCompilerOptions(options).options,
- )
- : DEFAULT_RUNTIME_TRANSPILE_OPTIONS;
-
- for (const [fileName, inputText] of Object.entries(sources)) {
- const { outputText: source, sourceMapText: map } = ts.transpileModule(
- inputText,
- {
- fileName,
- compilerOptions,
- },
- );
- result[fileName] = { source, map };
- }
- return Promise.resolve(result);
- }
-
- async function tsCompilerOnMessage({
- data: request,
- }) {
- switch (request.type) {
- case CompilerRequestType.Compile: {
- const result = compile(request);
- globalThis.postMessage(result);
- break;
- }
- case CompilerRequestType.Transpile: {
- const result = transpile(request);
- globalThis.postMessage(result);
- break;
- }
- case CompilerRequestType.Bundle: {
- const result = bundle(request);
- globalThis.postMessage(result);
- break;
- }
- case CompilerRequestType.RuntimeCompile: {
- const result = runtimeCompile(request);
- globalThis.postMessage(result);
- break;
- }
- case CompilerRequestType.RuntimeBundle: {
- const result = runtimeBundle(request);
- globalThis.postMessage(result);
- break;
- }
- case CompilerRequestType.RuntimeTranspile: {
- const result = await runtimeTranspile(request);
- globalThis.postMessage(result);
- break;
- }
- default:
- log(
- `!!! unhandled CompilerRequestType: ${request.type} (${
- CompilerRequestType[request.type]
- })`,
- );
- }
- // Shutdown after single request
- globalThis.close();
- }
-
- function bootstrapTsCompilerRuntime() {
- globalThis.bootstrap.workerRuntime("TS", false);
- globalThis.onmessage = tsCompilerOnMessage;
- }
-
- Object.defineProperties(globalThis, {
- bootstrap: {
- value: {
- ...globalThis.bootstrap,
- tsCompilerRuntime: bootstrapTsCompilerRuntime,
- },
- configurable: true,
- writable: true,
- },
- });
-})(this);
diff --git a/cli/js2/lib.deno.ns.d.ts b/cli/js2/lib.deno.ns.d.ts
deleted file mode 100644
index 962179381..000000000
--- a/cli/js2/lib.deno.ns.d.ts
+++ /dev/null
@@ -1,2028 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-
-/// <reference no-default-lib="true" />
-/// <reference lib="esnext" />
-
-/** Deno provides extra properties on `import.meta`. These are included here
- * to ensure that these are still available when using the Deno namepsace in
- * conjunction with other type libs, like `dom`. */
-declare interface ImportMeta {
- /** A string representation of the fully qualified module URL. */
- url: string;
-
- /** A flag that indicates if the current module is the main module that was
- * called when starting the program under Deno.
- *
- * ```ts
- * if (import.meta.main) {
- * // this was loaded as the main module, maybe do some bootstrapping
- * }
- * ```
- */
- main: boolean;
-}
-
-/** Deno supports user timing Level 3 (see: https://w3c.github.io/user-timing)
- * which is not widely supported yet in other runtimes. These types are here
- * so that these features are still available when using the Deno namespace
- * in conjunction with other type libs, like `dom`. */
-declare interface Performance {
- /** Stores a timestamp with the associated name (a "mark"). */
- mark(markName: string, options?: PerformanceMarkOptions): PerformanceMark;
-
- /** Stores the `DOMHighResTimeStamp` duration between two marks along with the
- * associated name (a "measure"). */
- measure(
- measureName: string,
- options?: PerformanceMeasureOptions,
- ): PerformanceMeasure;
-}
-
-declare interface PerformanceMarkOptions {
- /** Metadata to be included in the mark. */
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- detail?: any;
-
- /** Timestamp to be used as the mark time. */
- startTime?: number;
-}
-
-declare interface PerformanceMeasureOptions {
- /** Metadata to be included in the measure. */
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- detail?: any;
-
- /** Timestamp to be used as the start time or string to be used as start
- * mark.*/
- start?: string | number;
-
- /** Duration between the start and end times. */
- duration?: number;
-
- /** Timestamp to be used as the end time or string to be used as end mark. */
- end?: string | number;
-}
-
-declare namespace Deno {
- /** A set of error constructors that are raised by Deno APIs. */
- export const errors: {
- NotFound: ErrorConstructor;
- PermissionDenied: ErrorConstructor;
- ConnectionRefused: ErrorConstructor;
- ConnectionReset: ErrorConstructor;
- ConnectionAborted: ErrorConstructor;
- NotConnected: ErrorConstructor;
- AddrInUse: ErrorConstructor;
- AddrNotAvailable: ErrorConstructor;
- BrokenPipe: ErrorConstructor;
- AlreadyExists: ErrorConstructor;
- InvalidData: ErrorConstructor;
- TimedOut: ErrorConstructor;
- Interrupted: ErrorConstructor;
- WriteZero: ErrorConstructor;
- UnexpectedEof: ErrorConstructor;
- BadResource: ErrorConstructor;
- Http: ErrorConstructor;
- Busy: ErrorConstructor;
- };
-
- /** The current process id of the runtime. */
- export const pid: number;
-
- /** Reflects the `NO_COLOR` environment variable.
- *
- * See: https://no-color.org/ */
- export const noColor: boolean;
-
- export interface TestDefinition {
- fn: () => void | Promise<void>;
- name: string;
- ignore?: boolean;
- /** If at lease one test has `only` set to true, only run tests that have
- * `only` set to true and fail the test suite. */
- only?: boolean;
- /** Check that the number of async completed ops after the test is the same
- * as number of dispatched ops. Defaults to true.*/
- sanitizeOps?: boolean;
- /** Ensure the test case does not "leak" resources - ie. the resource table
- * after the test has exactly the same contents as before the test. Defaults
- * to true. */
- sanitizeResources?: boolean;
- }
-
- /** Register a test which will be run when `deno test` is used on the command
- * line and the containing module looks like a test module.
- * `fn` can be async if required.
- * ```ts
- * import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
- *
- * Deno.test({
- * name: "example test",
- * fn(): void {
- * assertEquals("world", "world");
- * },
- * });
- *
- * Deno.test({
- * name: "example ignored test",
- * ignore: Deno.build.os === "windows",
- * fn(): void {
- * // This test is ignored only on Windows machines
- * },
- * });
- *
- * Deno.test({
- * name: "example async test",
- * async fn() {
- * const decoder = new TextDecoder("utf-8");
- * const data = await Deno.readFile("hello_world.txt");
- * assertEquals(decoder.decode(data), "Hello world");
- * }
- * });
- * ```
- */
- export function test(t: TestDefinition): void;
-
- /** Register a test which will be run when `deno test` is used on the command
- * line and the containing module looks like a test module.
- * `fn` can be async if required.
- *
- * ```ts
- * import {assert, fail, assertEquals} from "https://deno.land/std/testing/asserts.ts";
- *
- * Deno.test("My test description", ():void => {
- * assertEquals("hello", "hello");
- * });
- *
- * Deno.test("My async test description", async ():Promise<void> => {
- * const decoder = new TextDecoder("utf-8");
- * const data = await Deno.readFile("hello_world.txt");
- * assertEquals(decoder.decode(data), "Hello world");
- * });
- * ```
- * */
- export function test(name: string, fn: () => void | Promise<void>): void;
-
- /** Exit the Deno process with optional exit code. If no exit code is supplied
- * then Deno will exit with return code of 0.
- *
- * ```ts
- * Deno.exit(5);
- * ```
- */
- export function exit(code?: number): never;
-
- export const env: {
- /** Retrieve the value of an environment variable. Returns undefined if that
- * key doesn't exist.
- *
- * ```ts
- * console.log(Deno.env.get("HOME")); // e.g. outputs "/home/alice"
- * console.log(Deno.env.get("MADE_UP_VAR")); // outputs "Undefined"
- * ```
- * Requires `allow-env` permission. */
- get(key: string): string | undefined;
-
- /** Set the value of an environment variable.
- *
- * ```ts
- * Deno.env.set("SOME_VAR", "Value"));
- * Deno.env.get("SOME_VAR"); // outputs "Value"
- * ```
- *
- * Requires `allow-env` permission. */
- set(key: string, value: string): void;
-
- /** Delete the value of an environment variable.
- *
- * ```ts
- * Deno.env.set("SOME_VAR", "Value"));
- * Deno.env.delete("SOME_VAR"); // outputs "Undefined"
- * ```
- *
- * Requires `allow-env` permission. */
- delete(key: string): void;
-
- /** Returns a snapshot of the environment variables at invocation.
- *
- * ```ts
- * Deno.env.set("TEST_VAR", "A");
- * const myEnv = Deno.env.toObject();
- * console.log(myEnv.SHELL);
- * Deno.env.set("TEST_VAR", "B");
- * console.log(myEnv.TEST_VAR); // outputs "A"
- * ```
- *
- * Requires `allow-env` permission. */
- toObject(): { [index: string]: string };
- };
-
- /**
- * Returns the path to the current deno executable.
- *
- * ```ts
- * console.log(Deno.execPath()); // e.g. "/home/alice/.local/bin/deno"
- * ```
- *
- * Requires `allow-read` permission.
- */
- export function execPath(): string;
-
- /**
- * Change the current working directory to the specified path.
- *
- * ```ts
- * Deno.chdir("/home/userA");
- * Deno.chdir("../userB");
- * Deno.chdir("C:\\Program Files (x86)\\Java");
- * ```
- *
- * Throws `Deno.errors.NotFound` if directory not found.
- * Throws `Deno.errors.PermissionDenied` if the user does not have access
- * rights
- *
- * Requires --allow-read.
- */
- export function chdir(directory: string): void;
-
- /**
- * Return a string representing the current working directory.
- *
- * If the current directory can be reached via multiple paths (due to symbolic
- * links), `cwd()` may return any one of them.
- *
- * ```ts
- * const currentWorkingDirectory = Deno.cwd();
- * ```
- *
- * Throws `Deno.errors.NotFound` if directory not available.
- *
- * Requires --allow-read
- */
- export function cwd(): string;
-
- export enum SeekMode {
- Start = 0,
- Current = 1,
- End = 2,
- }
-
- export interface Reader {
- /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
- * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
- * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
- * use all of `p` as scratch space during the call. If some data is
- * available but not `p.byteLength` bytes, `read()` conventionally resolves
- * to what is available instead of waiting for more.
- *
- * When `read()` encounters end-of-file condition, it resolves to EOF
- * (`null`).
- *
- * When `read()` encounters an error, it rejects with an error.
- *
- * Callers should always process the `n` > `0` bytes returned before
- * considering the EOF (`null`). Doing so correctly handles I/O errors that
- * happen after reading some bytes and also both of the allowed EOF
- * behaviors.
- *
- * Implementations should not retain a reference to `p`.
- *
- * Use Deno.iter() to turn a Reader into an AsyncIterator.
- */
- read(p: Uint8Array): Promise<number | null>;
- }
-
- export interface ReaderSync {
- /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
- * of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
- * encountered. Even if `read()` returns `n` < `p.byteLength`, it may use
- * all of `p` as scratch space during the call. If some data is available
- * but not `p.byteLength` bytes, `read()` conventionally returns what is
- * available instead of waiting for more.
- *
- * When `readSync()` encounters end-of-file condition, it returns EOF
- * (`null`).
- *
- * When `readSync()` encounters an error, it throws with an error.
- *
- * Callers should always process the `n` > `0` bytes returned before
- * considering the EOF (`null`). Doing so correctly handles I/O errors that happen
- * after reading some bytes and also both of the allowed EOF behaviors.
- *
- * Implementations should not retain a reference to `p`.
- *
- * Use Deno.iterSync() to turn a ReaderSync into an Iterator.
- */
- readSync(p: Uint8Array): number | null;
- }
-
- export interface Writer {
- /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
- * resolves to the number of bytes written from `p` (`0` <= `n` <=
- * `p.byteLength`) or reject with the error encountered that caused the
- * write to stop early. `write()` must reject with a non-null error if
- * would resolve to `n` < `p.byteLength`. `write()` must not modify the
- * slice data, even temporarily.
- *
- * Implementations should not retain a reference to `p`.
- */
- write(p: Uint8Array): Promise<number>;
- }
-
- export interface WriterSync {
- /** Writes `p.byteLength` bytes from `p` to the underlying data
- * stream. It returns the number of bytes written from `p` (`0` <= `n`
- * <= `p.byteLength`) and any error encountered that caused the write to
- * stop early. `writeSync()` must throw a non-null error if it returns `n` <
- * `p.byteLength`. `writeSync()` must not modify the slice data, even
- * temporarily.
- *
- * Implementations should not retain a reference to `p`.
- */
- writeSync(p: Uint8Array): number;
- }
-
- export interface Closer {
- close(): void;
- }
-
- export interface Seeker {
- /** Seek sets the offset for the next `read()` or `write()` to offset,
- * interpreted according to `whence`: `Start` means relative to the
- * start of the file, `Current` means relative to the current offset,
- * and `End` means relative to the end. Seek resolves to the new offset
- * relative to the start of the file.
- *
- * Seeking to an offset before the start of the file is an error. Seeking to
- * any positive offset is legal, but the behavior of subsequent I/O
- * operations on the underlying object is implementation-dependent.
- * It returns the number of cursor position.
- */
- seek(offset: number, whence: SeekMode): Promise<number>;
- }
-
- export interface SeekerSync {
- /** Seek sets the offset for the next `readSync()` or `writeSync()` to
- * offset, interpreted according to `whence`: `Start` means relative
- * to the start of the file, `Current` means relative to the current
- * offset, and `End` means relative to the end.
- *
- * Seeking to an offset before the start of the file is an error. Seeking to
- * any positive offset is legal, but the behavior of subsequent I/O
- * operations on the underlying object is implementation-dependent.
- */
- seekSync(offset: number, whence: SeekMode): number;
- }
-
- /** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or
- * an error occurs. It resolves to the number of bytes copied or rejects with
- * the first error encountered while copying.
- *
- * ```ts
- * const source = await Deno.open("my_file.txt");
- * const buffer = new Deno.Buffer()
- * const bytesCopied1 = await Deno.copy(source, Deno.stdout);
- * const bytesCopied2 = await Deno.copy(source, buffer);
- * ```
- *
- * @param src The source to copy from
- * @param dst The destination to copy to
- * @param options Can be used to tune size of the buffer. Default size is 32kB
- */
- export function copy(
- src: Reader,
- dst: Writer,
- options?: {
- bufSize?: number;
- },
- ): Promise<number>;
-
- /** Turns a Reader, `r`, into an async iterator.
- *
- * ```ts
- * let f = await Deno.open("/etc/passwd");
- * for await (const chunk of Deno.iter(f)) {
- * console.log(chunk);
- * }
- * f.close();
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * ```ts
- * let f = await Deno.open("/etc/passwd");
- * const iter = Deno.iter(f, {
- * bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- * console.log(chunk);
- * }
- * f.close();
- * ```
- *
- * Iterator uses an internal buffer of fixed size for efficiency; it returns
- * a view on that buffer on each iteration. It is therefore caller's
- * responsibility to copy contents of the buffer if needed; otherwise the
- * next iteration will overwrite contents of previously returned chunk.
- */
- export function iter(
- r: Reader,
- options?: {
- bufSize?: number;
- },
- ): AsyncIterableIterator<Uint8Array>;
-
- /** Turns a ReaderSync, `r`, into an iterator.
- *
- * ```ts
- * let f = Deno.openSync("/etc/passwd");
- * for (const chunk of Deno.iterSync(f)) {
- * console.log(chunk);
- * }
- * f.close();
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * ```ts
- * let f = await Deno.open("/etc/passwd");
- * const iter = Deno.iterSync(f, {
- * bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- * console.log(chunk);
- * }
- * f.close();
- * ```
- *
- * Iterator uses an internal buffer of fixed size for efficiency; it returns
- * a view on that buffer on each iteration. It is therefore caller's
- * responsibility to copy contents of the buffer if needed; otherwise the
- * next iteration will overwrite contents of previously returned chunk.
- */
- export function iterSync(
- r: ReaderSync,
- options?: {
- bufSize?: number;
- },
- ): IterableIterator<Uint8Array>;
-
- /** Synchronously open a file and return an instance of `Deno.File`. The
- * file does not need to previously exist if using the `create` or `createNew`
- * open options. It is the callers responsibility to close the file when finished
- * with it.
- *
- * ```ts
- * const file = Deno.openSync("/foo/bar.txt", { read: true, write: true });
- * // Do work with file
- * Deno.close(file.rid);
- * ```
- *
- * Requires `allow-read` and/or `allow-write` permissions depending on options.
- */
- export function openSync(path: string | URL, options?: OpenOptions): File;
-
- /** Open a file and resolve to an instance of `Deno.File`. The
- * file does not need to previously exist if using the `create` or `createNew`
- * open options. It is the callers responsibility to close the file when finished
- * with it.
- *
- * ```ts
- * const file = await Deno.open("/foo/bar.txt", { read: true, write: true });
- * // Do work with file
- * Deno.close(file.rid);
- * ```
- *
- * Requires `allow-read` and/or `allow-write` permissions depending on options.
- */
- export function open(
- path: string | URL,
- options?: OpenOptions,
- ): Promise<File>;
-
- /** Creates a file if none exists or truncates an existing file and returns
- * an instance of `Deno.File`.
- *
- * ```ts
- * const file = Deno.createSync("/foo/bar.txt");
- * ```
- *
- * Requires `allow-read` and `allow-write` permissions.
- */
- export function createSync(path: string | URL): File;
-
- /** Creates a file if none exists or truncates an existing file and resolves to
- * an instance of `Deno.File`.
- *
- * ```ts
- * const file = await Deno.create("/foo/bar.txt");
- * ```
- *
- * Requires `allow-read` and `allow-write` permissions.
- */
- export function create(path: string | URL): Promise<File>;
-
- /** Synchronously read from a resource ID (`rid`) into an array buffer (`buffer`).
- *
- * Returns either the number of bytes read during the operation or EOF
- * (`null`) if there was nothing more to read.
- *
- * It is possible for a read to successfully return with `0` bytes. This does
- * not indicate EOF.
- *
- * This function is one of the lowest level APIs and most users should not
- * work with this directly, but rather use Deno.readAllSync() instead.
- *
- * **It is not guaranteed that the full buffer will be read in a single call.**
- *
- * ```ts
- * // if "/foo/bar.txt" contains the text "hello world":
- * const file = Deno.openSync("/foo/bar.txt");
- * const buf = new Uint8Array(100);
- * const numberOfBytesRead = Deno.readSync(file.rid, buf); // 11 bytes
- * const text = new TextDecoder().decode(buf); // "hello world"
- * Deno.close(file.rid);
- * ```
- */
- export function readSync(rid: number, buffer: Uint8Array): number | null;
-
- /** Read from a resource ID (`rid`) into an array buffer (`buffer`).
- *
- * Resolves to either the number of bytes read during the operation or EOF
- * (`null`) if there was nothing more to read.
- *
- * It is possible for a read to successfully return with `0` bytes. This does
- * not indicate EOF.
- *
- * This function is one of the lowest level APIs and most users should not
- * work with this directly, but rather use Deno.readAll() instead.
- *
- * **It is not guaranteed that the full buffer will be read in a single call.**
- *
- * ```ts
- * // if "/foo/bar.txt" contains the text "hello world":
- * const file = await Deno.open("/foo/bar.txt");
- * const buf = new Uint8Array(100);
- * const numberOfBytesRead = await Deno.read(file.rid, buf); // 11 bytes
- * const text = new TextDecoder().decode(buf); // "hello world"
- * Deno.close(file.rid);
- * ```
- */
- export function read(rid: number, buffer: Uint8Array): Promise<number | null>;
-
- /** Synchronously write to the resource ID (`rid`) the contents of the array
- * buffer (`data`).
- *
- * Returns the number of bytes written. This function is one of the lowest
- * level APIs and most users should not work with this directly, but rather use
- * Deno.writeAllSync() instead.
- *
- * **It is not guaranteed that the full buffer will be written in a single
- * call.**
- *
- * ```ts
- * const encoder = new TextEncoder();
- * const data = encoder.encode("Hello world");
- * const file = Deno.openSync("/foo/bar.txt", {write: true});
- * const bytesWritten = Deno.writeSync(file.rid, data); // 11
- * Deno.close(file.rid);
- * ```
- */
- export function writeSync(rid: number, data: Uint8Array): number;
-
- /** Write to the resource ID (`rid`) the contents of the array buffer (`data`).
- *
- * Resolves to the number of bytes written. This function is one of the lowest
- * level APIs and most users should not work with this directly, but rather use
- * Deno.writeAll() instead.
- *
- * **It is not guaranteed that the full buffer will be written in a single
- * call.**
- *
- * ```ts
- * const encoder = new TextEncoder();
- * const data = encoder.encode("Hello world");
- * const file = await Deno.open("/foo/bar.txt", { write: true });
- * const bytesWritten = await Deno.write(file.rid, data); // 11
- * Deno.close(file.rid);
- * ```
- */
- export function write(rid: number, data: Uint8Array): Promise<number>;
-
- /** Synchronously seek a resource ID (`rid`) to the given `offset` under mode
- * given by `whence`. The new position within the resource (bytes from the
- * start) is returned.
- *
- * ```ts
- * const file = Deno.openSync('hello.txt', {read: true, write: true, truncate: true, create: true});
- * Deno.writeSync(file.rid, new TextEncoder().encode("Hello world"));
- * // advance cursor 6 bytes
- * const cursorPosition = Deno.seekSync(file.rid, 6, Deno.SeekMode.Start);
- * console.log(cursorPosition); // 6
- * const buf = new Uint8Array(100);
- * file.readSync(buf);
- * console.log(new TextDecoder().decode(buf)); // "world"
- * ```
- *
- * The seek modes work as follows:
- *
- * ```ts
- * // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
- * // Seek 6 bytes from the start of the file
- * console.log(Deno.seekSync(file.rid, 6, Deno.SeekMode.Start)); // "6"
- * // Seek 2 more bytes from the current position
- * console.log(Deno.seekSync(file.rid, 2, Deno.SeekMode.Current)); // "8"
- * // Seek backwards 2 bytes from the end of the file
- * console.log(Deno.seekSync(file.rid, -2, Deno.SeekMode.End)); // "9" (e.g. 11-2)
- * ```
- */
- export function seekSync(
- rid: number,
- offset: number,
- whence: SeekMode,
- ): number;
-
- /** Seek a resource ID (`rid`) to the given `offset` under mode given by `whence`.
- * The call resolves to the new position within the resource (bytes from the start).
- *
- * ```ts
- * const file = await Deno.open('hello.txt', {read: true, write: true, truncate: true, create: true});
- * await Deno.write(file.rid, new TextEncoder().encode("Hello world"));
- * // advance cursor 6 bytes
- * const cursorPosition = await Deno.seek(file.rid, 6, Deno.SeekMode.Start);
- * console.log(cursorPosition); // 6
- * const buf = new Uint8Array(100);
- * await file.read(buf);
- * console.log(new TextDecoder().decode(buf)); // "world"
- * ```
- *
- * The seek modes work as follows:
- *
- * ```ts
- * // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
- * // Seek 6 bytes from the start of the file
- * console.log(await Deno.seek(file.rid, 6, Deno.SeekMode.Start)); // "6"
- * // Seek 2 more bytes from the current position
- * console.log(await Deno.seek(file.rid, 2, Deno.SeekMode.Current)); // "8"
- * // Seek backwards 2 bytes from the end of the file
- * console.log(await Deno.seek(file.rid, -2, Deno.SeekMode.End)); // "9" (e.g. 11-2)
- * ```
- */
- export function seek(
- rid: number,
- offset: number,
- whence: SeekMode,
- ): Promise<number>;
-
- /** Close the given resource ID (rid) which has been previously opened, such
- * as via opening or creating a file. Closing a file when you are finished
- * with it is important to avoid leaking resources.
- *
- * ```ts
- * const file = await Deno.open("my_file.txt");
- * // do work with "file" object
- * Deno.close(file.rid);
- * ````
- */
- export function close(rid: number): void;
-
- /** The Deno abstraction for reading and writing files. */
- export class File
- implements
- Reader,
- ReaderSync,
- Writer,
- WriterSync,
- Seeker,
- SeekerSync,
- Closer {
- readonly rid: number;
- constructor(rid: number);
- write(p: Uint8Array): Promise<number>;
- writeSync(p: Uint8Array): number;
- read(p: Uint8Array): Promise<number | null>;
- readSync(p: Uint8Array): number | null;
- seek(offset: number, whence: SeekMode): Promise<number>;
- seekSync(offset: number, whence: SeekMode): number;
- close(): void;
- }
-
- /** A handle for `stdin`. */
- export const stdin: Reader & ReaderSync & Closer & { rid: number };
- /** A handle for `stdout`. */
- export const stdout: Writer & WriterSync & Closer & { rid: number };
- /** A handle for `stderr`. */
- export const stderr: Writer & WriterSync & Closer & { rid: number };
-
- export interface OpenOptions {
- /** Sets the option for read access. This option, when `true`, means that the
- * file should be read-able if opened. */
- read?: boolean;
- /** Sets the option for write access. This option, when `true`, means that
- * the file should be write-able if opened. If the file already exists,
- * any write calls on it will overwrite its contents, by default without
- * truncating it. */
- write?: boolean;
- /**Sets the option for the append mode. This option, when `true`, means that
- * writes will append to a file instead of overwriting previous contents.
- * Note that setting `{ write: true, append: true }` has the same effect as
- * setting only `{ append: true }`. */
- append?: boolean;
- /** Sets the option for truncating a previous file. If a file is
- * successfully opened with this option set it will truncate the file to `0`
- * size if it already exists. The file must be opened with write access
- * for truncate to work. */
- truncate?: boolean;
- /** Sets the option to allow creating a new file, if one doesn't already
- * exist at the specified path. Requires write or append access to be
- * used. */
- create?: boolean;
- /** Defaults to `false`. If set to `true`, no file, directory, or symlink is
- * allowed to exist at the target location. Requires write or append
- * access to be used. When createNew is set to `true`, create and truncate
- * are ignored. */
- createNew?: boolean;
- /** Permissions to use if creating the file (defaults to `0o666`, before
- * the process's umask).
- * Ignored on Windows. */
- mode?: number;
- }
-
- /**
- *
- * Check if a given resource id (`rid`) is a TTY.
- *
- * ```ts
- * // This example is system and context specific
- * const nonTTYRid = Deno.openSync("my_file.txt").rid;
- * const ttyRid = Deno.openSync("/dev/tty6").rid;
- * console.log(Deno.isatty(nonTTYRid)); // false
- * console.log(Deno.isatty(ttyRid)); // true
- * Deno.close(nonTTYRid);
- * Deno.close(ttyRid);
- * ```
- */
- export function isatty(rid: number): boolean;
-
- /** A variable-sized buffer of bytes with `read()` and `write()` methods.
- *
- * Deno.Buffer is almost always used with some I/O like files and sockets. It
- * allows one to buffer up a download from a socket. Buffer grows and shrinks
- * as necessary.
- *
- * Deno.Buffer is NOT the same thing as Node's Buffer. Node's Buffer was
- * created in 2009 before JavaScript had the concept of ArrayBuffers. It's
- * simply a non-standard ArrayBuffer.
- *
- * ArrayBuffer is a fixed memory allocation. Deno.Buffer is implemented on top
- * of ArrayBuffer.
- *
- * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */
- export class Buffer implements Reader, ReaderSync, Writer, WriterSync {
- constructor(ab?: ArrayBuffer);
- /** Returns a slice holding the unread portion of the buffer.
- *
- * The slice is valid for use only until the next buffer modification (that
- * is, only until the next call to a method like `read()`, `write()`,
- * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at
- * least until the next buffer modification, so immediate changes to the
- * slice will affect the result of future reads.
- * @param options Defaults to `{ copy: true }`
- */
- bytes(options?: { copy?: boolean }): Uint8Array;
- /** Returns whether the unread portion of the buffer is empty. */
- empty(): boolean;
- /** A read only number of bytes of the unread portion of the buffer. */
- readonly length: number;
- /** The read only capacity of the buffer's underlying byte slice, that is,
- * the total space allocated for the buffer's data. */
- readonly capacity: number;
- /** Discards all but the first `n` unread bytes from the buffer but
- * continues to use the same allocated storage. It throws if `n` is
- * negative or greater than the length of the buffer. */
- truncate(n: number): void;
- /** Resets the buffer to be empty, but it retains the underlying storage for
- * use by future writes. `.reset()` is the same as `.truncate(0)`. */
- reset(): void;
- /** Reads the next `p.length` bytes from the buffer or until the buffer is
- * drained. Returns the number of bytes read. If the buffer has no data to
- * return, the return is EOF (`null`). */
- readSync(p: Uint8Array): number | null;
- /** Reads the next `p.length` bytes from the buffer or until the buffer is
- * drained. Resolves to the number of bytes read. If the buffer has no
- * data to return, resolves to EOF (`null`).
- *
- * NOTE: This methods reads bytes sychronously; it's provided for
- * compatibility with `Reader` interfaces.
- */
- read(p: Uint8Array): Promise<number | null>;
- writeSync(p: Uint8Array): number;
- /** NOTE: This methods writes bytes sychronously; it's provided for
- * compatibility with `Writer` interface. */
- write(p: Uint8Array): Promise<number>;
- /** Grows the buffer's capacity, if necessary, to guarantee space for
- * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
- * the buffer without another allocation. If `n` is negative, `.grow()` will
- * throw. If the buffer can't grow it will throw an error.
- *
- * Based on Go Lang's
- * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */
- grow(n: number): void;
- /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
- * growing the buffer as needed. It resolves to the number of bytes read.
- * If the buffer becomes too large, `.readFrom()` will reject with an error.
- *
- * Based on Go Lang's
- * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
- readFrom(r: Reader): Promise<number>;
- /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
- * growing the buffer as needed. It returns the number of bytes read. If the
- * buffer becomes too large, `.readFromSync()` will throw an error.
- *
- * Based on Go Lang's
- * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
- readFromSync(r: ReaderSync): number;
- }
-
- /** Read Reader `r` until EOF (`null`) and resolve to the content as
- * Uint8Array`.
- *
- * ```ts
- * // Example from stdin
- * const stdinContent = await Deno.readAll(Deno.stdin);
- *
- * // Example from file
- * const file = await Deno.open("my_file.txt", {read: true});
- * const myFileContent = await Deno.readAll(file);
- * Deno.close(file.rid);
- *
- * // Example from buffer
- * const myData = new Uint8Array(100);
- * // ... fill myData array with data
- * const reader = new Deno.Buffer(myData.buffer as ArrayBuffer);
- * const bufferContent = await Deno.readAll(reader);
- * ```
- */
- export function readAll(r: Reader): Promise<Uint8Array>;
-
- /** Synchronously reads Reader `r` until EOF (`null`) and returns the content
- * as `Uint8Array`.
- *
- * ```ts
- * // Example from stdin
- * const stdinContent = Deno.readAllSync(Deno.stdin);
- *
- * // Example from file
- * const file = Deno.openSync("my_file.txt", {read: true});
- * const myFileContent = Deno.readAllSync(file);
- * Deno.close(file.rid);
- *
- * // Example from buffer
- * const myData = new Uint8Array(100);
- * // ... fill myData array with data
- * const reader = new Deno.Buffer(myData.buffer as ArrayBuffer);
- * const bufferContent = Deno.readAllSync(reader);
- * ```
- */
- export function readAllSync(r: ReaderSync): Uint8Array;
-
- /** Write all the content of the array buffer (`arr`) to the writer (`w`).
- *
- * ```ts
- * // Example writing to stdout
- * const contentBytes = new TextEncoder().encode("Hello World");
- * await Deno.writeAll(Deno.stdout, contentBytes);
- *
- * // Example writing to file
- * const contentBytes = new TextEncoder().encode("Hello World");
- * const file = await Deno.open('test.file', {write: true});
- * await Deno.writeAll(file, contentBytes);
- * Deno.close(file.rid);
- *
- * // Example writing to buffer
- * const contentBytes = new TextEncoder().encode("Hello World");
- * const writer = new Deno.Buffer();
- * await Deno.writeAll(writer, contentBytes);
- * console.log(writer.bytes().length); // 11
- * ```
- */
- export function writeAll(w: Writer, arr: Uint8Array): Promise<void>;
-
- /** Synchronously write all the content of the array buffer (`arr`) to the
- * writer (`w`).
- *
- * ```ts
- * // Example writing to stdout
- * const contentBytes = new TextEncoder().encode("Hello World");
- * Deno.writeAllSync(Deno.stdout, contentBytes);
- *
- * // Example writing to file
- * const contentBytes = new TextEncoder().encode("Hello World");
- * const file = Deno.openSync('test.file', {write: true});
- * Deno.writeAllSync(file, contentBytes);
- * Deno.close(file.rid);
- *
- * // Example writing to buffer
- * const contentBytes = new TextEncoder().encode("Hello World");
- * const writer = new Deno.Buffer();
- * Deno.writeAllSync(writer, contentBytes);
- * console.log(writer.bytes().length); // 11
- * ```
- */
- export function writeAllSync(w: WriterSync, arr: Uint8Array): void;
-
- export interface MkdirOptions {
- /** Defaults to `false`. If set to `true`, means that any intermediate
- * directories will also be created (as with the shell command `mkdir -p`).
- * Intermediate directories are created with the same permissions.
- * When recursive is set to `true`, succeeds silently (without changing any
- * permissions) if a directory already exists at the path, or if the path
- * is a symlink to an existing directory. */
- recursive?: boolean;
- /** Permissions to use when creating the directory (defaults to `0o777`,
- * before the process's umask).
- * Ignored on Windows. */
- mode?: number;
- }
-
- /** Synchronously creates a new directory with the specified path.
- *
- * ```ts
- * Deno.mkdirSync("new_dir");
- * Deno.mkdirSync("nested/directories", { recursive: true });
- * Deno.mkdirSync("restricted_access_dir", { mode: 0o700 });
- * ```
- *
- * Defaults to throwing error if the directory already exists.
- *
- * Requires `allow-write` permission. */
- export function mkdirSync(path: string | URL, options?: MkdirOptions): void;
-
- /** Creates a new directory with the specified path.
- *
- * ```ts
- * await Deno.mkdir("new_dir");
- * await Deno.mkdir("nested/directories", { recursive: true });
- * await Deno.mkdir("restricted_access_dir", { mode: 0o700 });
- * ```
- *
- * Defaults to throwing error if the directory already exists.
- *
- * Requires `allow-write` permission. */
- export function mkdir(
- path: string | URL,
- options?: MkdirOptions,
- ): Promise<void>;
-
- export interface MakeTempOptions {
- /** Directory where the temporary directory should be created (defaults to
- * the env variable TMPDIR, or the system's default, usually /tmp).
- *
- * Note that if the passed `dir` is relative, the path returned by
- * makeTempFile() and makeTempDir() will also be relative. Be mindful of
- * this when changing working directory. */
- dir?: string;
- /** String that should precede the random portion of the temporary
- * directory's name. */
- prefix?: string;
- /** String that should follow the random portion of the temporary
- * directory's name. */
- suffix?: string;
- }
-
- /** Synchronously creates a new temporary directory in the default directory
- * for temporary files (see also `Deno.dir("temp")`), unless `dir` is specified.
- * Other optional options include prefixing and suffixing the directory name
- * with `prefix` and `suffix` respectively.
- *
- * The full path to the newly created directory is returned.
- *
- * Multiple programs calling this function simultaneously will create different
- * directories. It is the caller's responsibility to remove the directory when
- * no longer needed.
- *
- * ```ts
- * const tempDirName0 = Deno.makeTempDirSync(); // e.g. /tmp/2894ea76
- * const tempDirName1 = Deno.makeTempDirSync({ prefix: 'my_temp' }); // e.g. /tmp/my_temp339c944d
- * ```
- *
- * Requires `allow-write` permission. */
- // TODO(ry) Doesn't check permissions.
- export function makeTempDirSync(options?: MakeTempOptions): string;
-
- /** Creates a new temporary directory in the default directory for temporary
- * files (see also `Deno.dir("temp")`), unless `dir` is specified. Other
- * optional options include prefixing and suffixing the directory name with
- * `prefix` and `suffix` respectively.
- *
- * This call resolves to the full path to the newly created directory.
- *
- * Multiple programs calling this function simultaneously will create different
- * directories. It is the caller's responsibility to remove the directory when
- * no longer needed.
- *
- * ```ts
- * const tempDirName0 = await Deno.makeTempDir(); // e.g. /tmp/2894ea76
- * const tempDirName1 = await Deno.makeTempDir({ prefix: 'my_temp' }); // e.g. /tmp/my_temp339c944d
- * ```
- *
- * Requires `allow-write` permission. */
- // TODO(ry) Doesn't check permissions.
- export function makeTempDir(options?: MakeTempOptions): Promise<string>;
-
- /** Synchronously creates a new temporary file in the default directory for
- * temporary files (see also `Deno.dir("temp")`), unless `dir` is specified.
- * Other optional options include prefixing and suffixing the directory name
- * with `prefix` and `suffix` respectively.
- *
- * The full path to the newly created file is returned.
- *
- * Multiple programs calling this function simultaneously will create different
- * files. It is the caller's responsibility to remove the file when no longer
- * needed.
- *
- * ```ts
- * const tempFileName0 = Deno.makeTempFileSync(); // e.g. /tmp/419e0bf2
- * const tempFileName1 = Deno.makeTempFileSync({ prefix: 'my_temp' }); // e.g. /tmp/my_temp754d3098
- * ```
- *
- * Requires `allow-write` permission. */
- export function makeTempFileSync(options?: MakeTempOptions): string;
-
- /** Creates a new temporary file in the default directory for temporary
- * files (see also `Deno.dir("temp")`), unless `dir` is specified. Other
- * optional options include prefixing and suffixing the directory name with
- * `prefix` and `suffix` respectively.
- *
- * This call resolves to the full path to the newly created file.
- *
- * Multiple programs calling this function simultaneously will create different
- * files. It is the caller's responsibility to remove the file when no longer
- * needed.
- *
- * ```ts
- * const tmpFileName0 = await Deno.makeTempFile(); // e.g. /tmp/419e0bf2
- * const tmpFileName1 = await Deno.makeTempFile({ prefix: 'my_temp' }); // e.g. /tmp/my_temp754d3098
- * ```
- *
- * Requires `allow-write` permission. */
- export function makeTempFile(options?: MakeTempOptions): Promise<string>;
-
- /** Synchronously changes the permission of a specific file/directory of
- * specified path. Ignores the process's umask.
- *
- * ```ts
- * Deno.chmodSync("/path/to/file", 0o666);
- * ```
- *
- * For a full description, see [chmod](#chmod)
- *
- * NOTE: This API currently throws on Windows
- *
- * Requires `allow-write` permission. */
- export function chmodSync(path: string | URL, mode: number): void;
-
- /** Changes the permission of a specific file/directory of specified path.
- * Ignores the process's umask.
- *
- * ```ts
- * await Deno.chmod("/path/to/file", 0o666);
- * ```
- *
- * The mode is a sequence of 3 octal numbers. The first/left-most number
- * specifies the permissions for the owner. The second number specifies the
- * permissions for the group. The last/right-most number specifies the
- * permissions for others. For example, with a mode of 0o764, the owner (7) can
- * read/write/execute, the group (6) can read/write and everyone else (4) can
- * read only.
- *
- * | Number | Description |
- * | ------ | ----------- |
- * | 7 | read, write, and execute |
- * | 6 | read and write |
- * | 5 | read and execute |
- * | 4 | read only |
- * | 3 | write and execute |
- * | 2 | write only |
- * | 1 | execute only |
- * | 0 | no permission |
- *
- * NOTE: This API currently throws on Windows
- *
- * Requires `allow-write` permission. */
- export function chmod(path: string | URL, mode: number): Promise<void>;
-
- /** Synchronously change owner of a regular file or directory. This functionality
- * is not available on Windows.
- *
- * ```ts
- * Deno.chownSync("myFile.txt", 1000, 1002);
- * ```
- *
- * Requires `allow-write` permission.
- *
- * Throws Error (not implemented) if executed on Windows
- *
- * @param path path to the file
- * @param uid user id (UID) of the new owner, or `null` for no change
- * @param gid group id (GID) of the new owner, or `null` for no change
- */
- export function chownSync(
- path: string | URL,
- uid: number | null,
- gid: number | null,
- ): void;
-
- /** Change owner of a regular file or directory. This functionality
- * is not available on Windows.
- *
- * ```ts
- * await Deno.chown("myFile.txt", 1000, 1002);
- * ```
- *
- * Requires `allow-write` permission.
- *
- * Throws Error (not implemented) if executed on Windows
- *
- * @param path path to the file
- * @param uid user id (UID) of the new owner, or `null` for no change
- * @param gid group id (GID) of the new owner, or `null` for no change
- */
- export function chown(
- path: string | URL,
- uid: number | null,
- gid: number | null,
- ): Promise<void>;
-
- export interface RemoveOptions {
- /** Defaults to `false`. If set to `true`, path will be removed even if
- * it's a non-empty directory. */
- recursive?: boolean;
- }
-
- /** Synchronously removes the named file or directory.
- *
- * ```ts
- * Deno.removeSync("/path/to/empty_dir/or/file");
- * Deno.removeSync("/path/to/populated_dir/or/file", { recursive: true });
- * ```
- *
- * Throws error if permission denied, path not found, or path is a non-empty
- * directory and the `recursive` option isn't set to `true`.
- *
- * Requires `allow-write` permission. */
- export function removeSync(path: string | URL, options?: RemoveOptions): void;
-
- /** Removes the named file or directory.
- *
- * ```ts
- * await Deno.remove("/path/to/empty_dir/or/file");
- * await Deno.remove("/path/to/populated_dir/or/file", { recursive: true });
- * ```
- *
- * Throws error if permission denied, path not found, or path is a non-empty
- * directory and the `recursive` option isn't set to `true`.
- *
- * Requires `allow-write` permission. */
- export function remove(
- path: string | URL,
- options?: RemoveOptions,
- ): Promise<void>;
-
- /** Synchronously renames (moves) `oldpath` to `newpath`. Paths may be files or
- * directories. If `newpath` already exists and is not a directory,
- * `renameSync()` replaces it. OS-specific restrictions may apply when
- * `oldpath` and `newpath` are in different directories.
- *
- * ```ts
- * Deno.renameSync("old/path", "new/path");
- * ```
- *
- * On Unix, this operation does not follow symlinks at either path.
- *
- * It varies between platforms when the operation throws errors, and if so what
- * they are. It's always an error to rename anything to a non-empty directory.
- *
- * Requires `allow-read` and `allow-write` permissions. */
- export function renameSync(oldpath: string, newpath: string): void;
-
- /** Renames (moves) `oldpath` to `newpath`. Paths may be files or directories.
- * If `newpath` already exists and is not a directory, `rename()` replaces it.
- * OS-specific restrictions may apply when `oldpath` and `newpath` are in
- * different directories.
- *
- * ```ts
- * await Deno.rename("old/path", "new/path");
- * ```
- *
- * On Unix, this operation does not follow symlinks at either path.
- *
- * It varies between platforms when the operation throws errors, and if so what
- * they are. It's always an error to rename anything to a non-empty directory.
- *
- * Requires `allow-read` and `allow-write` permission. */
- export function rename(oldpath: string, newpath: string): Promise<void>;
-
- /** Synchronously reads and returns the entire contents of a file as utf8 encoded string
- * encoded string. Reading a directory returns an empty string.
- *
- * ```ts
- * const data = Deno.readTextFileSync("hello.txt");
- * console.log(data);
- * ```
- *
- * Requires `allow-read` permission. */
- export function readTextFileSync(path: string | URL): string;
-
- /** Asynchronously reads and returns the entire contents of a file as a utf8
- * encoded string. Reading a directory returns an empty data array.
- *
- * ```ts
- * const data = await Deno.readTextFile("hello.txt");
- * console.log(data);
- * ```
- *
- * Requires `allow-read` permission. */
- export function readTextFile(path: string | URL): Promise<string>;
-
- /** Synchronously reads and returns the entire contents of a file as an array
- * of bytes. `TextDecoder` can be used to transform the bytes to string if
- * required. Reading a directory returns an empty data array.
- *
- * ```ts
- * const decoder = new TextDecoder("utf-8");
- * const data = Deno.readFileSync("hello.txt");
- * console.log(decoder.decode(data));
- * ```
- *
- * Requires `allow-read` permission. */
- export function readFileSync(path: string | URL): Uint8Array;
-
- /** Reads and resolves to the entire contents of a file as an array of bytes.
- * `TextDecoder` can be used to transform the bytes to string if required.
- * Reading a directory returns an empty data array.
- *
- * ```ts
- * const decoder = new TextDecoder("utf-8");
- * const data = await Deno.readFile("hello.txt");
- * console.log(decoder.decode(data));
- * ```
- *
- * Requires `allow-read` permission. */
- export function readFile(path: string | URL): Promise<Uint8Array>;
-
- /** A FileInfo describes a file and is returned by `stat`, `lstat`,
- * `statSync`, `lstatSync`. */
- export interface FileInfo {
- /** True if this is info for a regular file. Mutually exclusive to
- * `FileInfo.isDirectory` and `FileInfo.isSymlink`. */
- isFile: boolean;
- /** True if this is info for a regular directory. Mutually exclusive to
- * `FileInfo.isFile` and `FileInfo.isSymlink`. */
- isDirectory: boolean;
- /** True if this is info for a symlink. Mutually exclusive to
- * `FileInfo.isFile` and `FileInfo.isDirectory`. */
- isSymlink: boolean;
- /** The size of the file, in bytes. */
- size: number;
- /** The last modification time of the file. This corresponds to the `mtime`
- * field from `stat` on Linux/Mac OS and `ftLastWriteTime` on Windows. This
- * may not be available on all platforms. */
- mtime: Date | null;
- /** The last access time of the file. This corresponds to the `atime`
- * field from `stat` on Unix and `ftLastAccessTime` on Windows. This may not
- * be available on all platforms. */
- atime: Date | null;
- /** The creation time of the file. This corresponds to the `birthtime`
- * field from `stat` on Mac/BSD and `ftCreationTime` on Windows. This may
- * not be available on all platforms. */
- birthtime: Date | null;
- /** ID of the device containing the file.
- *
- * _Linux/Mac OS only._ */
- dev: number | null;
- /** Inode number.
- *
- * _Linux/Mac OS only._ */
- ino: number | null;
- /** **UNSTABLE**: Match behavior with Go on Windows for `mode`.
- *
- * The underlying raw `st_mode` bits that contain the standard Unix
- * permissions for this file/directory. */
- mode: number | null;
- /** Number of hard links pointing to this file.
- *
- * _Linux/Mac OS only._ */
- nlink: number | null;
- /** User ID of the owner of this file.
- *
- * _Linux/Mac OS only._ */
- uid: number | null;
- /** Group ID of the owner of this file.
- *
- * _Linux/Mac OS only._ */
- gid: number | null;
- /** Device ID of this file.
- *
- * _Linux/Mac OS only._ */
- rdev: number | null;
- /** Blocksize for filesystem I/O.
- *
- * _Linux/Mac OS only._ */
- blksize: number | null;
- /** Number of blocks allocated to the file, in 512-byte units.
- *
- * _Linux/Mac OS only._ */
- blocks: number | null;
- }
-
- /** Returns absolute normalized path, with symbolic links resolved.
- *
- * ```ts
- * // e.g. given /home/alice/file.txt and current directory /home/alice
- * Deno.symlinkSync("file.txt", "symlink_file.txt");
- * const realPath = Deno.realPathSync("./file.txt");
- * const realSymLinkPath = Deno.realPathSync("./symlink_file.txt");
- * console.log(realPath); // outputs "/home/alice/file.txt"
- * console.log(realSymLinkPath); // outputs "/home/alice/file.txt"
- * ```
- *
- * Requires `allow-read` permission for the target path.
- * Also requires `allow-read` permission for the CWD if the target path is
- * relative.*/
- export function realPathSync(path: string): string;
-
- /** Resolves to the absolute normalized path, with symbolic links resolved.
- *
- * ```ts
- * // e.g. given /home/alice/file.txt and current directory /home/alice
- * await Deno.symlink("file.txt", "symlink_file.txt");
- * const realPath = await Deno.realPath("./file.txt");
- * const realSymLinkPath = await Deno.realPath("./symlink_file.txt");
- * console.log(realPath); // outputs "/home/alice/file.txt"
- * console.log(realSymLinkPath); // outputs "/home/alice/file.txt"
- * ```
- *
- * Requires `allow-read` permission for the target path.
- * Also requires `allow-read` permission for the CWD if the target path is
- * relative.*/
- export function realPath(path: string): Promise<string>;
-
- export interface DirEntry {
- name: string;
- isFile: boolean;
- isDirectory: boolean;
- isSymlink: boolean;
- }
-
- /** Synchronously reads the directory given by `path` and returns an iterable
- * of `Deno.DirEntry`.
- *
- * ```ts
- * for (const dirEntry of Deno.readDirSync("/")) {
- * console.log(dirEntry.name);
- * }
- * ```
- *
- * Throws error if `path` is not a directory.
- *
- * Requires `allow-read` permission. */
- export function readDirSync(path: string | URL): Iterable<DirEntry>;
-
- /** Reads the directory given by `path` and returns an async iterable of
- * `Deno.DirEntry`.
- *
- * ```ts
- * for await (const dirEntry of Deno.readDir("/")) {
- * console.log(dirEntry.name);
- * }
- * ```
- *
- * Throws error if `path` is not a directory.
- *
- * Requires `allow-read` permission. */
- export function readDir(path: string | URL): AsyncIterable<DirEntry>;
-
- /** Synchronously copies the contents and permissions of one file to another
- * specified path, by default creating a new file if needed, else overwriting.
- * Fails if target path is a directory or is unwritable.
- *
- * ```ts
- * Deno.copyFileSync("from.txt", "to.txt");
- * ```
- *
- * Requires `allow-read` permission on fromPath.
- * Requires `allow-write` permission on toPath. */
- export function copyFileSync(
- fromPath: string | URL,
- toPath: string | URL,
- ): void;
-
- /** Copies the contents and permissions of one file to another specified path,
- * by default creating a new file if needed, else overwriting. Fails if target
- * path is a directory or is unwritable.
- *
- * ```ts
- * await Deno.copyFile("from.txt", "to.txt");
- * ```
- *
- * Requires `allow-read` permission on fromPath.
- * Requires `allow-write` permission on toPath. */
- export function copyFile(
- fromPath: string | URL,
- toPath: string | URL,
- ): Promise<void>;
-
- /** Returns the full path destination of the named symbolic link.
- *
- * ```ts
- * Deno.symlinkSync("./test.txt", "./test_link.txt");
- * const target = Deno.readLinkSync("./test_link.txt"); // full path of ./test.txt
- * ```
- *
- * Throws TypeError if called with a hard link
- *
- * Requires `allow-read` permission. */
- export function readLinkSync(path: string): string;
-
- /** Resolves to the full path destination of the named symbolic link.
- *
- * ```ts
- * await Deno.symlink("./test.txt", "./test_link.txt");
- * const target = await Deno.readLink("./test_link.txt"); // full path of ./test.txt
- * ```
- *
- * Throws TypeError if called with a hard link
- *
- * Requires `allow-read` permission. */
- export function readLink(path: string): Promise<string>;
-
- /** Resolves to a `Deno.FileInfo` for the specified `path`. If `path` is a
- * symlink, information for the symlink will be returned instead of what it
- * points to.
- *
- * ```ts
- * import { assert } from "https://deno.land/std/testing/asserts.ts";
- * const fileInfo = await Deno.lstat("hello.txt");
- * assert(fileInfo.isFile);
- * ```
- *
- * Requires `allow-read` permission. */
- export function lstat(path: string | URL): Promise<FileInfo>;
-
- /** Synchronously returns a `Deno.FileInfo` for the specified `path`. If
- * `path` is a symlink, information for the symlink will be returned instead of
- * what it points to..
- *
- * ```ts
- * const fileInfo = Deno.lstatSync("hello.txt");
- * assert(fileInfo.isFile);
- * ```
- *
- * Requires `allow-read` permission. */
- export function lstatSync(path: string | URL): FileInfo;
-
- /** Resolves to a `Deno.FileInfo` for the specified `path`. Will always
- * follow symlinks.
- *
- * ```ts
- * import { assert } from "https://deno.land/std/testing/asserts.ts";
- * const fileInfo = await Deno.stat("hello.txt");
- * assert(fileInfo.isFile);
- * ```
- *
- * Requires `allow-read` permission. */
- export function stat(path: string | URL): Promise<FileInfo>;
-
- /** Synchronously returns a `Deno.FileInfo` for the specified `path`. Will
- * always follow symlinks.
- *
- * ```ts
- * import { assert } from "https://deno.land/std/testing/asserts.ts";
- * const fileInfo = Deno.statSync("hello.txt");
- * assert(fileInfo.isFile);
- * ```
- *
- * Requires `allow-read` permission. */
- export function statSync(path: string | URL): FileInfo;
-
- /** Options for writing to a file. */
- export interface WriteFileOptions {
- /** Defaults to `false`. If set to `true`, will append to a file instead of
- * overwriting previous contents. */
- append?: boolean;
- /** Sets the option to allow creating a new file, if one doesn't already
- * exist at the specified path (defaults to `true`). */
- create?: boolean;
- /** Permissions always applied to file. */
- mode?: number;
- }
-
- /** Synchronously write `data` to the given `path`, by default creating a new
- * file if needed, else overwriting.
- *
- * ```ts
- * const encoder = new TextEncoder();
- * const data = encoder.encode("Hello world\n");
- * Deno.writeFileSync("hello1.txt", data); // overwrite "hello1.txt" or create it
- * Deno.writeFileSync("hello2.txt", data, {create: false}); // only works if "hello2.txt" exists
- * Deno.writeFileSync("hello3.txt", data, {mode: 0o777}); // set permissions on new file
- * Deno.writeFileSync("hello4.txt", data, {append: true}); // add data to the end of the file
- * ```
- *
- * Requires `allow-write` permission, and `allow-read` if `options.create` is
- * `false`.
- */
- export function writeFileSync(
- path: string | URL,
- data: Uint8Array,
- options?: WriteFileOptions,
- ): void;
-
- /** Write `data` to the given `path`, by default creating a new file if needed,
- * else overwriting.
- *
- * ```ts
- * const encoder = new TextEncoder();
- * const data = encoder.encode("Hello world\n");
- * await Deno.writeFile("hello1.txt", data); // overwrite "hello1.txt" or create it
- * await Deno.writeFile("hello2.txt", data, {create: false}); // only works if "hello2.txt" exists
- * await Deno.writeFile("hello3.txt", data, {mode: 0o777}); // set permissions on new file
- * await Deno.writeFile("hello4.txt", data, {append: true}); // add data to the end of the file
- * ```
- *
- * Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
- */
- export function writeFile(
- path: string | URL,
- data: Uint8Array,
- options?: WriteFileOptions,
- ): Promise<void>;
-
- /** Synchronously write string `data` to the given `path`, by default creating a new file if needed,
- * else overwriting.
- *
- * ```ts
- * await Deno.writeTextFileSync("hello1.txt", "Hello world\n"); // overwrite "hello1.txt" or create it
- * ```
- *
- * Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
- */
- export function writeTextFileSync(
- path: string | URL,
- data: string,
- options?: WriteFileOptions,
- ): void;
-
- /** Asynchronously write string `data` to the given `path`, by default creating a new file if needed,
- * else overwriting.
- *
- * ```ts
- * await Deno.writeTextFile("hello1.txt", "Hello world\n"); // overwrite "hello1.txt" or create it
- * ```
- *
- * Requires `allow-write` permission, and `allow-read` if `options.create` is `false`.
- */
- export function writeTextFile(
- path: string | URL,
- data: string,
- options?: WriteFileOptions,
- ): Promise<void>;
-
- /** Synchronously truncates or extends the specified file, to reach the
- * specified `len`. If `len` is not specified then the entire file contents
- * are truncated.
- *
- * ```ts
- * // truncate the entire file
- * Deno.truncateSync("my_file.txt");
- *
- * // truncate part of the file
- * const file = Deno.makeTempFileSync();
- * Deno.writeFileSync(file, new TextEncoder().encode("Hello World"));
- * Deno.truncateSync(file, 7);
- * const data = Deno.readFileSync(file);
- * console.log(new TextDecoder().decode(data));
- * ```
- *
- * Requires `allow-write` permission. */
- export function truncateSync(name: string, len?: number): void;
-
- /** Truncates or extends the specified file, to reach the specified `len`. If
- * `len` is not specified then the entire file contents are truncated.
- *
- * ```ts
- * // truncate the entire file
- * await Deno.truncate("my_file.txt");
- *
- * // truncate part of the file
- * const file = await Deno.makeTempFile();
- * await Deno.writeFile(file, new TextEncoder().encode("Hello World"));
- * await Deno.truncate(file, 7);
- * const data = await Deno.readFile(file);
- * console.log(new TextDecoder().decode(data)); // "Hello W"
- * ```
- *
- * Requires `allow-write` permission. */
- export function truncate(name: string, len?: number): Promise<void>;
-
- export interface NetAddr {
- transport: "tcp" | "udp";
- hostname: string;
- port: number;
- }
-
- export interface UnixAddr {
- transport: "unix" | "unixpacket";
- path: string;
- }
-
- export type Addr = NetAddr | UnixAddr;
-
- /** A generic network listener for stream-oriented protocols. */
- export interface Listener extends AsyncIterable<Conn> {
- /** Waits for and resolves to the next connection to the `Listener`. */
- accept(): Promise<Conn>;
- /** Close closes the listener. Any pending accept promises will be rejected
- * with errors. */
- close(): void;
- /** Return the address of the `Listener`. */
- readonly addr: Addr;
-
- /** Return the rid of the `Listener`. */
- readonly rid: number;
-
- [Symbol.asyncIterator](): AsyncIterableIterator<Conn>;
- }
-
- export interface Conn extends Reader, Writer, Closer {
- /** The local address of the connection. */
- readonly localAddr: Addr;
- /** The remote address of the connection. */
- readonly remoteAddr: Addr;
- /** The resource ID of the connection. */
- readonly rid: number;
- /** Shuts down (`shutdown(2)`) the writing side of the TCP connection. Most
- * callers should just use `close()`.
- *
- * **Unstable** because of lack of testing and because Deno.shutdown is also
- * unstable.
- * */
- closeWrite(): void;
- }
-
- export interface ListenOptions {
- /** The port to listen on. */
- port: number;
- /** A literal IP address or host name that can be resolved to an IP address.
- * If not specified, defaults to `0.0.0.0`. */
- hostname?: string;
- }
-
- /** Listen announces on the local transport address.
- *
- * ```ts
- * const listener1 = Deno.listen({ port: 80 })
- * const listener2 = Deno.listen({ hostname: "192.0.2.1", port: 80 })
- * const listener3 = Deno.listen({ hostname: "[2001:db8::1]", port: 80 });
- * const listener4 = Deno.listen({ hostname: "golang.org", port: 80, transport: "tcp" });
- * ```
- *
- * Requires `allow-net` permission. */
- export function listen(
- options: ListenOptions & { transport?: "tcp" },
- ): Listener;
-
- export interface ListenTlsOptions extends ListenOptions {
- /** Server certificate file. */
- certFile: string;
- /** Server public key file. */
- keyFile: string;
-
- transport?: "tcp";
- }
-
- /** Listen announces on the local transport address over TLS (transport layer
- * security).
- *
- * ```ts
- * const lstnr = Deno.listenTls({ port: 443, certFile: "./server.crt", keyFile: "./server.key" });
- * ```
- *
- * Requires `allow-net` permission. */
- export function listenTls(options: ListenTlsOptions): Listener;
-
- export interface ConnectOptions {
- /** The port to connect to. */
- port: number;
- /** A literal IP address or host name that can be resolved to an IP address.
- * If not specified, defaults to `127.0.0.1`. */
- hostname?: string;
- transport?: "tcp";
- }
-
- /**
- * Connects to the hostname (default is "127.0.0.1") and port on the named
- * transport (default is "tcp"), and resolves to the connection (`Conn`).
- *
- * ```ts
- * const conn1 = await Deno.connect({ port: 80 });
- * const conn2 = await Deno.connect({ hostname: "192.0.2.1", port: 80 });
- * const conn3 = await Deno.connect({ hostname: "[2001:db8::1]", port: 80 });
- * const conn4 = await Deno.connect({ hostname: "golang.org", port: 80, transport: "tcp" });
- * ```
- *
- * Requires `allow-net` permission for "tcp". */
- export function connect(options: ConnectOptions): Promise<Conn>;
-
- export interface ConnectTlsOptions {
- /** The port to connect to. */
- port: number;
- /** A literal IP address or host name that can be resolved to an IP address.
- * If not specified, defaults to `127.0.0.1`. */
- hostname?: string;
- /** Server certificate file. */
- certFile?: string;
- }
-
- /** Establishes a secure connection over TLS (transport layer security) using
- * an optional cert file, hostname (default is "127.0.0.1") and port. The
- * cert file is optional and if not included Mozilla's root certificates will
- * be used (see also https://github.com/ctz/webpki-roots for specifics)
- *
- * ```ts
- * const conn1 = await Deno.connectTls({ port: 80 });
- * const conn2 = await Deno.connectTls({ certFile: "./certs/my_custom_root_CA.pem", hostname: "192.0.2.1", port: 80 });
- * const conn3 = await Deno.connectTls({ hostname: "[2001:db8::1]", port: 80 });
- * const conn4 = await Deno.connectTls({ certFile: "./certs/my_custom_root_CA.pem", hostname: "golang.org", port: 80});
- * ```
- *
- * Requires `allow-net` permission.
- */
- export function connectTls(options: ConnectTlsOptions): Promise<Conn>;
-
- export interface Metrics {
- opsDispatched: number;
- opsDispatchedSync: number;
- opsDispatchedAsync: number;
- opsDispatchedAsyncUnref: number;
- opsCompleted: number;
- opsCompletedSync: number;
- opsCompletedAsync: number;
- opsCompletedAsyncUnref: number;
- bytesSentControl: number;
- bytesSentData: number;
- bytesReceived: number;
- }
-
- /** Receive metrics from the privileged side of Deno. This is primarily used
- * in the development of Deno. 'Ops', also called 'bindings', are the go-between
- * between Deno JavaScript and Deno Rust.
- *
- * > console.table(Deno.metrics())
- * ┌─────────────────────────┬────────┐
- * │ (index) │ Values │
- * ├─────────────────────────┼────────┤
- * │ opsDispatched │ 3 │
- * │ opsDispatchedSync │ 2 │
- * │ opsDispatchedAsync │ 1 │
- * │ opsDispatchedAsyncUnref │ 0 │
- * │ opsCompleted │ 3 │
- * │ opsCompletedSync │ 2 │
- * │ opsCompletedAsync │ 1 │
- * │ opsCompletedAsyncUnref │ 0 │
- * │ bytesSentControl │ 73 │
- * │ bytesSentData │ 0 │
- * │ bytesReceived │ 375 │
- * └─────────────────────────┴────────┘
- */
- export function metrics(): Metrics;
-
- interface ResourceMap {
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- [rid: number]: any;
- }
-
- /** Returns a map of open resource ids (rid) along with their string
- * representations. This is an internal API and as such resource
- * representation has `any` type; that means it can change any time.
- *
- * ```ts
- * console.log(Deno.resources());
- * // { 0: "stdin", 1: "stdout", 2: "stderr" }
- * Deno.openSync('../test.file');
- * console.log(Deno.resources());
- * // { 0: "stdin", 1: "stdout", 2: "stderr", 3: "fsFile" }
- * ```
- */
- export function resources(): ResourceMap;
-
- export interface FsEvent {
- kind: "any" | "access" | "create" | "modify" | "remove";
- paths: string[];
- }
-
- /** Watch for file system events against one or more `paths`, which can be files
- * or directories. These paths must exist already. One user action (e.g.
- * `touch test.file`) can generate multiple file system events. Likewise,
- * one user action can result in multiple file paths in one event (e.g. `mv
- * old_name.txt new_name.txt`). Recursive option is `true` by default and,
- * for directories, will watch the specified directory and all sub directories.
- * Note that the exact ordering of the events can vary between operating systems.
- *
- * ```ts
- * const watcher = Deno.watchFs("/");
- * for await (const event of watcher) {
- * console.log(">>>> event", event);
- * // { kind: "create", paths: [ "/foo.txt" ] }
- * }
- *```
- *
- * Requires `allow-read` permission.
- */
- export function watchFs(
- paths: string | string[],
- options?: { recursive: boolean },
- ): AsyncIterableIterator<FsEvent>;
-
- export class Process<T extends RunOptions = RunOptions> {
- readonly rid: number;
- readonly pid: number;
- readonly stdin: T["stdin"] extends "piped" ? Writer & Closer
- : (Writer & Closer) | null;
- readonly stdout: T["stdout"] extends "piped" ? Reader & Closer
- : (Reader & Closer) | null;
- readonly stderr: T["stderr"] extends "piped" ? Reader & Closer
- : (Reader & Closer) | null;
- /** Resolves to the current status of the process. */
- status(): Promise<ProcessStatus>;
- /** Buffer the stdout until EOF and return it as `Uint8Array`.
- *
- * You must set stdout to `"piped"` when creating the process.
- *
- * This calls `close()` on stdout after its done. */
- output(): Promise<Uint8Array>;
- /** Buffer the stderr until EOF and return it as `Uint8Array`.
- *
- * You must set stderr to `"piped"` when creating the process.
- *
- * This calls `close()` on stderr after its done. */
- stderrOutput(): Promise<Uint8Array>;
- close(): void;
-
- /** **UNSTABLE**: The `signo` argument may change to require the Deno.Signal
- * enum.
- *
- * Send a signal to process. This functionality currently only works on
- * Linux and Mac OS.
- */
- kill(signo: number): void;
- }
-
- export type ProcessStatus =
- | {
- success: true;
- code: 0;
- signal?: undefined;
- }
- | {
- success: false;
- code: number;
- signal?: number;
- };
-
- export interface RunOptions {
- /** Arguments to pass. Note, the first element needs to be a path to the
- * binary */
- cmd: string[];
- cwd?: string;
- env?: {
- [key: string]: string;
- };
- stdout?: "inherit" | "piped" | "null" | number;
- stderr?: "inherit" | "piped" | "null" | number;
- stdin?: "inherit" | "piped" | "null" | number;
- }
-
- /** Spawns new subprocess. RunOptions must contain at a minimum the `opt.cmd`,
- * an array of program arguments, the first of which is the binary.
- *
- * ```ts
- * const p = Deno.run({
- * cmd: ["echo", "hello"],
- * });
- * ```
- *
- * Subprocess uses same working directory as parent process unless `opt.cwd`
- * is specified.
- *
- * Environmental variables for subprocess can be specified using `opt.env`
- * mapping.
- *
- * By default subprocess inherits stdio of parent process. To change that
- * `opt.stdout`, `opt.stderr` and `opt.stdin` can be specified independently -
- * they can be set to either an rid of open file or set to "inherit" "piped"
- * or "null":
- *
- * `"inherit"` The default if unspecified. The child inherits from the
- * corresponding parent descriptor.
- *
- * `"piped"` A new pipe should be arranged to connect the parent and child
- * sub-processes.
- *
- * `"null"` This stream will be ignored. This is the equivalent of attaching
- * the stream to `/dev/null`.
- *
- * Details of the spawned process are returned.
- *
- * Requires `allow-run` permission. */
- export function run<T extends RunOptions = RunOptions>(opt: T): Process<T>;
-
- export interface InspectOptions {
- /** Traversal depth for nested objects. Defaults to 4. */
- depth?: number;
- /** Sort Object, Set and Map entries by key. Defaults to false. */
- sorted?: boolean;
- /** Add a trailing comma for multiline collections. Defaults to false. */
- trailingComma?: boolean;
- /** Try to fit more than one entry of a collection on the same line.
- * Defaults to true. */
- compact?: boolean;
- /** The maximum number of iterable entries to print. Defaults to 100. */
- iterableLimit?: number;
- }
-
- /** Converts the input into a string that has the same format as printed by
- * `console.log()`.
- *
- * ```ts
- * const obj = {};
- * obj.propA = 10;
- * obj.propB = "hello";
- * const objAsString = Deno.inspect(obj); // { propA: 10, propB: "hello" }
- * console.log(obj); // prints same value as objAsString, e.g. { propA: 10, propB: "hello" }
- * ```
- *
- * You can also register custom inspect functions, via the `customInspect` Deno
- * symbol on objects, to control and customize the output.
- *
- * ```ts
- * class A {
- * x = 10;
- * y = "hello";
- * [Deno.customInspect](): string {
- * return "x=" + this.x + ", y=" + this.y;
- * }
- * }
- * ```
- *
- * const inStringFormat = Deno.inspect(new A()); // "x=10, y=hello"
- * console.log(inStringFormat); // prints "x=10, y=hello"
- *
- * Finally, you can also specify the depth to which it will format.
- *
- * Deno.inspect({a: {b: {c: {d: 'hello'}}}}, {depth: 2}); // { a: { b: [Object] } }
- *
- */
- export function inspect(value: unknown, options?: InspectOptions): string;
-
- /** Build related information. */
- export const build: {
- /** The LLVM target triple */
- target: string;
- /** Instruction set architecture */
- arch: "x86_64";
- /** Operating system */
- os: "darwin" | "linux" | "windows";
- /** Computer vendor */
- vendor: string;
- /** Optional environment */
- env?: string;
- };
-
- interface Version {
- deno: string;
- v8: string;
- typescript: string;
- }
- /** Version related information. */
- export const version: Version;
-
- /** Returns the script arguments to the program. If for example we run a
- * program:
- *
- * deno run --allow-read https://deno.land/std/examples/cat.ts /etc/passwd
- *
- * Then `Deno.args` will contain:
- *
- * [ "/etc/passwd" ]
- */
- export const args: string[];
-
- /** A symbol which can be used as a key for a custom method which will be
- * called when `Deno.inspect()` is called, or when the object is logged to
- * the console. */
- export const customInspect: unique symbol;
-}
diff --git a/cli/js2/lib.deno.shared_globals.d.ts b/cli/js2/lib.deno.shared_globals.d.ts
deleted file mode 100644
index c77f1ea0e..000000000
--- a/cli/js2/lib.deno.shared_globals.d.ts
+++ /dev/null
@@ -1,1657 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, no-var */
-
-/// <reference no-default-lib="true" />
-/// <reference lib="esnext" />
-
-// This follows the WebIDL at: https://webassembly.github.io/spec/js-api/
-// and: https://webassembly.github.io/spec/web-api/
-declare namespace WebAssembly {
- interface WebAssemblyInstantiatedSource {
- module: Module;
- instance: Instance;
- }
-
- /** Compiles a `WebAssembly.Module` from WebAssembly binary code. This
- * function is useful if it is necessary to a compile a module before it can
- * be instantiated (otherwise, the `WebAssembly.instantiate()` function
- * should be used). */
- function compile(bufferSource: BufferSource): Promise<Module>;
-
- /** Compiles a `WebAssembly.Module` directly from a streamed underlying
- * source. This function is useful if it is necessary to a compile a module
- * before it can be instantiated (otherwise, the
- * `WebAssembly.instantiateStreaming()` function should be used). */
- function compileStreaming(source: Promise<Response>): Promise<Module>;
-
- /** Takes the WebAssembly binary code, in the form of a typed array or
- * `ArrayBuffer`, and performs both compilation and instantiation in one step.
- * The returned `Promise` resolves to both a compiled `WebAssembly.Module` and
- * its first `WebAssembly.Instance`. */
- function instantiate(
- bufferSource: BufferSource,
- importObject?: object,
- ): Promise<WebAssemblyInstantiatedSource>;
-
- /** Takes an already-compiled `WebAssembly.Module` and returns a `Promise`
- * that resolves to an `Instance` of that `Module`. This overload is useful if
- * the `Module` has already been compiled. */
- function instantiate(
- module: Module,
- importObject?: object,
- ): Promise<Instance>;
-
- /** Compiles and instantiates a WebAssembly module directly from a streamed
- * underlying source. This is the most efficient, optimized way to load wasm
- * code. */
- function instantiateStreaming(
- source: Promise<Response>,
- importObject?: object,
- ): Promise<WebAssemblyInstantiatedSource>;
-
- /** Validates a given typed array of WebAssembly binary code, returning
- * whether the bytes form a valid wasm module (`true`) or not (`false`). */
- function validate(bufferSource: BufferSource): boolean;
-
- type ImportExportKind = "function" | "table" | "memory" | "global";
-
- interface ModuleExportDescriptor {
- name: string;
- kind: ImportExportKind;
- }
- interface ModuleImportDescriptor {
- module: string;
- name: string;
- kind: ImportExportKind;
- }
-
- class Module {
- constructor(bufferSource: BufferSource);
-
- /** Given a `Module` and string, returns a copy of the contents of all
- * custom sections in the module with the given string name. */
- static customSections(
- moduleObject: Module,
- sectionName: string,
- ): ArrayBuffer;
-
- /** Given a `Module`, returns an array containing descriptions of all the
- * declared exports. */
- static exports(moduleObject: Module): ModuleExportDescriptor[];
-
- /** Given a `Module`, returns an array containing descriptions of all the
- * declared imports. */
- static imports(moduleObject: Module): ModuleImportDescriptor[];
- }
-
- class Instance<T extends object = { [key: string]: any }> {
- constructor(module: Module, importObject?: object);
-
- /** An object containing as its members all the functions exported from the
- * WebAssembly module instance, to allow them to be accessed and used by
- * JavaScript. */
- readonly exports: T;
- }
-
- interface MemoryDescriptor {
- initial: number;
- maximum?: number;
- }
-
- class Memory {
- constructor(descriptor: MemoryDescriptor);
-
- /** An accessor property that returns the buffer contained in the memory. */
- readonly buffer: ArrayBuffer;
-
- /** Increases the size of the memory instance by a specified number of
- * WebAssembly pages (each one is 64KB in size). */
- grow(delta: number): number;
- }
-
- type TableKind = "anyfunc";
-
- interface TableDescriptor {
- element: TableKind;
- initial: number;
- maximum?: number;
- }
-
- class Table {
- constructor(descriptor: TableDescriptor);
-
- /** Returns the length of the table, i.e. the number of elements. */
- readonly length: number;
-
- /** Accessor function — gets the element stored at a given index. */
- get(index: number): (...args: any[]) => any;
-
- /** Increases the size of the Table instance by a specified number of
- * elements. */
- grow(delta: number): number;
-
- /** Sets an element stored at a given index to a given value. */
- set(index: number, value: (...args: any[]) => any): void;
- }
-
- type ValueType = "i32" | "i64" | "f32" | "f64";
-
- interface GlobalDescriptor {
- value: ValueType;
- mutable?: boolean;
- }
-
- /** Represents a global variable instance, accessible from both JavaScript and
- * importable/exportable across one or more `WebAssembly.Module` instances.
- * This allows dynamic linking of multiple modules. */
- class Global {
- constructor(descriptor: GlobalDescriptor, value?: any);
-
- /** Old-style method that returns the value contained inside the global
- * variable. */
- valueOf(): any;
-
- /** The value contained inside the global variable — this can be used to
- * directly set and get the global's value. */
- value: any;
- }
-
- /** Indicates an error during WebAssembly decoding or validation */
- class CompileError extends Error {
- constructor(message: string, fileName?: string, lineNumber?: string);
- }
-
- /** Indicates an error during module instantiation (besides traps from the
- * start function). */
- class LinkError extends Error {
- constructor(message: string, fileName?: string, lineNumber?: string);
- }
-
- /** Is thrown whenever WebAssembly specifies a trap. */
- class RuntimeError extends Error {
- constructor(message: string, fileName?: string, lineNumber?: string);
- }
-}
-
-/** Sets a timer which executes a function once after the timer expires. Returns
- * an id which may be used to cancel the timeout.
- *
- * setTimeout(() => { console.log('hello'); }, 500);
- */
-declare function setTimeout(
- /** callback function to execute when timer expires */
- cb: (...args: any[]) => void,
- /** delay in ms */
- delay?: number,
- /** arguments passed to callback function */
- ...args: any[]
-): number;
-
-/** Repeatedly calls a function , with a fixed time delay between each call.
- *
- * // Outputs 'hello' to the console every 500ms
- * setInterval(() => { console.log('hello'); }, 500);
- */
-declare function setInterval(
- /** callback function to execute when timer expires */
- cb: (...args: any[]) => void,
- /** delay in ms */
- delay?: number,
- /** arguments passed to callback function */
- ...args: any[]
-): number;
-
-/** Cancels a timed, repeating action which was previously started by a call
- * to `setInterval()`
- *
- * const id = setInterval(()= > {console.log('hello');}, 500);
- * ...
- * clearInterval(id);
- */
-declare function clearInterval(id?: number): void;
-
-/** Cancels a scheduled action initiated by `setTimeout()`
- *
- * const id = setTimeout(()= > {console.log('hello');}, 500);
- * ...
- * clearTimeout(id);
- */
-declare function clearTimeout(id?: number): void;
-
-interface VoidFunction {
- (): void;
-}
-
-/** A microtask is a short function which is executed after the function or
- * module which created it exits and only if the JavaScript execution stack is
- * empty, but before returning control to the event loop being used to drive the
- * script's execution environment. This event loop may be either the main event
- * loop or the event loop driving a web worker.
- *
- * queueMicrotask(() => { console.log('This event loop stack is complete'); });
- */
-declare function queueMicrotask(func: VoidFunction): void;
-
-declare var console: Console;
-declare var crypto: Crypto;
-
-/** Registers an event listener in the global scope, which will be called
- * synchronously whenever the event `type` is dispatched.
- *
- * addEventListener('unload', () => { console.log('All finished!'); });
- * ...
- * dispatchEvent(new Event('unload'));
- */
-declare function addEventListener(
- type: string,
- callback: EventListenerOrEventListenerObject | null,
- options?: boolean | AddEventListenerOptions | undefined,
-): void;
-
-/** Dispatches an event in the global scope, synchronously invoking any
- * registered event listeners for this event in the appropriate order. Returns
- * false if event is cancelable and at least one of the event handlers which
- * handled this event called Event.preventDefault(). Otherwise it returns true.
- *
- * dispatchEvent(new Event('unload'));
- */
-declare function dispatchEvent(event: Event): boolean;
-
-/** Remove a previously registered event listener from the global scope
- *
- * const lstnr = () => { console.log('hello'); };
- * addEventListener('load', lstnr);
- * removeEventListener('load', lstnr);
- */
-declare function removeEventListener(
- type: string,
- callback: EventListenerOrEventListenerObject | null,
- options?: boolean | EventListenerOptions | undefined,
-): void;
-
-interface DomIterable<K, V> {
- keys(): IterableIterator<K>;
- values(): IterableIterator<V>;
- entries(): IterableIterator<[K, V]>;
- [Symbol.iterator](): IterableIterator<[K, V]>;
- forEach(
- callback: (value: V, key: K, parent: this) => void,
- thisArg?: any,
- ): void;
-}
-
-interface ReadableStreamReadDoneResult<T> {
- done: true;
- value?: T;
-}
-
-interface ReadableStreamReadValueResult<T> {
- done: false;
- value: T;
-}
-
-type ReadableStreamReadResult<T> =
- | ReadableStreamReadValueResult<T>
- | ReadableStreamReadDoneResult<T>;
-
-interface ReadableStreamDefaultReader<R = any> {
- readonly closed: Promise<void>;
- cancel(reason?: any): Promise<void>;
- read(): Promise<ReadableStreamReadResult<R>>;
- releaseLock(): void;
-}
-
-interface ReadableStreamReader<R = any> {
- cancel(): Promise<void>;
- read(): Promise<ReadableStreamReadResult<R>>;
- releaseLock(): void;
-}
-
-interface ReadableByteStreamControllerCallback {
- (controller: ReadableByteStreamController): void | PromiseLike<void>;
-}
-
-interface UnderlyingByteSource {
- autoAllocateChunkSize?: number;
- cancel?: ReadableStreamErrorCallback;
- pull?: ReadableByteStreamControllerCallback;
- start?: ReadableByteStreamControllerCallback;
- type: "bytes";
-}
-
-interface UnderlyingSource<R = any> {
- cancel?: ReadableStreamErrorCallback;
- pull?: ReadableStreamDefaultControllerCallback<R>;
- start?: ReadableStreamDefaultControllerCallback<R>;
- type?: undefined;
-}
-
-interface ReadableStreamErrorCallback {
- (reason: any): void | PromiseLike<void>;
-}
-
-interface ReadableStreamDefaultControllerCallback<R> {
- (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
-}
-
-interface ReadableStreamDefaultController<R = any> {
- readonly desiredSize: number | null;
- close(): void;
- enqueue(chunk: R): void;
- error(error?: any): void;
-}
-
-interface ReadableByteStreamController {
- readonly byobRequest: undefined;
- readonly desiredSize: number | null;
- close(): void;
- enqueue(chunk: ArrayBufferView): void;
- error(error?: any): void;
-}
-
-interface PipeOptions {
- preventAbort?: boolean;
- preventCancel?: boolean;
- preventClose?: boolean;
- signal?: AbortSignal;
-}
-
-interface QueuingStrategySizeCallback<T = any> {
- (chunk: T): number;
-}
-
-interface QueuingStrategy<T = any> {
- highWaterMark?: number;
- size?: QueuingStrategySizeCallback<T>;
-}
-
-/** This Streams API interface provides a built-in byte length queuing strategy
- * that can be used when constructing streams. */
-declare class CountQueuingStrategy implements QueuingStrategy {
- constructor(options: { highWaterMark: number });
- highWaterMark: number;
- size(chunk: any): 1;
-}
-
-declare class ByteLengthQueuingStrategy
- implements QueuingStrategy<ArrayBufferView> {
- constructor(options: { highWaterMark: number });
- highWaterMark: number;
- size(chunk: ArrayBufferView): number;
-}
-
-/** This Streams API interface represents a readable stream of byte data. The
- * Fetch API offers a concrete instance of a ReadableStream through the body
- * property of a Response object. */
-interface ReadableStream<R = any> {
- readonly locked: boolean;
- cancel(reason?: any): Promise<void>;
- getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
- // getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
- getReader(): ReadableStreamDefaultReader<R>;
- pipeThrough<T>(
- {
- writable,
- readable,
- }: {
- writable: WritableStream<R>;
- readable: ReadableStream<T>;
- },
- options?: PipeOptions,
- ): ReadableStream<T>;
- pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
- tee(): [ReadableStream<R>, ReadableStream<R>];
- [Symbol.asyncIterator](options?: {
- preventCancel?: boolean;
- }): AsyncIterableIterator<R>;
-}
-
-declare var ReadableStream: {
- prototype: ReadableStream;
- new (
- underlyingSource: UnderlyingByteSource,
- strategy?: { highWaterMark?: number; size?: undefined },
- ): ReadableStream<Uint8Array>;
- new <R = any>(
- underlyingSource?: UnderlyingSource<R>,
- strategy?: QueuingStrategy<R>,
- ): ReadableStream<R>;
-};
-
-interface WritableStreamDefaultControllerCloseCallback {
- (): void | PromiseLike<void>;
-}
-
-interface WritableStreamDefaultControllerStartCallback {
- (controller: WritableStreamDefaultController): void | PromiseLike<void>;
-}
-
-interface WritableStreamDefaultControllerWriteCallback<W> {
- (chunk: W, controller: WritableStreamDefaultController):
- | void
- | PromiseLike<
- void
- >;
-}
-
-interface WritableStreamErrorCallback {
- (reason: any): void | PromiseLike<void>;
-}
-
-interface UnderlyingSink<W = any> {
- abort?: WritableStreamErrorCallback;
- close?: WritableStreamDefaultControllerCloseCallback;
- start?: WritableStreamDefaultControllerStartCallback;
- type?: undefined;
- write?: WritableStreamDefaultControllerWriteCallback<W>;
-}
-
-/** This Streams API interface provides a standard abstraction for writing
- * streaming data to a destination, known as a sink. This object comes with
- * built-in backpressure and queuing. */
-declare class WritableStream<W = any> {
- constructor(
- underlyingSink?: UnderlyingSink<W>,
- strategy?: QueuingStrategy<W>,
- );
- readonly locked: boolean;
- abort(reason?: any): Promise<void>;
- close(): Promise<void>;
- getWriter(): WritableStreamDefaultWriter<W>;
-}
-
-/** This Streams API interface represents a controller allowing control of a
- * WritableStream's state. When constructing a WritableStream, the underlying
- * sink is given a corresponding WritableStreamDefaultController instance to
- * manipulate. */
-interface WritableStreamDefaultController {
- error(error?: any): void;
-}
-
-/** This Streams API interface is the object returned by
- * WritableStream.getWriter() and once created locks the < writer to the
- * WritableStream ensuring that no other streams can write to the underlying
- * sink. */
-interface WritableStreamDefaultWriter<W = any> {
- readonly closed: Promise<void>;
- readonly desiredSize: number | null;
- readonly ready: Promise<void>;
- abort(reason?: any): Promise<void>;
- close(): Promise<void>;
- releaseLock(): void;
- write(chunk: W): Promise<void>;
-}
-
-declare class TransformStream<I = any, O = any> {
- constructor(
- transformer?: Transformer<I, O>,
- writableStrategy?: QueuingStrategy<I>,
- readableStrategy?: QueuingStrategy<O>,
- );
- readonly readable: ReadableStream<O>;
- readonly writable: WritableStream<I>;
-}
-
-interface TransformStreamDefaultController<O = any> {
- readonly desiredSize: number | null;
- enqueue(chunk: O): void;
- error(reason?: any): void;
- terminate(): void;
-}
-
-interface Transformer<I = any, O = any> {
- flush?: TransformStreamDefaultControllerCallback<O>;
- readableType?: undefined;
- start?: TransformStreamDefaultControllerCallback<O>;
- transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
- writableType?: undefined;
-}
-
-interface TransformStreamDefaultControllerCallback<O> {
- (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
-}
-
-interface TransformStreamDefaultControllerTransformCallback<I, O> {
- (
- chunk: I,
- controller: TransformStreamDefaultController<O>,
- ): void | PromiseLike<void>;
-}
-
-interface DOMStringList {
- /** Returns the number of strings in strings. */
- readonly length: number;
- /** Returns true if strings contains string, and false otherwise. */
- contains(string: string): boolean;
- /** Returns the string with index index from strings. */
- item(index: number): string | null;
- [index: number]: string;
-}
-
-declare class DOMException extends Error {
- constructor(message?: string, name?: string);
- readonly name: string;
- readonly message: string;
-}
-
-type BufferSource = ArrayBufferView | ArrayBuffer;
-type BlobPart = BufferSource | Blob | string;
-
-interface BlobPropertyBag {
- type?: string;
- ending?: "transparent" | "native";
-}
-
-/** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
-interface Blob {
- readonly size: number;
- readonly type: string;
- arrayBuffer(): Promise<ArrayBuffer>;
- slice(start?: number, end?: number, contentType?: string): Blob;
- stream(): ReadableStream;
- text(): Promise<string>;
-}
-
-declare const Blob: {
- prototype: Blob;
- new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
-};
-
-interface FilePropertyBag extends BlobPropertyBag {
- lastModified?: number;
-}
-
-/** Provides information about files and allows JavaScript in a web page to
- * access their content. */
-interface File extends Blob {
- readonly lastModified: number;
- readonly name: string;
-}
-
-declare const File: {
- prototype: File;
- new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
-};
-
-declare const isConsoleInstance: unique symbol;
-
-declare class Console {
- indentLevel: number;
- [isConsoleInstance]: boolean;
- /** Writes the arguments to stdout */
- log: (...args: unknown[]) => void;
- /** Writes the arguments to stdout */
- debug: (...args: unknown[]) => void;
- /** Writes the arguments to stdout */
- info: (...args: unknown[]) => void;
- /** Writes the properties of the supplied `obj` to stdout */
- dir: (
- obj: unknown,
- options?: Partial<{
- depth: number;
- indentLevel: number;
- }>,
- ) => void;
-
- /** From MDN:
- * Displays an interactive tree of the descendant elements of
- * the specified XML/HTML element. If it is not possible to display
- * as an element the JavaScript Object view is shown instead.
- * The output is presented as a hierarchical listing of expandable
- * nodes that let you see the contents of child nodes.
- *
- * Since we write to stdout, we can't display anything interactive
- * we just fall back to `console.dir`.
- */
- dirxml: (
- obj: unknown,
- options?: Partial<{
- showHidden: boolean;
- depth: number;
- colors: boolean;
- indentLevel: number;
- }>,
- ) => void;
-
- /** Writes the arguments to stdout */
- warn: (...args: unknown[]) => void;
- /** Writes the arguments to stdout */
- error: (...args: unknown[]) => void;
- /** Writes an error message to stdout if the assertion is `false`. If the
- * assertion is `true`, nothing happens.
- *
- * ref: https://console.spec.whatwg.org/#assert
- */
- assert: (condition?: boolean, ...args: unknown[]) => void;
- count: (label?: string) => void;
- countReset: (label?: string) => void;
- table: (data: unknown, properties?: string[] | undefined) => void;
- time: (label?: string) => void;
- timeLog: (label?: string, ...args: unknown[]) => void;
- timeEnd: (label?: string) => void;
- group: (...label: unknown[]) => void;
- groupCollapsed: (...label: unknown[]) => void;
- groupEnd: () => void;
- clear: () => void;
- trace: (...args: unknown[]) => void;
- static [Symbol.hasInstance](instance: Console): boolean;
-}
-
-declare interface Crypto {
- readonly subtle: null;
- getRandomValues<
- T extends
- | Int8Array
- | Int16Array
- | Int32Array
- | Uint8Array
- | Uint16Array
- | Uint32Array
- | Uint8ClampedArray
- | Float32Array
- | Float64Array
- | DataView
- | null,
- >(
- array: T,
- ): T;
-}
-
-type FormDataEntryValue = File | string;
-
-/** Provides a way to easily construct a set of key/value pairs representing
- * form fields and their values, which can then be easily sent using the
- * XMLHttpRequest.send() method. It uses the same format a form would use if the
- * encoding type were set to "multipart/form-data". */
-interface FormData extends DomIterable<string, FormDataEntryValue> {
- append(name: string, value: string | Blob, fileName?: string): void;
- delete(name: string): void;
- get(name: string): FormDataEntryValue | null;
- getAll(name: string): FormDataEntryValue[];
- has(name: string): boolean;
- set(name: string, value: string | Blob, fileName?: string): void;
-}
-
-declare const FormData: {
- prototype: FormData;
- // TODO(ry) FormData constructor is non-standard.
- // new(form?: HTMLFormElement): FormData;
- new (): FormData;
-};
-
-interface Body {
- /** A simple getter used to expose a `ReadableStream` of the body contents. */
- readonly body: ReadableStream<Uint8Array> | null;
- /** Stores a `Boolean` that declares whether the body has been used in a
- * response yet.
- */
- readonly bodyUsed: boolean;
- /** Takes a `Response` stream and reads it to completion. It returns a promise
- * that resolves with an `ArrayBuffer`.
- */
- arrayBuffer(): Promise<ArrayBuffer>;
- /** Takes a `Response` stream and reads it to completion. It returns a promise
- * that resolves with a `Blob`.
- */
- blob(): Promise<Blob>;
- /** Takes a `Response` stream and reads it to completion. It returns a promise
- * that resolves with a `FormData` object.
- */
- formData(): Promise<FormData>;
- /** Takes a `Response` stream and reads it to completion. It returns a promise
- * that resolves with the result of parsing the body text as JSON.
- */
- json(): Promise<any>;
- /** Takes a `Response` stream and reads it to completion. It returns a promise
- * that resolves with a `USVString` (text).
- */
- text(): Promise<string>;
-}
-
-type HeadersInit = Headers | string[][] | Record<string, string>;
-
-/** This Fetch API interface allows you to perform various actions on HTTP
- * request and response headers. These actions include retrieving, setting,
- * adding to, and removing. A Headers object has an associated header list,
- * which is initially empty and consists of zero or more name and value pairs.
- *  You can add to this using methods like append() (see Examples.) In all
- * methods of this interface, header names are matched by case-insensitive byte
- * sequence. */
-interface Headers {
- append(name: string, value: string): void;
- delete(name: string): void;
- get(name: string): string | null;
- has(name: string): boolean;
- set(name: string, value: string): void;
- forEach(
- callbackfn: (value: string, key: string, parent: Headers) => void,
- thisArg?: any,
- ): void;
-}
-
-interface Headers extends DomIterable<string, string> {
- /** Appends a new value onto an existing header inside a `Headers` object, or
- * adds the header if it does not already exist.
- */
- append(name: string, value: string): void;
- /** Deletes a header from a `Headers` object. */
- delete(name: string): void;
- /** Returns an iterator allowing to go through all key/value pairs
- * contained in this Headers object. The both the key and value of each pairs
- * are ByteString objects.
- */
- entries(): IterableIterator<[string, string]>;
- /** Returns a `ByteString` sequence of all the values of a header within a
- * `Headers` object with a given name.
- */
- get(name: string): string | null;
- /** Returns a boolean stating whether a `Headers` object contains a certain
- * header.
- */
- has(name: string): boolean;
- /** Returns an iterator allowing to go through all keys contained in
- * this Headers object. The keys are ByteString objects.
- */
- keys(): IterableIterator<string>;
- /** Sets a new value for an existing header inside a Headers object, or adds
- * the header if it does not already exist.
- */
- set(name: string, value: string): void;
- /** Returns an iterator allowing to go through all values contained in
- * this Headers object. The values are ByteString objects.
- */
- values(): IterableIterator<string>;
- forEach(
- callbackfn: (value: string, key: string, parent: this) => void,
- thisArg?: any,
- ): void;
- /** The Symbol.iterator well-known symbol specifies the default
- * iterator for this Headers object
- */
- [Symbol.iterator](): IterableIterator<[string, string]>;
-}
-
-declare const Headers: {
- prototype: Headers;
- new (init?: HeadersInit): Headers;
-};
-
-type RequestInfo = Request | string;
-type RequestCache =
- | "default"
- | "force-cache"
- | "no-cache"
- | "no-store"
- | "only-if-cached"
- | "reload";
-type RequestCredentials = "include" | "omit" | "same-origin";
-type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
-type RequestRedirect = "error" | "follow" | "manual";
-type ReferrerPolicy =
- | ""
- | "no-referrer"
- | "no-referrer-when-downgrade"
- | "origin"
- | "origin-when-cross-origin"
- | "same-origin"
- | "strict-origin"
- | "strict-origin-when-cross-origin"
- | "unsafe-url";
-type BodyInit =
- | Blob
- | BufferSource
- | FormData
- | URLSearchParams
- | ReadableStream<Uint8Array>
- | string;
-type RequestDestination =
- | ""
- | "audio"
- | "audioworklet"
- | "document"
- | "embed"
- | "font"
- | "image"
- | "manifest"
- | "object"
- | "paintworklet"
- | "report"
- | "script"
- | "sharedworker"
- | "style"
- | "track"
- | "video"
- | "worker"
- | "xslt";
-
-interface RequestInit {
- /**
- * A BodyInit object or null to set request's body.
- */
- body?: BodyInit | null;
- /**
- * A string indicating how the request will interact with the browser's cache
- * to set request's cache.
- */
- cache?: RequestCache;
- /**
- * A string indicating whether credentials will be sent with the request
- * always, never, or only when sent to a same-origin URL. Sets request's
- * credentials.
- */
- credentials?: RequestCredentials;
- /**
- * A Headers object, an object literal, or an array of two-item arrays to set
- * request's headers.
- */
- headers?: HeadersInit;
- /**
- * A cryptographic hash of the resource to be fetched by request. Sets
- * request's integrity.
- */
- integrity?: string;
- /**
- * A boolean to set request's keepalive.
- */
- keepalive?: boolean;
- /**
- * A string to set request's method.
- */
- method?: string;
- /**
- * A string to indicate whether the request will use CORS, or will be
- * restricted to same-origin URLs. Sets request's mode.
- */
- mode?: RequestMode;
- /**
- * A string indicating whether request follows redirects, results in an error
- * upon encountering a redirect, or returns the redirect (in an opaque
- * fashion). Sets request's redirect.
- */
- redirect?: RequestRedirect;
- /**
- * A string whose value is a same-origin URL, "about:client", or the empty
- * string, to set request's referrer.
- */
- referrer?: string;
- /**
- * A referrer policy to set request's referrerPolicy.
- */
- referrerPolicy?: ReferrerPolicy;
- /**
- * An AbortSignal to set request's signal.
- */
- signal?: AbortSignal | null;
- /**
- * Can only be null. Used to disassociate request from any Window.
- */
- window?: any;
-}
-
-/** This Fetch API interface represents a resource request. */
-interface Request extends Body {
- /**
- * Returns the cache mode associated with request, which is a string
- * indicating how the request will interact with the browser's cache when
- * fetching.
- */
- readonly cache: RequestCache;
- /**
- * Returns the credentials mode associated with request, which is a string
- * indicating whether credentials will be sent with the request always, never,
- * or only when sent to a same-origin URL.
- */
- readonly credentials: RequestCredentials;
- /**
- * Returns the kind of resource requested by request, e.g., "document" or "script".
- */
- readonly destination: RequestDestination;
- /**
- * Returns a Headers object consisting of the headers associated with request.
- * Note that headers added in the network layer by the user agent will not be
- * accounted for in this object, e.g., the "Host" header.
- */
- readonly headers: Headers;
- /**
- * Returns request's subresource integrity metadata, which is a cryptographic
- * hash of the resource being fetched. Its value consists of multiple hashes
- * separated by whitespace. [SRI]
- */
- readonly integrity: string;
- /**
- * Returns a boolean indicating whether or not request is for a history
- * navigation (a.k.a. back-forward navigation).
- */
- readonly isHistoryNavigation: boolean;
- /**
- * Returns a boolean indicating whether or not request is for a reload
- * navigation.
- */
- readonly isReloadNavigation: boolean;
- /**
- * Returns a boolean indicating whether or not request can outlive the global
- * in which it was created.
- */
- readonly keepalive: boolean;
- /**
- * Returns request's HTTP method, which is "GET" by default.
- */
- readonly method: string;
- /**
- * Returns the mode associated with request, which is a string indicating
- * whether the request will use CORS, or will be restricted to same-origin
- * URLs.
- */
- readonly mode: RequestMode;
- /**
- * Returns the redirect mode associated with request, which is a string
- * indicating how redirects for the request will be handled during fetching. A
- * request will follow redirects by default.
- */
- readonly redirect: RequestRedirect;
- /**
- * Returns the referrer of request. Its value can be a same-origin URL if
- * explicitly set in init, the empty string to indicate no referrer, and
- * "about:client" when defaulting to the global's default. This is used during
- * fetching to determine the value of the `Referer` header of the request
- * being made.
- */
- readonly referrer: string;
- /**
- * Returns the referrer policy associated with request. This is used during
- * fetching to compute the value of the request's referrer.
- */
- readonly referrerPolicy: ReferrerPolicy;
- /**
- * Returns the signal associated with request, which is an AbortSignal object
- * indicating whether or not request has been aborted, and its abort event
- * handler.
- */
- readonly signal: AbortSignal;
- /**
- * Returns the URL of request as a string.
- */
- readonly url: string;
- clone(): Request;
-}
-
-declare const Request: {
- prototype: Request;
- new (input: RequestInfo, init?: RequestInit): Request;
-};
-
-interface ResponseInit {
- headers?: HeadersInit;
- status?: number;
- statusText?: string;
-}
-
-type ResponseType =
- | "basic"
- | "cors"
- | "default"
- | "error"
- | "opaque"
- | "opaqueredirect";
-
-/** This Fetch API interface represents the response to a request. */
-interface Response extends Body {
- readonly headers: Headers;
- readonly ok: boolean;
- readonly redirected: boolean;
- readonly status: number;
- readonly statusText: string;
- readonly trailer: Promise<Headers>;
- readonly type: ResponseType;
- readonly url: string;
- clone(): Response;
-}
-
-declare const Response: {
- prototype: Response;
- new (body?: BodyInit | null, init?: ResponseInit): Response;
- error(): Response;
- redirect(url: string, status?: number): Response;
-};
-
-/** Fetch a resource from the network. It returns a Promise that resolves to the
- * Response to that request, whether it is successful or not.
- *
- * const response = await fetch("http://my.json.host/data.json");
- * console.log(response.status); // e.g. 200
- * console.log(response.statusText); // e.g. "OK"
- * const jsonData = await response.json();
- */
-declare function fetch(
- input: Request | URL | string,
- init?: RequestInit,
-): Promise<Response>;
-
-/** Decodes a string of data which has been encoded using base-64 encoding.
- *
- * console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'
- */
-declare function atob(s: string): string;
-
-/** Creates a base-64 ASCII encoded string from the input string.
- *
- * console.log(btoa("hello world")); // outputs "aGVsbG8gd29ybGQ="
- */
-declare function btoa(s: string): string;
-
-declare class TextDecoder {
- /** Returns encoding's name, lowercased. */
- readonly encoding: string;
- /** Returns `true` if error mode is "fatal", and `false` otherwise. */
- readonly fatal: boolean;
- /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
- readonly ignoreBOM = false;
- constructor(
- label?: string,
- options?: { fatal?: boolean; ignoreBOM?: boolean },
- );
- /** Returns the result of running encoding's decoder. */
- decode(input?: BufferSource, options?: { stream?: false }): string;
- readonly [Symbol.toStringTag]: string;
-}
-
-declare class TextEncoder {
- /** Returns "utf-8". */
- readonly encoding = "utf-8";
- /** Returns the result of running UTF-8's encoder. */
- encode(input?: string): Uint8Array;
- encodeInto(
- input: string,
- dest: Uint8Array,
- ): { read: number; written: number };
- readonly [Symbol.toStringTag]: string;
-}
-
-interface URLSearchParams {
- /** Appends a specified key/value pair as a new search parameter.
- *
- * ```ts
- * let searchParams = new URLSearchParams();
- * searchParams.append('name', 'first');
- * searchParams.append('name', 'second');
- * ```
- */
- append(name: string, value: string): void;
-
- /** Deletes the given search parameter and its associated value,
- * from the list of all search parameters.
- *
- * ```ts
- * let searchParams = new URLSearchParams([['name', 'value']]);
- * searchParams.delete('name');
- * ```
- */
- delete(name: string): void;
-
- /** Returns all the values associated with a given search parameter
- * as an array.
- *
- * ```ts
- * searchParams.getAll('name');
- * ```
- */
- getAll(name: string): string[];
-
- /** Returns the first value associated to the given search parameter.
- *
- * ```ts
- * searchParams.get('name');
- * ```
- */
- get(name: string): string | null;
-
- /** Returns a Boolean that indicates whether a parameter with the
- * specified name exists.
- *
- * ```ts
- * searchParams.has('name');
- * ```
- */
- has(name: string): boolean;
-
- /** Sets the value associated with a given search parameter to the
- * given value. If there were several matching values, this method
- * deletes the others. If the search parameter doesn't exist, this
- * method creates it.
- *
- * ```ts
- * searchParams.set('name', 'value');
- * ```
- */
- set(name: string, value: string): void;
-
- /** Sort all key/value pairs contained in this object in place and
- * return undefined. The sort order is according to Unicode code
- * points of the keys.
- *
- * ```ts
- * searchParams.sort();
- * ```
- */
- sort(): void;
-
- /** Calls a function for each element contained in this object in
- * place and return undefined. Optionally accepts an object to use
- * as this when executing callback as second argument.
- *
- * ```ts
- * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
- * params.forEach((value, key, parent) => {
- * console.log(value, key, parent);
- * });
- * ```
- *
- */
- forEach(
- callbackfn: (value: string, key: string, parent: this) => void,
- thisArg?: any,
- ): void;
-
- /** Returns an iterator allowing to go through all keys contained
- * in this object.
- *
- * ```ts
- * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
- * for (const key of params.keys()) {
- * console.log(key);
- * }
- * ```
- */
- keys(): IterableIterator<string>;
-
- /** Returns an iterator allowing to go through all values contained
- * in this object.
- *
- * ```ts
- * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
- * for (const value of params.values()) {
- * console.log(value);
- * }
- * ```
- */
- values(): IterableIterator<string>;
-
- /** Returns an iterator allowing to go through all key/value
- * pairs contained in this object.
- *
- * ```ts
- * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
- * for (const [key, value] of params.entries()) {
- * console.log(key, value);
- * }
- * ```
- */
- entries(): IterableIterator<[string, string]>;
-
- /** Returns an iterator allowing to go through all key/value
- * pairs contained in this object.
- *
- * ```ts
- * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
- * for (const [key, value] of params) {
- * console.log(key, value);
- * }
- * ```
- */
- [Symbol.iterator](): IterableIterator<[string, string]>;
-
- /** Returns a query string suitable for use in a URL.
- *
- * ```ts
- * searchParams.toString();
- * ```
- */
- toString(): string;
-}
-
-declare const URLSearchParams: {
- prototype: URLSearchParams;
- new (
- init?: string[][] | Record<string, string> | string | URLSearchParams,
- ): URLSearchParams;
- toString(): string;
-};
-
-/** The URL interface represents an object providing static methods used for creating object URLs. */
-interface URL {
- hash: string;
- host: string;
- hostname: string;
- href: string;
- toString(): string;
- readonly origin: string;
- password: string;
- pathname: string;
- port: string;
- protocol: string;
- search: string;
- readonly searchParams: URLSearchParams;
- username: string;
- toJSON(): string;
-}
-
-declare const URL: {
- prototype: URL;
- new (url: string, base?: string | URL): URL;
- createObjectURL(object: any): string;
- revokeObjectURL(url: string): void;
-};
-
-interface MessageEventInit extends EventInit {
- data?: any;
- origin?: string;
- lastEventId?: string;
-}
-
-declare class MessageEvent extends Event {
- readonly data: any;
- readonly origin: string;
- readonly lastEventId: string;
- constructor(type: string, eventInitDict?: MessageEventInit);
-}
-
-interface ErrorEventInit extends EventInit {
- message?: string;
- filename?: string;
- lineno?: number;
- colno?: number;
- error?: any;
-}
-
-declare class ErrorEvent extends Event {
- readonly message: string;
- readonly filename: string;
- readonly lineno: number;
- readonly colno: number;
- readonly error: any;
- constructor(type: string, eventInitDict?: ErrorEventInit);
-}
-
-interface PostMessageOptions {
- transfer?: any[];
-}
-
-declare class Worker extends EventTarget {
- onerror?: (e: ErrorEvent) => void;
- onmessage?: (e: MessageEvent) => void;
- onmessageerror?: (e: MessageEvent) => void;
- constructor(
- specifier: string,
- options?: {
- type?: "classic" | "module";
- name?: string;
- /** UNSTABLE: New API. Expect many changes; most likely this
- * field will be made into an object for more granular
- * configuration of worker thread (permissions, import map, etc.).
- *
- * Set to `true` to make `Deno` namespace and all of its methods
- * available to worker thread.
- *
- * Currently worker inherits permissions from main thread (permissions
- * given using `--allow-*` flags).
- * Configurable permissions are on the roadmap to be implemented.
- *
- * Example:
- *
- * ```ts
- * // mod.ts
- * const worker = new Worker(
- * new URL("deno_worker.ts", import.meta.url).href,
- * { type: "module", deno: true }
- * );
- * worker.postMessage({ cmd: "readFile", fileName: "./log.txt" });
- *
- * // deno_worker.ts
- *
- *
- * self.onmessage = async function (e) {
- * const { cmd, fileName } = e.data;
- * if (cmd !== "readFile") {
- * throw new Error("Invalid command");
- * }
- * const buf = await Deno.readFile(fileName);
- * const fileContents = new TextDecoder().decode(buf);
- * console.log(fileContents);
- * }
- * ```
- *
- * // log.txt
- * hello world
- * hello world 2
- *
- * // run program
- * $ deno run --allow-read mod.ts
- * hello world
- * hello world2
- *
- */
- deno?: boolean;
- },
- );
- postMessage(message: any, transfer: ArrayBuffer[]): void;
- postMessage(message: any, options?: PostMessageOptions): void;
- terminate(): void;
-}
-
-declare type PerformanceEntryList = PerformanceEntry[];
-
-declare interface Performance {
- /** Removes the stored timestamp with the associated name. */
- clearMarks(markName?: string): void;
-
- /** Removes stored timestamp with the associated name. */
- clearMeasures(measureName?: string): void;
-
- getEntries(): PerformanceEntryList;
- getEntriesByName(name: string, type?: string): PerformanceEntryList;
- getEntriesByType(type: string): PerformanceEntryList;
-
- /** Stores a timestamp with the associated name (a "mark"). */
- mark(markName: string, options?: PerformanceMarkOptions): PerformanceMark;
-
- /** Stores the `DOMHighResTimeStamp` duration between two marks along with the
- * associated name (a "measure"). */
- measure(
- measureName: string,
- options?: PerformanceMeasureOptions,
- ): PerformanceMeasure;
- /** Stores the `DOMHighResTimeStamp` duration between two marks along with the
- * associated name (a "measure"). */
- measure(
- measureName: string,
- startMark?: string,
- endMark?: string,
- ): PerformanceMeasure;
-
- /** Returns a current time from Deno's start in milliseconds.
- *
- * Use the permission flag `--allow-hrtime` return a precise value.
- *
- * ```ts
- * const t = performance.now();
- * console.log(`${t} ms since start!`);
- * ```
- */
- now(): number;
-}
-
-declare const Performance: {
- prototype: Performance;
- new (): Performance;
-};
-
-declare const performance: Performance;
-
-declare interface PerformanceMarkOptions {
- /** Metadata to be included in the mark. */
- detail?: any;
-
- /** Timestamp to be used as the mark time. */
- startTime?: number;
-}
-
-declare interface PerformanceMeasureOptions {
- /** Metadata to be included in the measure. */
- detail?: any;
-
- /** Timestamp to be used as the start time or string to be used as start
- * mark.*/
- start?: string | number;
-
- /** Duration between the start and end times. */
- duration?: number;
-
- /** Timestamp to be used as the end time or string to be used as end mark. */
- end?: string | number;
-}
-
-/** Encapsulates a single performance metric that is part of the performance
- * timeline. A performance entry can be directly created by making a performance
- * mark or measure (for example by calling the `.mark()` method) at an explicit
- * point in an application. */
-declare class PerformanceEntry {
- readonly duration: number;
- readonly entryType: string;
- readonly name: string;
- readonly startTime: number;
- toJSON(): any;
-}
-
-/** `PerformanceMark` is an abstract interface for `PerformanceEntry` objects
- * with an entryType of `"mark"`. Entries of this type are created by calling
- * `performance.mark()` to add a named `DOMHighResTimeStamp` (the mark) to the
- * performance timeline. */
-declare class PerformanceMark extends PerformanceEntry {
- readonly detail: any;
- readonly entryType: "mark";
- constructor(name: string, options?: PerformanceMarkOptions);
-}
-
-/** `PerformanceMeasure` is an abstract interface for `PerformanceEntry` objects
- * with an entryType of `"measure"`. Entries of this type are created by calling
- * `performance.measure()` to add a named `DOMHighResTimeStamp` (the measure)
- * between two marks to the performance timeline. */
-declare class PerformanceMeasure extends PerformanceEntry {
- readonly detail: any;
- readonly entryType: "measure";
-}
-
-interface EventInit {
- bubbles?: boolean;
- cancelable?: boolean;
- composed?: boolean;
-}
-
-/** An event which takes place in the DOM. */
-declare class Event {
- constructor(type: string, eventInitDict?: EventInit);
- /** Returns true or false depending on how event was initialized. True if
- * event goes through its target's ancestors in reverse tree order, and
- * false otherwise. */
- readonly bubbles: boolean;
- cancelBubble: boolean;
- /** Returns true or false depending on how event was initialized. Its return
- * value does not always carry meaning, but true can indicate that part of the
- * operation during which event was dispatched, can be canceled by invoking
- * the preventDefault() method. */
- readonly cancelable: boolean;
- /** Returns true or false depending on how event was initialized. True if
- * event invokes listeners past a ShadowRoot node that is the root of its
- * target, and false otherwise. */
- readonly composed: boolean;
- /** Returns the object whose event listener's callback is currently being
- * invoked. */
- readonly currentTarget: EventTarget | null;
- /** Returns true if preventDefault() was invoked successfully to indicate
- * cancellation, and false otherwise. */
- readonly defaultPrevented: boolean;
- /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE,
- * AT_TARGET, and BUBBLING_PHASE. */
- readonly eventPhase: number;
- /** Returns true if event was dispatched by the user agent, and false
- * otherwise. */
- readonly isTrusted: boolean;
- /** Returns the object to which event is dispatched (its target). */
- readonly target: EventTarget | null;
- /** Returns the event's timestamp as the number of milliseconds measured
- * relative to the time origin. */
- readonly timeStamp: number;
- /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
- readonly type: string;
- /** Returns the invocation target objects of event's path (objects on which
- * listeners will be invoked), except for any nodes in shadow trees of which
- * the shadow root's mode is "closed" that are not reachable from event's
- * currentTarget. */
- composedPath(): EventTarget[];
- /** If invoked when the cancelable attribute value is true, and while
- * executing a listener for the event with passive set to false, signals to
- * the operation that caused event to be dispatched that it needs to be
- * canceled. */
- preventDefault(): void;
- /** Invoking this method prevents event from reaching any registered event
- * listeners after the current one finishes running and, when dispatched in a
- * tree, also prevents event from reaching any other objects. */
- stopImmediatePropagation(): void;
- /** When dispatched in a tree, invoking this method prevents event from
- * reaching any objects other than the current object. */
- stopPropagation(): void;
- readonly AT_TARGET: number;
- readonly BUBBLING_PHASE: number;
- readonly CAPTURING_PHASE: number;
- readonly NONE: number;
- static readonly AT_TARGET: number;
- static readonly BUBBLING_PHASE: number;
- static readonly CAPTURING_PHASE: number;
- static readonly NONE: number;
-}
-
-/**
- * EventTarget is a DOM interface implemented by objects that can receive events
- * and may have listeners for them.
- */
-declare class EventTarget {
- /** Appends an event listener for events whose type attribute value is type.
- * The callback argument sets the callback that will be invoked when the event
- * is dispatched.
- *
- * The options argument sets listener-specific options. For compatibility this
- * can be a boolean, in which case the method behaves exactly as if the value
- * was specified as options's capture.
- *
- * When set to true, options's capture prevents callback from being invoked
- * when the event's eventPhase attribute value is BUBBLING_PHASE. When false
- * (or not present), callback will not be invoked when event's eventPhase
- * attribute value is CAPTURING_PHASE. Either way, callback will be invoked if
- * event's eventPhase attribute value is AT_TARGET.
- *
- * When set to true, options's passive indicates that the callback will not
- * cancel the event by invoking preventDefault(). This is used to enable
- * performance optimizations described in § 2.8 Observing event listeners.
- *
- * When set to true, options's once indicates that the callback will only be
- * invoked once after which the event listener will be removed.
- *
- * The event listener is appended to target's event listener list and is not
- * appended if it has the same type, callback, and capture. */
- addEventListener(
- type: string,
- listener: EventListenerOrEventListenerObject | null,
- options?: boolean | AddEventListenerOptions,
- ): void;
- /** Dispatches a synthetic event event to target and returns true if either
- * event's cancelable attribute value is false or its preventDefault() method
- * was not invoked, and false otherwise. */
- dispatchEvent(event: Event): boolean;
- /** Removes the event listener in target's event listener list with the same
- * type, callback, and options. */
- removeEventListener(
- type: string,
- callback: EventListenerOrEventListenerObject | null,
- options?: EventListenerOptions | boolean,
- ): void;
- [Symbol.toStringTag]: string;
-}
-
-interface EventListener {
- (evt: Event): void | Promise<void>;
-}
-
-interface EventListenerObject {
- handleEvent(evt: Event): void | Promise<void>;
-}
-
-declare type EventListenerOrEventListenerObject =
- | EventListener
- | EventListenerObject;
-
-interface AddEventListenerOptions extends EventListenerOptions {
- once?: boolean;
- passive?: boolean;
-}
-
-interface EventListenerOptions {
- capture?: boolean;
-}
-
-/** Events measuring progress of an underlying process, like an HTTP request
- * (for an XMLHttpRequest, or the loading of the underlying resource of an
- * <img>, <audio>, <video>, <style> or <link>). */
-interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
- readonly lengthComputable: boolean;
- readonly loaded: number;
- readonly target: T | null;
- readonly total: number;
-}
-
-interface CustomEventInit<T = any> extends EventInit {
- detail?: T;
-}
-
-declare class CustomEvent<T = any> extends Event {
- constructor(typeArg: string, eventInitDict?: CustomEventInit<T>);
- /** Returns any custom data event was created with. Typically used for
- * synthetic events. */
- readonly detail: T;
-}
-
-/** A controller object that allows you to abort one or more DOM requests as and
- * when desired. */
-declare class AbortController {
- /** Returns the AbortSignal object associated with this object. */
- readonly signal: AbortSignal;
- /** Invoking this method will set this object's AbortSignal's aborted flag and
- * signal to any observers that the associated activity is to be aborted. */
- abort(): void;
-}
-
-interface AbortSignalEventMap {
- abort: Event;
-}
-
-/** A signal object that allows you to communicate with a DOM request (such as a
- * Fetch) and abort it if required via an AbortController object. */
-interface AbortSignal extends EventTarget {
- /** Returns true if this AbortSignal's AbortController has signaled to abort,
- * and false otherwise. */
- readonly aborted: boolean;
- onabort: ((this: AbortSignal, ev: Event) => any) | null;
- addEventListener<K extends keyof AbortSignalEventMap>(
- type: K,
- listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
- options?: boolean | AddEventListenerOptions,
- ): void;
- addEventListener(
- type: string,
- listener: EventListenerOrEventListenerObject,
- options?: boolean | AddEventListenerOptions,
- ): void;
- removeEventListener<K extends keyof AbortSignalEventMap>(
- type: K,
- listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
- options?: boolean | EventListenerOptions,
- ): void;
- removeEventListener(
- type: string,
- listener: EventListenerOrEventListenerObject,
- options?: boolean | EventListenerOptions,
- ): void;
-}
-
-declare const AbortSignal: {
- prototype: AbortSignal;
- new (): AbortSignal;
-};
-
-interface ErrorConstructor {
- /** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */
- // eslint-disable-next-line @typescript-eslint/ban-types
- captureStackTrace(error: Object, constructor?: Function): void;
- // TODO(nayeemrmn): Support `Error.prepareStackTrace()`. We currently use this
- // internally in a way that makes it unavailable for users.
-}
diff --git a/cli/js2/lib.deno.unstable.d.ts b/cli/js2/lib.deno.unstable.d.ts
deleted file mode 100644
index d23536c42..000000000
--- a/cli/js2/lib.deno.unstable.d.ts
+++ /dev/null
@@ -1,1217 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-
-/// <reference no-default-lib="true" />
-/// <reference lib="deno.ns" />
-
-declare namespace Deno {
- /**
- * **UNSTABLE**: New API, yet to be vetted. This API is under consideration to
- * determine if permissions are required to call it.
- *
- * Retrieve the process umask. If `mask` is provided, sets the process umask.
- * This call always returns what the umask was before the call.
- *
- * ```ts
- * console.log(Deno.umask()); // e.g. 18 (0o022)
- * const prevUmaskValue = Deno.umask(0o077); // e.g. 18 (0o022)
- * console.log(Deno.umask()); // e.g. 63 (0o077)
- * ```
- *
- * NOTE: This API is not implemented on Windows
- */
- export function umask(mask?: number): number;
-
- /** **UNSTABLE**: This API needs a security review.
- *
- * Synchronously creates `newpath` as a hard link to `oldpath`.
- *
- * ```ts
- * Deno.linkSync("old/name", "new/name");
- * ```
- *
- * Requires `allow-read` and `allow-write` permissions. */
- export function linkSync(oldpath: string, newpath: string): void;
-
- /** **UNSTABLE**: This API needs a security review.
- *
- * Creates `newpath` as a hard link to `oldpath`.
- *
- * ```ts
- * await Deno.link("old/name", "new/name");
- * ```
- *
- * Requires `allow-read` and `allow-write` permissions. */
- export function link(oldpath: string, newpath: string): Promise<void>;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- *
- * Gets the size of the console as columns/rows.
- *
- * ```ts
- * const { columns, rows } = await Deno.consoleSize(Deno.stdout.rid);
- * ```
- */
- export function consoleSize(
- rid: number,
- ): {
- columns: number;
- rows: number;
- };
-
- export type SymlinkOptions = {
- type: "file" | "dir";
- };
-
- /** **UNSTABLE**: This API needs a security review.
- *
- * Creates `newpath` as a symbolic link to `oldpath`.
- *
- * The options.type parameter can be set to `file` or `dir`. This argument is only
- * available on Windows and ignored on other platforms.
- *
- * ```ts
- * Deno.symlinkSync("old/name", "new/name");
- * ```
- *
- * Requires `allow-write` permission. */
- export function symlinkSync(
- oldpath: string,
- newpath: string,
- options?: SymlinkOptions,
- ): void;
-
- /** **UNSTABLE**: This API needs a security review.
- *
- * Creates `newpath` as a symbolic link to `oldpath`.
- *
- * The options.type parameter can be set to `file` or `dir`. This argument is only
- * available on Windows and ignored on other platforms.
- *
- * ```ts
- * await Deno.symlink("old/name", "new/name");
- * ```
- *
- * Requires `allow-write` permission. */
- export function symlink(
- oldpath: string,
- newpath: string,
- options?: SymlinkOptions,
- ): Promise<void>;
-
- /** **Unstable** There are questions around which permission this needs. And
- * maybe should be renamed (loadAverage?)
- *
- * Returns an array containing the 1, 5, and 15 minute load averages. The
- * load average is a measure of CPU and IO utilization of the last one, five,
- * and 15 minute periods expressed as a fractional number. Zero means there
- * is no load. On Windows, the three values are always the same and represent
- * the current load, not the 1, 5 and 15 minute load averages.
- *
- * ```ts
- * console.log(Deno.loadavg()); // e.g. [ 0.71, 0.44, 0.44 ]
- * ```
- *
- * Requires `allow-env` permission.
- */
- export function loadavg(): number[];
-
- /** **Unstable** new API. yet to be vetted. Under consideration to possibly move to
- * Deno.build or Deno.versions and if it should depend sys-info, which may not
- * be desireable.
- *
- * Returns the release version of the Operating System.
- *
- * ```ts
- * console.log(Deno.osRelease());
- * ```
- *
- * Requires `allow-env` permission.
- *
- */
- export function osRelease(): string;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Open and initialize a plugin.
- *
- * ```ts
- * const rid = Deno.openPlugin("./path/to/some/plugin.so");
- * const opId = Deno.core.ops()["some_op"];
- * const response = Deno.core.dispatch(opId, new Uint8Array([1,2,3,4]));
- * console.log(`Response from plugin ${response}`);
- * ```
- *
- * Requires `allow-plugin` permission.
- *
- * The plugin system is not stable and will change in the future, hence the
- * lack of docs. For now take a look at the example
- * https://github.com/denoland/deno/tree/master/test_plugin
- */
- export function openPlugin(filename: string): number;
-
- /** The log category for a diagnostic message. */
- export enum DiagnosticCategory {
- Log = 0,
- Debug = 1,
- Info = 2,
- Error = 3,
- Warning = 4,
- Suggestion = 5,
- }
-
- export interface DiagnosticMessageChain {
- message: string;
- category: DiagnosticCategory;
- code: number;
- next?: DiagnosticMessageChain[];
- }
-
- export interface DiagnosticItem {
- /** A string message summarizing the diagnostic. */
- message: string;
- /** An ordered array of further diagnostics. */
- messageChain?: DiagnosticMessageChain;
- /** Information related to the diagnostic. This is present when there is a
- * suggestion or other additional diagnostic information */
- relatedInformation?: DiagnosticItem[];
- /** The text of the source line related to the diagnostic. */
- sourceLine?: string;
- /** The line number that is related to the diagnostic. */
- lineNumber?: number;
- /** The name of the script resource related to the diagnostic. */
- scriptResourceName?: string;
- /** The start position related to the diagnostic. */
- startPosition?: number;
- /** The end position related to the diagnostic. */
- endPosition?: number;
- /** The category of the diagnostic. */
- category: DiagnosticCategory;
- /** A number identifier. */
- code: number;
- /** The the start column of the sourceLine related to the diagnostic. */
- startColumn?: number;
- /** The end column of the sourceLine related to the diagnostic. */
- endColumn?: number;
- }
-
- export interface Diagnostic {
- /** An array of diagnostic items. */
- items: DiagnosticItem[];
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Format an array of diagnostic items and return them as a single string in a
- * user friendly format.
- *
- * ```ts
- * const [diagnostics, result] = Deno.compile("file_with_compile_issues.ts");
- * console.table(diagnostics); // Prints raw diagnostic data
- * console.log(Deno.formatDiagnostics(diagnostics)); // User friendly output of diagnostics
- * ```
- *
- * @param items An array of diagnostic items to format
- */
- export function formatDiagnostics(items: DiagnosticItem[]): string;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * A specific subset TypeScript compiler options that can be supported by the
- * Deno TypeScript compiler. */
- export interface CompilerOptions {
- /** Allow JavaScript files to be compiled. Defaults to `true`. */
- allowJs?: boolean;
- /** Allow default imports from modules with no default export. This does not
- * affect code emit, just typechecking. Defaults to `false`. */
- allowSyntheticDefaultImports?: boolean;
- /** Allow accessing UMD globals from modules. Defaults to `false`. */
- allowUmdGlobalAccess?: boolean;
- /** Do not report errors on unreachable code. Defaults to `false`. */
- allowUnreachableCode?: boolean;
- /** Do not report errors on unused labels. Defaults to `false` */
- allowUnusedLabels?: boolean;
- /** Parse in strict mode and emit `"use strict"` for each source file.
- * Defaults to `true`. */
- alwaysStrict?: boolean;
- /** Base directory to resolve non-relative module names. Defaults to
- * `undefined`. */
- baseUrl?: string;
- /** Report errors in `.js` files. Use in conjunction with `allowJs`. Defaults
- * to `false`. */
- checkJs?: boolean;
- /** Generates corresponding `.d.ts` file. Defaults to `false`. */
- declaration?: boolean;
- /** Output directory for generated declaration files. */
- declarationDir?: string;
- /** Generates a source map for each corresponding `.d.ts` file. Defaults to
- * `false`. */
- declarationMap?: boolean;
- /** Provide full support for iterables in `for..of`, spread and
- * destructuring when targeting ES5 or ES3. Defaults to `false`. */
- downlevelIteration?: boolean;
- /** Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files.
- * Defaults to `false`. */
- emitBOM?: boolean;
- /** Only emit `.d.ts` declaration files. Defaults to `false`. */
- emitDeclarationOnly?: boolean;
- /** Emit design-type metadata for decorated declarations in source. See issue
- * [microsoft/TypeScript#2577](https://github.com/Microsoft/TypeScript/issues/2577)
- * for details. Defaults to `false`. */
- emitDecoratorMetadata?: boolean;
- /** Emit `__importStar` and `__importDefault` helpers for runtime babel
- * ecosystem compatibility and enable `allowSyntheticDefaultImports` for type
- * system compatibility. Defaults to `true`. */
- esModuleInterop?: boolean;
- /** Enables experimental support for ES decorators. Defaults to `false`. */
- experimentalDecorators?: boolean;
- /** Emit a single file with source maps instead of having a separate file.
- * Defaults to `false`. */
- inlineSourceMap?: boolean;
- /** Emit the source alongside the source maps within a single file; requires
- * `inlineSourceMap` or `sourceMap` to be set. Defaults to `false`. */
- inlineSources?: boolean;
- /** Perform additional checks to ensure that transpile only would be safe.
- * Defaults to `false`. */
- isolatedModules?: boolean;
- /** Support JSX in `.tsx` files: `"react"`, `"preserve"`, `"react-native"`.
- * Defaults to `"react"`. */
- jsx?: "react" | "preserve" | "react-native";
- /** Specify the JSX factory function to use when targeting react JSX emit,
- * e.g. `React.createElement` or `h`. Defaults to `React.createElement`. */
- jsxFactory?: string;
- /** Resolve keyof to string valued property names only (no numbers or
- * symbols). Defaults to `false`. */
- keyofStringsOnly?: string;
- /** Emit class fields with ECMAScript-standard semantics. Defaults to `false`.
- * Does not apply to `"esnext"` target. */
- useDefineForClassFields?: boolean;
- /** List of library files to be included in the compilation. If omitted,
- * then the Deno main runtime libs are used. */
- lib?: string[];
- /** The locale to use to show error messages. */
- locale?: string;
- /** Specifies the location where debugger should locate map files instead of
- * generated locations. Use this flag if the `.map` files will be located at
- * run-time in a different location than the `.js` files. The location
- * specified will be embedded in the source map to direct the debugger where
- * the map files will be located. Defaults to `undefined`. */
- mapRoot?: string;
- /** Specify the module format for the emitted code. Defaults to
- * `"esnext"`. */
- module?:
- | "none"
- | "commonjs"
- | "amd"
- | "system"
- | "umd"
- | "es6"
- | "es2015"
- | "esnext";
- /** Do not generate custom helper functions like `__extends` in compiled
- * output. Defaults to `false`. */
- noEmitHelpers?: boolean;
- /** Report errors for fallthrough cases in switch statement. Defaults to
- * `false`. */
- noFallthroughCasesInSwitch?: boolean;
- /** Raise error on expressions and declarations with an implied any type.
- * Defaults to `true`. */
- noImplicitAny?: boolean;
- /** Report an error when not all code paths in function return a value.
- * Defaults to `false`. */
- noImplicitReturns?: boolean;
- /** Raise error on `this` expressions with an implied `any` type. Defaults to
- * `true`. */
- noImplicitThis?: boolean;
- /** Do not emit `"use strict"` directives in module output. Defaults to
- * `false`. */
- noImplicitUseStrict?: boolean;
- /** Do not add triple-slash references or module import targets to the list of
- * compiled files. Defaults to `false`. */
- noResolve?: boolean;
- /** Disable strict checking of generic signatures in function types. Defaults
- * to `false`. */
- noStrictGenericChecks?: boolean;
- /** Report errors on unused locals. Defaults to `false`. */
- noUnusedLocals?: boolean;
- /** Report errors on unused parameters. Defaults to `false`. */
- noUnusedParameters?: boolean;
- /** Redirect output structure to the directory. This only impacts
- * `Deno.compile` and only changes the emitted file names. Defaults to
- * `undefined`. */
- outDir?: string;
- /** List of path mapping entries for module names to locations relative to the
- * `baseUrl`. Defaults to `undefined`. */
- paths?: Record<string, string[]>;
- /** Do not erase const enum declarations in generated code. Defaults to
- * `false`. */
- preserveConstEnums?: boolean;
- /** Remove all comments except copy-right header comments beginning with
- * `/*!`. Defaults to `true`. */
- removeComments?: boolean;
- /** Include modules imported with `.json` extension. Defaults to `true`. */
- resolveJsonModule?: boolean;
- /** Specifies the root directory of input files. Only use to control the
- * output directory structure with `outDir`. Defaults to `undefined`. */
- rootDir?: string;
- /** List of _root_ folders whose combined content represent the structure of
- * the project at runtime. Defaults to `undefined`. */
- rootDirs?: string[];
- /** Generates corresponding `.map` file. Defaults to `false`. */
- sourceMap?: boolean;
- /** Specifies the location where debugger should locate TypeScript files
- * instead of source locations. Use this flag if the sources will be located
- * at run-time in a different location than that at design-time. The location
- * specified will be embedded in the sourceMap to direct the debugger where
- * the source files will be located. Defaults to `undefined`. */
- sourceRoot?: string;
- /** Enable all strict type checking options. Enabling `strict` enables
- * `noImplicitAny`, `noImplicitThis`, `alwaysStrict`, `strictBindCallApply`,
- * `strictNullChecks`, `strictFunctionTypes` and
- * `strictPropertyInitialization`. Defaults to `true`. */
- strict?: boolean;
- /** Enable stricter checking of the `bind`, `call`, and `apply` methods on
- * functions. Defaults to `true`. */
- strictBindCallApply?: boolean;
- /** Disable bivariant parameter checking for function types. Defaults to
- * `true`. */
- strictFunctionTypes?: boolean;
- /** Ensure non-undefined class properties are initialized in the constructor.
- * This option requires `strictNullChecks` be enabled in order to take effect.
- * Defaults to `true`. */
- strictPropertyInitialization?: boolean;
- /** In strict null checking mode, the `null` and `undefined` values are not in
- * the domain of every type and are only assignable to themselves and `any`
- * (the one exception being that `undefined` is also assignable to `void`). */
- strictNullChecks?: boolean;
- /** Suppress excess property checks for object literals. Defaults to
- * `false`. */
- suppressExcessPropertyErrors?: boolean;
- /** Suppress `noImplicitAny` errors for indexing objects lacking index
- * signatures. */
- suppressImplicitAnyIndexErrors?: boolean;
- /** Specify ECMAScript target version. Defaults to `esnext`. */
- target?:
- | "es3"
- | "es5"
- | "es6"
- | "es2015"
- | "es2016"
- | "es2017"
- | "es2018"
- | "es2019"
- | "es2020"
- | "esnext";
- /** List of names of type definitions to include. Defaults to `undefined`.
- *
- * The type definitions are resolved according to the normal Deno resolution
- * irrespective of if sources are provided on the call. Like other Deno
- * modules, there is no "magical" resolution. For example:
- *
- * ```ts
- * Deno.compile(
- * "./foo.js",
- * undefined,
- * {
- * types: [ "./foo.d.ts", "https://deno.land/x/example/types.d.ts" ]
- * }
- * );
- * ```
- */
- types?: string[];
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * The results of a transpile only command, where the `source` contains the
- * emitted source, and `map` optionally contains the source map. */
- export interface TranspileOnlyResult {
- source: string;
- map?: string;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Takes a set of TypeScript sources and resolves to a map where the key was
- * the original file name provided in sources and the result contains the
- * `source` and optionally the `map` from the transpile operation. This does no
- * type checking and validation, it effectively "strips" the types from the
- * file.
- *
- * ```ts
- * const results = await Deno.transpileOnly({
- * "foo.ts": `const foo: string = "foo";`
- * });
- * ```
- *
- * @param sources A map where the key is the filename and the value is the text
- * to transpile. The filename is only used in the transpile and
- * not resolved, for example to fill in the source name in the
- * source map.
- * @param options An option object of options to send to the compiler. This is
- * a subset of ts.CompilerOptions which can be supported by Deno.
- * Many of the options related to type checking and emitting
- * type declaration files will have no impact on the output.
- */
- export function transpileOnly(
- sources: Record<string, string>,
- options?: CompilerOptions,
- ): Promise<Record<string, TranspileOnlyResult>>;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Takes a root module name, and optionally a record set of sources. Resolves
- * with a compiled set of modules and possibly diagnostics if the compiler
- * encountered any issues. If just a root name is provided, the modules
- * will be resolved as if the root module had been passed on the command line.
- *
- * If sources are passed, all modules will be resolved out of this object, where
- * the key is the module name and the value is the content. The extension of
- * the module name will be used to determine the media type of the module.
- *
- * ```ts
- * const [ maybeDiagnostics1, output1 ] = await Deno.compile("foo.ts");
- *
- * const [ maybeDiagnostics2, output2 ] = await Deno.compile("/foo.ts", {
- * "/foo.ts": `export * from "./bar.ts";`,
- * "/bar.ts": `export const bar = "bar";`
- * });
- * ```
- *
- * @param rootName The root name of the module which will be used as the
- * "starting point". If no `sources` is specified, Deno will
- * resolve the module externally as if the `rootName` had been
- * specified on the command line.
- * @param sources An optional key/value map of sources to be used when resolving
- * modules, where the key is the module name, and the value is
- * the source content. The extension of the key will determine
- * the media type of the file when processing. If supplied,
- * Deno will not attempt to resolve any modules externally.
- * @param options An optional object of options to send to the compiler. This is
- * a subset of ts.CompilerOptions which can be supported by Deno.
- */
- export function compile(
- rootName: string,
- sources?: Record<string, string>,
- options?: CompilerOptions,
- ): Promise<[DiagnosticItem[] | undefined, Record<string, string>]>;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * `bundle()` is part the compiler API. A full description of this functionality
- * can be found in the [manual](https://deno.land/manual/runtime/compiler_apis#denobundle).
- *
- * Takes a root module name, and optionally a record set of sources. Resolves
- * with a single JavaScript string (and bundle diagnostics if issues arise with
- * the bundling) that is like the output of a `deno bundle` command. If just
- * a root name is provided, the modules will be resolved as if the root module
- * had been passed on the command line.
- *
- * If sources are passed, all modules will be resolved out of this object, where
- * the key is the module name and the value is the content. The extension of the
- * module name will be used to determine the media type of the module.
- *
- * ```ts
- * // equivalent to "deno bundle foo.ts" from the command line
- * const [ maybeDiagnostics1, output1 ] = await Deno.bundle("foo.ts");
- *
- * const [ maybeDiagnostics2, output2 ] = await Deno.bundle("/foo.ts", {
- * "/foo.ts": `export * from "./bar.ts";`,
- * "/bar.ts": `export const bar = "bar";`
- * });
- * ```
- *
- * @param rootName The root name of the module which will be used as the
- * "starting point". If no `sources` is specified, Deno will
- * resolve the module externally as if the `rootName` had been
- * specified on the command line.
- * @param sources An optional key/value map of sources to be used when resolving
- * modules, where the key is the module name, and the value is
- * the source content. The extension of the key will determine
- * the media type of the file when processing. If supplied,
- * Deno will not attempt to resolve any modules externally.
- * @param options An optional object of options to send to the compiler. This is
- * a subset of ts.CompilerOptions which can be supported by Deno.
- */
- export function bundle(
- rootName: string,
- sources?: Record<string, string>,
- options?: CompilerOptions,
- ): Promise<[DiagnosticItem[] | undefined, string]>;
-
- /** **UNSTABLE**: Should not have same name as `window.location` type. */
- interface Location {
- /** The full url for the module, e.g. `file://some/file.ts` or
- * `https://some/file.ts`. */
- fileName: string;
- /** The line number in the file. It is assumed to be 1-indexed. */
- lineNumber: number;
- /** The column number in the file. It is assumed to be 1-indexed. */
- columnNumber: number;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Given a current location in a module, lookup the source location and return
- * it.
- *
- * When Deno transpiles code, it keep source maps of the transpiled code. This
- * function can be used to lookup the original location. This is
- * automatically done when accessing the `.stack` of an error, or when an
- * uncaught error is logged. This function can be used to perform the lookup
- * for creating better error handling.
- *
- * **Note:** `line` and `column` are 1 indexed, which matches display
- * expectations, but is not typical of most index numbers in Deno.
- *
- * An example:
- *
- * ```ts
- * const orig = Deno.applySourceMap({
- * fileName: "file://my/module.ts",
- * lineNumber: 5,
- * columnNumber: 15
- * });
- * console.log(`${orig.filename}:${orig.line}:${orig.column}`);
- * ```
- */
- export function applySourceMap(location: Location): Location;
-
- enum LinuxSignal {
- SIGHUP = 1,
- SIGINT = 2,
- SIGQUIT = 3,
- SIGILL = 4,
- SIGTRAP = 5,
- SIGABRT = 6,
- SIGBUS = 7,
- SIGFPE = 8,
- SIGKILL = 9,
- SIGUSR1 = 10,
- SIGSEGV = 11,
- SIGUSR2 = 12,
- SIGPIPE = 13,
- SIGALRM = 14,
- SIGTERM = 15,
- SIGSTKFLT = 16,
- SIGCHLD = 17,
- SIGCONT = 18,
- SIGSTOP = 19,
- SIGTSTP = 20,
- SIGTTIN = 21,
- SIGTTOU = 22,
- SIGURG = 23,
- SIGXCPU = 24,
- SIGXFSZ = 25,
- SIGVTALRM = 26,
- SIGPROF = 27,
- SIGWINCH = 28,
- SIGIO = 29,
- SIGPWR = 30,
- SIGSYS = 31,
- }
- enum MacOSSignal {
- SIGHUP = 1,
- SIGINT = 2,
- SIGQUIT = 3,
- SIGILL = 4,
- SIGTRAP = 5,
- SIGABRT = 6,
- SIGEMT = 7,
- SIGFPE = 8,
- SIGKILL = 9,
- SIGBUS = 10,
- SIGSEGV = 11,
- SIGSYS = 12,
- SIGPIPE = 13,
- SIGALRM = 14,
- SIGTERM = 15,
- SIGURG = 16,
- SIGSTOP = 17,
- SIGTSTP = 18,
- SIGCONT = 19,
- SIGCHLD = 20,
- SIGTTIN = 21,
- SIGTTOU = 22,
- SIGIO = 23,
- SIGXCPU = 24,
- SIGXFSZ = 25,
- SIGVTALRM = 26,
- SIGPROF = 27,
- SIGWINCH = 28,
- SIGINFO = 29,
- SIGUSR1 = 30,
- SIGUSR2 = 31,
- }
-
- /** **UNSTABLE**: Further changes required to make platform independent.
- *
- * Signals numbers. This is platform dependent. */
- export const Signal: typeof MacOSSignal | typeof LinuxSignal;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Represents the stream of signals, implements both `AsyncIterator` and
- * `PromiseLike`. */
- export class SignalStream
- implements AsyncIterableIterator<void>, PromiseLike<void> {
- constructor(signal: typeof Deno.Signal);
- then<T, S>(
- f: (v: void) => T | Promise<T>,
- g?: (v: void) => S | Promise<S>,
- ): Promise<T | S>;
- next(): Promise<IteratorResult<void>>;
- [Symbol.asyncIterator](): AsyncIterableIterator<void>;
- dispose(): void;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Returns the stream of the given signal number. You can use it as an async
- * iterator.
- *
- * ```ts
- * for await (const _ of Deno.signal(Deno.Signal.SIGTERM)) {
- * console.log("got SIGTERM!");
- * }
- * ```
- *
- * You can also use it as a promise. In this case you can only receive the
- * first one.
- *
- * ```ts
- * await Deno.signal(Deno.Signal.SIGTERM);
- * console.log("SIGTERM received!")
- * ```
- *
- * If you want to stop receiving the signals, you can use `.dispose()` method
- * of the signal stream object.
- *
- * ```ts
- * const sig = Deno.signal(Deno.Signal.SIGTERM);
- * setTimeout(() => { sig.dispose(); }, 5000);
- * for await (const _ of sig) {
- * console.log("SIGTERM!")
- * }
- * ```
- *
- * The above for-await loop exits after 5 seconds when `sig.dispose()` is
- * called.
- *
- * NOTE: This functionality is not yet implemented on Windows.
- */
- export function signal(signo: number): SignalStream;
-
- /** **UNSTABLE**: new API, yet to be vetted. */
- export const signals: {
- /** Returns the stream of SIGALRM signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGALRM)`. */
- alarm: () => SignalStream;
- /** Returns the stream of SIGCHLD signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGCHLD)`. */
- child: () => SignalStream;
- /** Returns the stream of SIGHUP signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGHUP)`. */
- hungup: () => SignalStream;
- /** Returns the stream of SIGINT signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGINT)`. */
- interrupt: () => SignalStream;
- /** Returns the stream of SIGIO signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGIO)`. */
- io: () => SignalStream;
- /** Returns the stream of SIGPIPE signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGPIPE)`. */
- pipe: () => SignalStream;
- /** Returns the stream of SIGQUIT signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGQUIT)`. */
- quit: () => SignalStream;
- /** Returns the stream of SIGTERM signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGTERM)`. */
- terminate: () => SignalStream;
- /** Returns the stream of SIGUSR1 signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGUSR1)`. */
- userDefined1: () => SignalStream;
- /** Returns the stream of SIGUSR2 signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGUSR2)`. */
- userDefined2: () => SignalStream;
- /** Returns the stream of SIGWINCH signals.
- *
- * This method is the shorthand for `Deno.signal(Deno.Signal.SIGWINCH)`. */
- windowChange: () => SignalStream;
- };
-
- /** **UNSTABLE**: new API, yet to be vetted
- *
- * Set TTY to be under raw mode or not. In raw mode, characters are read and
- * returned as is, without being processed. All special processing of
- * characters by the terminal is disabled, including echoing input characters.
- * Reading from a TTY device in raw mode is faster than reading from a TTY
- * device in canonical mode.
- *
- * ```ts
- * Deno.setRaw(myTTY.rid, true);
- * ```
- */
- export function setRaw(rid: number, mode: boolean): void;
-
- /** **UNSTABLE**: needs investigation into high precision time.
- *
- * Synchronously changes the access (`atime`) and modification (`mtime`) times
- * of a file system object referenced by `path`. Given times are either in
- * seconds (UNIX epoch time) or as `Date` objects.
- *
- * ```ts
- * Deno.utimeSync("myfile.txt", 1556495550, new Date());
- * ```
- *
- * Requires `allow-write` permission. */
- export function utimeSync(
- path: string,
- atime: number | Date,
- mtime: number | Date,
- ): void;
-
- /** **UNSTABLE**: needs investigation into high precision time.
- *
- * Changes the access (`atime`) and modification (`mtime`) times of a file
- * system object referenced by `path`. Given times are either in seconds
- * (UNIX epoch time) or as `Date` objects.
- *
- * ```ts
- * await Deno.utime("myfile.txt", 1556495550, new Date());
- * ```
- *
- * Requires `allow-write` permission. */
- export function utime(
- path: string,
- atime: number | Date,
- mtime: number | Date,
- ): Promise<void>;
-
- /** **UNSTABLE**: Under consideration to remove `ShutdownMode` entirely.
- *
- * Corresponds to `SHUT_RD`, `SHUT_WR`, `SHUT_RDWR` on POSIX-like systems.
- *
- * See: http://man7.org/linux/man-pages/man2/shutdown.2.html */
- export enum ShutdownMode {
- Read = 0,
- Write,
- ReadWrite, // TODO(ry) panics on ReadWrite.
- }
-
- /** **UNSTABLE**: Both the `how` parameter and `ShutdownMode` enum are under
- * consideration for removal.
- *
- * Shutdown socket send and receive operations.
- *
- * Matches behavior of POSIX shutdown(3).
- *
- * ```ts
- * const listener = Deno.listen({ port: 80 });
- * const conn = await listener.accept();
- * Deno.shutdown(conn.rid, Deno.ShutdownMode.Write);
- * ```
- */
- export function shutdown(rid: number, how: ShutdownMode): Promise<void>;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * A generic transport listener for message-oriented protocols. */
- export interface DatagramConn extends AsyncIterable<[Uint8Array, Addr]> {
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Waits for and resolves to the next message to the `UDPConn`. */
- receive(p?: Uint8Array): Promise<[Uint8Array, Addr]>;
- /** UNSTABLE: new API, yet to be vetted.
- *
- * Sends a message to the target. */
- send(p: Uint8Array, addr: Addr): Promise<number>;
- /** UNSTABLE: new API, yet to be vetted.
- *
- * Close closes the socket. Any pending message promises will be rejected
- * with errors. */
- close(): void;
- /** Return the address of the `UDPConn`. */
- readonly addr: Addr;
- [Symbol.asyncIterator](): AsyncIterableIterator<[Uint8Array, Addr]>;
- }
-
- export interface UnixListenOptions {
- /** A Path to the Unix Socket. */
- path: string;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Listen announces on the local transport address.
- *
- * ```ts
- * const listener = Deno.listen({ path: "/foo/bar.sock", transport: "unix" })
- * ```
- *
- * Requires `allow-read` and `allow-write` permission. */
- export function listen(
- options: UnixListenOptions & { transport: "unix" },
- ): Listener;
-
- /** **UNSTABLE**: new API, yet to be vetted
- *
- * Listen announces on the local transport address.
- *
- * ```ts
- * const listener1 = Deno.listenDatagram({
- * port: 80,
- * transport: "udp"
- * });
- * const listener2 = Deno.listenDatagram({
- * hostname: "golang.org",
- * port: 80,
- * transport: "udp"
- * });
- * ```
- *
- * Requires `allow-net` permission. */
- export function listenDatagram(
- options: ListenOptions & { transport: "udp" },
- ): DatagramConn;
-
- /** **UNSTABLE**: new API, yet to be vetted
- *
- * Listen announces on the local transport address.
- *
- * ```ts
- * const listener = Deno.listenDatagram({
- * address: "/foo/bar.sock",
- * transport: "unixpacket"
- * });
- * ```
- *
- * Requires `allow-read` and `allow-write` permission. */
- export function listenDatagram(
- options: UnixListenOptions & { transport: "unixpacket" },
- ): DatagramConn;
-
- export interface UnixConnectOptions {
- transport: "unix";
- path: string;
- }
-
- /** **UNSTABLE**: The unix socket transport is unstable as a new API yet to
- * be vetted. The TCP transport is considered stable.
- *
- * Connects to the hostname (default is "127.0.0.1") and port on the named
- * transport (default is "tcp"), and resolves to the connection (`Conn`).
- *
- * ```ts
- * const conn1 = await Deno.connect({ port: 80 });
- * const conn2 = await Deno.connect({ hostname: "192.0.2.1", port: 80 });
- * const conn3 = await Deno.connect({ hostname: "[2001:db8::1]", port: 80 });
- * const conn4 = await Deno.connect({ hostname: "golang.org", port: 80, transport: "tcp" });
- * const conn5 = await Deno.connect({ path: "/foo/bar.sock", transport: "unix" });
- * ```
- *
- * Requires `allow-net` permission for "tcp" and `allow-read` for "unix". */
- export function connect(
- options: ConnectOptions | UnixConnectOptions,
- ): Promise<Conn>;
-
- export interface StartTlsOptions {
- /** A literal IP address or host name that can be resolved to an IP address.
- * If not specified, defaults to `127.0.0.1`. */
- hostname?: string;
- /** Server certificate file. */
- certFile?: string;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Start TLS handshake from an existing connection using
- * an optional cert file, hostname (default is "127.0.0.1"). The
- * cert file is optional and if not included Mozilla's root certificates will
- * be used (see also https://github.com/ctz/webpki-roots for specifics)
- * Using this function requires that the other end of the connection is
- * prepared for TLS handshake.
- *
- * ```ts
- * const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
- * const tlsConn = await Deno.startTls(conn, { certFile: "./certs/my_custom_root_CA.pem", hostname: "127.0.0.1", port: 80 });
- * ```
- *
- * Requires `allow-net` permission.
- */
- export function startTls(
- conn: Conn,
- options?: StartTlsOptions,
- ): Promise<Conn>;
-
- /** **UNSTABLE**: The `signo` argument may change to require the Deno.Signal
- * enum.
- *
- * Send a signal to process under given `pid`. This functionality currently
- * only works on Linux and Mac OS.
- *
- * If `pid` is negative, the signal will be sent to the process group
- * identified by `pid`.
- *
- * const p = Deno.run({
- * cmd: ["python", "-c", "from time import sleep; sleep(10000)"]
- * });
- *
- * Deno.kill(p.pid, Deno.Signal.SIGINT);
- *
- * Requires `allow-run` permission. */
- export function kill(pid: number, signo: number): void;
-
- /** The name of a "powerful feature" which needs permission.
- *
- * See: https://w3c.github.io/permissions/#permission-registry
- *
- * Note that the definition of `PermissionName` in the above spec is swapped
- * out for a set of Deno permissions which are not web-compatible. */
- export type PermissionName =
- | "run"
- | "read"
- | "write"
- | "net"
- | "env"
- | "plugin"
- | "hrtime";
-
- /** The current status of the permission.
- *
- * See: https://w3c.github.io/permissions/#status-of-a-permission */
- export type PermissionState = "granted" | "denied" | "prompt";
-
- export interface RunPermissionDescriptor {
- name: "run";
- }
-
- export interface ReadPermissionDescriptor {
- name: "read";
- path?: string;
- }
-
- export interface WritePermissionDescriptor {
- name: "write";
- path?: string;
- }
-
- export interface NetPermissionDescriptor {
- name: "net";
- /** Optional url associated with this descriptor.
- *
- * If specified: must be a valid url. Expected format: <scheme>://<host_or_ip>[:port][/path]
- * If the scheme is unknown, callers should specify some scheme, such as x:// na:// unknown://
- *
- * See: https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml */
- url?: string;
- }
-
- export interface EnvPermissionDescriptor {
- name: "env";
- }
-
- export interface PluginPermissionDescriptor {
- name: "plugin";
- }
-
- export interface HrtimePermissionDescriptor {
- name: "hrtime";
- }
-
- /** Permission descriptors which define a permission and can be queried,
- * requested, or revoked.
- *
- * See: https://w3c.github.io/permissions/#permission-descriptor */
- export type PermissionDescriptor =
- | RunPermissionDescriptor
- | ReadPermissionDescriptor
- | WritePermissionDescriptor
- | NetPermissionDescriptor
- | EnvPermissionDescriptor
- | PluginPermissionDescriptor
- | HrtimePermissionDescriptor;
-
- export class Permissions {
- /** Resolves to the current status of a permission.
- *
- * ```ts
- * const status = await Deno.permissions.query({ name: "read", path: "/etc" });
- * if (status.state === "granted") {
- * data = await Deno.readFile("/etc/passwd");
- * }
- * ```
- */
- query(desc: PermissionDescriptor): Promise<PermissionStatus>;
-
- /** Revokes a permission, and resolves to the state of the permission.
- *
- * const status = await Deno.permissions.revoke({ name: "run" });
- * assert(status.state !== "granted")
- */
- revoke(desc: PermissionDescriptor): Promise<PermissionStatus>;
-
- /** Requests the permission, and resolves to the state of the permission.
- *
- * ```ts
- * const status = await Deno.permissions.request({ name: "env" });
- * if (status.state === "granted") {
- * console.log(Deno.dir("home");
- * } else {
- * console.log("'env' permission is denied.");
- * }
- * ```
- */
- request(desc: PermissionDescriptor): Promise<PermissionStatus>;
- }
-
- /** **UNSTABLE**: Under consideration to move to `navigator.permissions` to
- * match web API. It could look like `navigator.permissions.query({ name: Deno.symbols.read })`.
- */
- export const permissions: Permissions;
-
- /** see: https://w3c.github.io/permissions/#permissionstatus */
- export class PermissionStatus {
- state: PermissionState;
- constructor(state: PermissionState);
- }
-
- /** **UNSTABLE**: New API, yet to be vetted. Additional consideration is still
- * necessary around the permissions required.
- *
- * Get the `hostname` of the machine the Deno process is running on.
- *
- * ```ts
- * console.log(Deno.hostname());
- * ```
- *
- * Requires `allow-env` permission.
- */
- export function hostname(): string;
-
- /** **UNSTABLE**: The URL of the file that was originally executed from the command-line. */
- export const mainModule: string;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- * Synchronously truncates or extends the specified file stream, to reach the
- * specified `len`. If `len` is not specified then the entire file contents
- * are truncated.
- *
- * ```ts
- * // truncate the entire file
- * const file = Deno.open("my_file.txt", { read: true, write: true, truncate: true, create: true });
- * Deno.ftruncateSync(file.rid);
- *
- * // truncate part of the file
- * const file = Deno.open("my_file.txt", { read: true, write: true, create: true });
- * Deno.write(file.rid, new TextEncoder().encode("Hello World"));
- * Deno.ftruncateSync(file.rid, 7);
- * const data = new Uint8Array(32);
- * Deno.readSync(file.rid, data);
- * console.log(new TextDecoder().decode(data)); // Hello W
- * ```
- */
- export function ftruncateSync(rid: number, len?: number): void;
-
- /** **UNSTABLE**: new API, yet to be vetted.
- * Truncates or extends the specified file stream, to reach the specified `len`. If
- * `len` is not specified then the entire file contents are truncated.
- *
- * ```ts
- * // truncate the entire file
- * const file = Deno.open("my_file.txt", { read: true, write: true, create: true });
- * await Deno.ftruncate(file.rid);
- *
- * // truncate part of the file
- * const file = Deno.open("my_file.txt", { read: true, write: true, create: true });
- * await Deno.write(file.rid, new TextEncoder().encode("Hello World"));
- * await Deno.ftruncate(file.rid, 7);
- * const data = new Uint8Array(32);
- * await Deno.read(file.rid, data);
- * console.log(new TextDecoder().decode(data)); // Hello W
- * ```
- */
- export function ftruncate(rid: number, len?: number): Promise<void>;
-
- /* **UNSTABLE**: New API, yet to be vetted.
- * Synchronously flushes any pending data operations of the given file stream to disk.
- * ```ts
- * const file = Deno.openSync("my_file.txt", { read: true, write: true, create: true });
- * Deno.writeSync(file.rid, new TextEncoder().encode("Hello World"));
- * Deno.fdatasyncSync(file.rid);
- * console.log(new TextDecoder().decode(Deno.readFileSync("my_file.txt"))); // Hello World
- * ```
- */
- export function fdatasyncSync(rid: number): void;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- * Flushes any pending data operations of the given file stream to disk.
- * ```ts
- * const file = await Deno.open("my_file.txt", { read: true, write: true, create: true });
- * await Deno.write(file.rid, new TextEncoder().encode("Hello World"));
- * await Deno.fdatasync(file.rid);
- * console.log(new TextDecoder().decode(await Deno.readFile("my_file.txt"))); // Hello World
- * ```
- */
- export function fdatasync(rid: number): Promise<void>;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- * Synchronously flushes any pending data and metadata operations of the given file stream to disk.
- * ```ts
- * const file = Deno.openSync("my_file.txt", { read: true, write: true, create: true });
- * Deno.writeSync(file.rid, new TextEncoder().encode("Hello World"));
- * Deno.ftruncateSync(file.rid, 1);
- * Deno.fsyncSync(file.rid);
- * console.log(new TextDecoder().decode(Deno.readFileSync("my_file.txt"))); // H
- * ```
- */
- export function fsyncSync(rid: number): void;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- * Flushes any pending data and metadata operations of the given file stream to disk.
- * ```ts
- * const file = await Deno.open("my_file.txt", { read: true, write: true, create: true });
- * await Deno.write(file.rid, new TextEncoder().encode("Hello World"));
- * await Deno.ftruncate(file.rid, 1);
- * await Deno.fsync(file.rid);
- * console.log(new TextDecoder().decode(await Deno.readFile("my_file.txt"))); // H
- * ```
- */
- export function fsync(rid: number): Promise<void>;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- * Synchronously returns a `Deno.FileInfo` for the given file stream.
- *
- * ```ts
- * const file = Deno.openSync("file.txt", { read: true });
- * const fileInfo = Deno.fstatSync(file.rid);
- * assert(fileInfo.isFile);
- * ```
- */
- export function fstatSync(rid: number): FileInfo;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- * Returns a `Deno.FileInfo` for the given file stream.
- *
- * ```ts
- * const file = await Deno.open("file.txt", { read: true });
- * const fileInfo = await Deno.fstat(file.rid);
- * assert(fileInfo.isFile);
- * ```
- */
- export function fstat(rid: number): Promise<FileInfo>;
-
- /** **UNSTABLE**: New API, yet to be vetted.
- * The pid of the current process's parent.
- */
- export const ppid: number;
-}
diff --git a/cli/js2/lib.deno.window.d.ts b/cli/js2/lib.deno.window.d.ts
deleted file mode 100644
index 61c5abf8a..000000000
--- a/cli/js2/lib.deno.window.d.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/// <reference no-default-lib="true" />
-/// <reference lib="deno.ns" />
-/// <reference lib="deno.shared_globals" />
-/// <reference lib="esnext" />
-
-declare interface Window extends EventTarget {
- readonly window: Window & typeof globalThis;
- readonly self: Window & typeof globalThis;
- onload: ((this: Window, ev: Event) => any) | null;
- onunload: ((this: Window, ev: Event) => any) | null;
- close: () => void;
- readonly closed: boolean;
- Deno: typeof Deno;
-}
-
-declare const window: Window & typeof globalThis;
-declare const self: Window & typeof globalThis;
-declare const onload: ((this: Window, ev: Event) => any) | null;
-declare const onunload: ((this: Window, ev: Event) => any) | null;
-
-/* eslint-enable @typescript-eslint/no-explicit-any */
diff --git a/cli/js2/lib.deno.worker.d.ts b/cli/js2/lib.deno.worker.d.ts
deleted file mode 100644
index 95aa16139..000000000
--- a/cli/js2/lib.deno.worker.d.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any */
-
-/// <reference no-default-lib="true" />
-/// <reference lib="deno.ns" />
-/// <reference lib="deno.shared_globals" />
-/// <reference lib="esnext" />
-
-declare interface DedicatedWorkerGlobalScope {
- self: DedicatedWorkerGlobalScope & typeof globalThis;
- onmessage: (e: MessageEvent) => void;
- onmessageerror: (e: MessageEvent) => void;
- onerror: undefined | typeof onerror;
- name: typeof __workerMain.name;
- close: typeof __workerMain.close;
- postMessage: typeof __workerMain.postMessage;
- Deno: typeof Deno;
-}
-
-declare const self: DedicatedWorkerGlobalScope & typeof globalThis;
-declare let onmessage: ((e: { data: any }) => Promise<void> | void) | undefined;
-declare let onerror:
- | ((
- msg: string,
- source: string,
- lineno: number,
- colno: number,
- e: Event,
- ) => boolean | void)
- | undefined;
-declare const close: typeof __workerMain.close;
-declare const name: typeof __workerMain.name;
-declare const postMessage: typeof __workerMain.postMessage;
-
-declare namespace __workerMain {
- export let onmessage: (e: { data: any }) => void;
- export function postMessage(data: any): void;
- export function close(): void;
- export const name: string;
-}
-
-/* eslint-enable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any */