+ Press n or j to go to the next uncovered block, b, p or k for the previous block.
+
+
+
+ Filter:
+
+
+
+
+
+
+
+
+
+
File
+
+
Statements
+
+
Branches
+
+
Functions
+
+
Lines
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/example/simple-http-page/coverage/lcov-report/prettify.css b/example/simple-http-page/coverage/lcov-report/prettify.css
new file mode 100644
index 0000000..b317a7c
--- /dev/null
+++ b/example/simple-http-page/coverage/lcov-report/prettify.css
@@ -0,0 +1 @@
+.pln{color:#000}@media screen{.str{color:#080}.kwd{color:#008}.com{color:#800}.typ{color:#606}.lit{color:#066}.pun,.opn,.clo{color:#660}.tag{color:#008}.atn{color:#606}.atv{color:#080}.dec,.var{color:#606}.fun{color:red}}@media print,projection{.str{color:#060}.kwd{color:#006;font-weight:bold}.com{color:#600;font-style:italic}.typ{color:#404;font-weight:bold}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:bold}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8{list-style-type:none}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee}
diff --git a/example/simple-http-page/coverage/lcov-report/prettify.js b/example/simple-http-page/coverage/lcov-report/prettify.js
new file mode 100644
index 0000000..b322523
--- /dev/null
+++ b/example/simple-http-page/coverage/lcov-report/prettify.js
@@ -0,0 +1,2 @@
+/* eslint-disable */
+window.PR_SHOULD_USE_CONTINUATION=true;(function(){var h=["break,continue,do,else,for,if,return,while"];var u=[h,"auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"];var p=[u,"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"];var l=[p,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"];var x=[p,"abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient"];var R=[x,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var"];var r="all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,true,try,unless,until,when,while,yes";var w=[p,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"];var s="caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END";var I=[h,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"];var f=[h,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"];var H=[h,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"];var A=[l,R,w,s+I,f,H];var e=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)/;var C="str";var z="kwd";var j="com";var O="typ";var G="lit";var L="pun";var F="pln";var m="tag";var E="dec";var J="src";var P="atn";var n="atv";var N="nocode";var M="(?:^^\\.?|[+-]|\\!|\\!=|\\!==|\\#|\\%|\\%=|&|&&|&&=|&=|\\(|\\*|\\*=|\\+=|\\,|\\-=|\\->|\\/|\\/=|:|::|\\;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|\\?|\\@|\\[|\\^|\\^=|\\^\\^|\\^\\^=|\\{|\\||\\|=|\\|\\||\\|\\|=|\\~|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*";function k(Z){var ad=0;var S=false;var ac=false;for(var V=0,U=Z.length;V122)){if(!(al<65||ag>90)){af.push([Math.max(65,ag)|32,Math.min(al,90)|32])}if(!(al<97||ag>122)){af.push([Math.max(97,ag)&~32,Math.min(al,122)&~32])}}}}af.sort(function(av,au){return(av[0]-au[0])||(au[1]-av[1])});var ai=[];var ap=[NaN,NaN];for(var ar=0;arat[0]){if(at[1]+1>at[0]){an.push("-")}an.push(T(at[1]))}}an.push("]");return an.join("")}function W(al){var aj=al.source.match(new RegExp("(?:\\[(?:[^\\x5C\\x5D]|\\\\[\\s\\S])*\\]|\\\\u[A-Fa-f0-9]{4}|\\\\x[A-Fa-f0-9]{2}|\\\\[0-9]+|\\\\[^ux0-9]|\\(\\?[:!=]|[\\(\\)\\^]|[^\\x5B\\x5C\\(\\)\\^]+)","g"));var ah=aj.length;var an=[];for(var ak=0,am=0;ak=2&&ai==="["){aj[ak]=X(ag)}else{if(ai!=="\\"){aj[ak]=ag.replace(/[a-zA-Z]/g,function(ao){var ap=ao.charCodeAt(0);return"["+String.fromCharCode(ap&~32,ap|32)+"]"})}}}}return aj.join("")}var aa=[];for(var V=0,U=Z.length;V=0;){S[ac.charAt(ae)]=Y}}var af=Y[1];var aa=""+af;if(!ag.hasOwnProperty(aa)){ah.push(af);ag[aa]=null}}ah.push(/[\0-\uffff]/);V=k(ah)})();var X=T.length;var W=function(ah){var Z=ah.sourceCode,Y=ah.basePos;var ad=[Y,F];var af=0;var an=Z.match(V)||[];var aj={};for(var ae=0,aq=an.length;ae=5&&"lang-"===ap.substring(0,5);if(am&&!(ai&&typeof ai[1]==="string")){am=false;ap=J}if(!am){aj[ag]=ap}}var ab=af;af+=ag.length;if(!am){ad.push(Y+ab,ap)}else{var al=ai[1];var ak=ag.indexOf(al);var ac=ak+al.length;if(ai[2]){ac=ag.length-ai[2].length;ak=ac-al.length}var ar=ap.substring(5);B(Y+ab,ag.substring(0,ak),W,ad);B(Y+ab+ak,al,q(ar,al),ad);B(Y+ab+ac,ag.substring(ac),W,ad)}}ah.decorations=ad};return W}function i(T){var W=[],S=[];if(T.tripleQuotedStrings){W.push([C,/^(?:\'\'\'(?:[^\'\\]|\\[\s\S]|\'{1,2}(?=[^\']))*(?:\'\'\'|$)|\"\"\"(?:[^\"\\]|\\[\s\S]|\"{1,2}(?=[^\"]))*(?:\"\"\"|$)|\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$))/,null,"'\""])}else{if(T.multiLineStrings){W.push([C,/^(?:\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$)|\`(?:[^\\\`]|\\[\s\S])*(?:\`|$))/,null,"'\"`"])}else{W.push([C,/^(?:\'(?:[^\\\'\r\n]|\\.)*(?:\'|$)|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/,null,"\"'"])}}if(T.verbatimStrings){S.push([C,/^@\"(?:[^\"]|\"\")*(?:\"|$)/,null])}var Y=T.hashComments;if(Y){if(T.cStyleComments){if(Y>1){W.push([j,/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,null,"#"])}else{W.push([j,/^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\r\n]*)/,null,"#"])}S.push([C,/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,null])}else{W.push([j,/^#[^\r\n]*/,null,"#"])}}if(T.cStyleComments){S.push([j,/^\/\/[^\r\n]*/,null]);S.push([j,/^\/\*[\s\S]*?(?:\*\/|$)/,null])}if(T.regexLiterals){var X=("/(?=[^/*])(?:[^/\\x5B\\x5C]|\\x5C[\\s\\S]|\\x5B(?:[^\\x5C\\x5D]|\\x5C[\\s\\S])*(?:\\x5D|$))+/");S.push(["lang-regex",new RegExp("^"+M+"("+X+")")])}var V=T.types;if(V){S.push([O,V])}var U=(""+T.keywords).replace(/^ | $/g,"");if(U.length){S.push([z,new RegExp("^(?:"+U.replace(/[\s,]+/g,"|")+")\\b"),null])}W.push([F,/^\s+/,null," \r\n\t\xA0"]);S.push([G,/^@[a-z_$][a-z_$@0-9]*/i,null],[O,/^(?:[@_]?[A-Z]+[a-z][A-Za-z_$@0-9]*|\w+_t\b)/,null],[F,/^[a-z_$][a-z_$@0-9]*/i,null],[G,new RegExp("^(?:0x[a-f0-9]+|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)(?:e[+\\-]?\\d+)?)[a-z]*","i"),null,"0123456789"],[F,/^\\[\s\S]?/,null],[L,/^.[^\s\w\.$@\'\"\`\/\#\\]*/,null]);return g(W,S)}var K=i({keywords:A,hashComments:true,cStyleComments:true,multiLineStrings:true,regexLiterals:true});function Q(V,ag){var U=/(?:^|\s)nocode(?:\s|$)/;var ab=/\r\n?|\n/;var ac=V.ownerDocument;var S;if(V.currentStyle){S=V.currentStyle.whiteSpace}else{if(window.getComputedStyle){S=ac.defaultView.getComputedStyle(V,null).getPropertyValue("white-space")}}var Z=S&&"pre"===S.substring(0,3);var af=ac.createElement("LI");while(V.firstChild){af.appendChild(V.firstChild)}var W=[af];function ae(al){switch(al.nodeType){case 1:if(U.test(al.className)){break}if("BR"===al.nodeName){ad(al);if(al.parentNode){al.parentNode.removeChild(al)}}else{for(var an=al.firstChild;an;an=an.nextSibling){ae(an)}}break;case 3:case 4:if(Z){var am=al.nodeValue;var aj=am.match(ab);if(aj){var ai=am.substring(0,aj.index);al.nodeValue=ai;var ah=am.substring(aj.index+aj[0].length);if(ah){var ak=al.parentNode;ak.insertBefore(ac.createTextNode(ah),al.nextSibling)}ad(al);if(!ai){al.parentNode.removeChild(al)}}}break}}function ad(ak){while(!ak.nextSibling){ak=ak.parentNode;if(!ak){return}}function ai(al,ar){var aq=ar?al.cloneNode(false):al;var ao=al.parentNode;if(ao){var ap=ai(ao,1);var an=al.nextSibling;ap.appendChild(aq);for(var am=an;am;am=an){an=am.nextSibling;ap.appendChild(am)}}return aq}var ah=ai(ak.nextSibling,0);for(var aj;(aj=ah.parentNode)&&aj.nodeType===1;){ah=aj}W.push(ah)}for(var Y=0;Y=S){ah+=2}if(V>=ap){Z+=2}}}var t={};function c(U,V){for(var S=V.length;--S>=0;){var T=V[S];if(!t.hasOwnProperty(T)){t[T]=U}else{if(window.console){console.warn("cannot override language handler %s",T)}}}}function q(T,S){if(!(T&&t.hasOwnProperty(T))){T=/^\s*]*(?:>|$)/],[j,/^<\!--[\s\S]*?(?:-\->|$)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],[L,/^(?:<[%?]|[%?]>)/],["lang-",/^]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-js",/^]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),["default-markup","htm","html","mxml","xhtml","xml","xsl"]);c(g([[F,/^[\s]+/,null," \t\r\n"],[n,/^(?:\"[^\"]*\"?|\'[^\']*\'?)/,null,"\"'"]],[[m,/^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i],[P,/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/],[L,/^[=<>\/]+/],["lang-js",/^on\w+\s*=\s*\"([^\"]+)\"/i],["lang-js",/^on\w+\s*=\s*\'([^\']+)\'/i],["lang-js",/^on\w+\s*=\s*([^\"\'>\s]+)/i],["lang-css",/^style\s*=\s*\"([^\"]+)\"/i],["lang-css",/^style\s*=\s*\'([^\']+)\'/i],["lang-css",/^style\s*=\s*([^\"\'>\s]+)/i]]),["in.tag"]);c(g([],[[n,/^[\s\S]+/]]),["uq.val"]);c(i({keywords:l,hashComments:true,cStyleComments:true,types:e}),["c","cc","cpp","cxx","cyc","m"]);c(i({keywords:"null,true,false"}),["json"]);c(i({keywords:R,hashComments:true,cStyleComments:true,verbatimStrings:true,types:e}),["cs"]);c(i({keywords:x,cStyleComments:true}),["java"]);c(i({keywords:H,hashComments:true,multiLineStrings:true}),["bsh","csh","sh"]);c(i({keywords:I,hashComments:true,multiLineStrings:true,tripleQuotedStrings:true}),["cv","py"]);c(i({keywords:s,hashComments:true,multiLineStrings:true,regexLiterals:true}),["perl","pl","pm"]);c(i({keywords:f,hashComments:true,multiLineStrings:true,regexLiterals:true}),["rb"]);c(i({keywords:w,cStyleComments:true,regexLiterals:true}),["js"]);c(i({keywords:r,hashComments:3,cStyleComments:true,multilineStrings:true,tripleQuotedStrings:true,regexLiterals:true}),["coffee"]);c(g([],[[C,/^[\s\S]+/]]),["regex"]);function d(V){var U=V.langExtension;try{var S=a(V.sourceNode);var T=S.sourceCode;V.sourceCode=T;V.spans=S.spans;V.basePos=0;q(U,T)(V);D(V)}catch(W){if("console" in window){console.log(W&&W.stack?W.stack:W)}}}function y(W,V,U){var S=document.createElement("PRE");S.innerHTML=W;if(U){Q(S,U)}var T={langExtension:V,numberLines:U,sourceNode:S};d(T);return S.innerHTML}function b(ad){function Y(af){return document.getElementsByTagName(af)}var ac=[Y("pre"),Y("code"),Y("xmp")];var T=[];for(var aa=0;aa=0){var ah=ai.match(ab);var am;if(!ah&&(am=o(aj))&&"CODE"===am.tagName){ah=am.className.match(ab)}if(ah){ah=ah[1]}var al=false;for(var ak=aj.parentNode;ak;ak=ak.parentNode){if((ak.tagName==="pre"||ak.tagName==="code"||ak.tagName==="xmp")&&ak.className&&ak.className.indexOf("prettyprint")>=0){al=true;break}}if(!al){var af=aj.className.match(/\blinenums\b(?::(\d+))?/);af=af?af[1]&&af[1].length?+af[1]:true:false;if(af){Q(aj,af)}S={langExtension:ah,sourceNode:aj,numberLines:af};d(S)}}}if(X]*(?:>|$)/],[PR.PR_COMMENT,/^<\!--[\s\S]*?(?:-\->|$)/],[PR.PR_PUNCTUATION,/^(?:<[%?]|[%?]>)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],["lang-",/^]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-handlebars",/^]*type\s*=\s*['"]?text\/x-handlebars-template['"]?\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-js",/^]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i],[PR.PR_DECLARATION,/^{{[#^>/]?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{&?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{{>?\s*[\w.][^}]*}}}/],[PR.PR_COMMENT,/^{{![^}]*}}/]]),["handlebars","hbs"]);PR.registerLangHandler(PR.createSimpleLexer([[PR.PR_PLAIN,/^[ \t\r\n\f]+/,null," \t\r\n\f"]],[[PR.PR_STRING,/^\"(?:[^\n\r\f\\\"]|\\(?:\r\n?|\n|\f)|\\[\s\S])*\"/,null],[PR.PR_STRING,/^\'(?:[^\n\r\f\\\']|\\(?:\r\n?|\n|\f)|\\[\s\S])*\'/,null],["lang-css-str",/^url\(([^\)\"\']*)\)/i],[PR.PR_KEYWORD,/^(?:url|rgb|\!important|@import|@page|@media|@charset|inherit)(?=[^\-\w]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|(?:\\[0-9a-f]+ ?))(?:[_a-z0-9\-]|\\(?:\\[0-9a-f]+ ?))*)\s*:/i],[PR.PR_COMMENT,/^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//],[PR.PR_COMMENT,/^(?:)/],[PR.PR_LITERAL,/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],[PR.PR_LITERAL,/^#(?:[0-9a-f]{3}){1,2}/i],[PR.PR_PLAIN,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i],[PR.PR_PUNCTUATION,/^[^\s\w\'\"]+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_KEYWORD,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_STRING,/^[^\)\"\']+/]]),["css-str"]);
diff --git a/example/simple-http-page/coverage/lcov-report/sort-arrow-sprite.png b/example/simple-http-page/coverage/lcov-report/sort-arrow-sprite.png
new file mode 100644
index 0000000..6ed6831
Binary files /dev/null and b/example/simple-http-page/coverage/lcov-report/sort-arrow-sprite.png differ
diff --git a/example/simple-http-page/coverage/lcov-report/sorter.js b/example/simple-http-page/coverage/lcov-report/sorter.js
new file mode 100644
index 0000000..2bb296a
--- /dev/null
+++ b/example/simple-http-page/coverage/lcov-report/sorter.js
@@ -0,0 +1,196 @@
+/* eslint-disable */
+var addSorting = (function() {
+ 'use strict';
+ var cols,
+ currentSort = {
+ index: 0,
+ desc: false
+ };
+
+ // returns the summary table element
+ function getTable() {
+ return document.querySelector('.coverage-summary');
+ }
+ // returns the thead element of the summary table
+ function getTableHeader() {
+ return getTable().querySelector('thead tr');
+ }
+ // returns the tbody element of the summary table
+ function getTableBody() {
+ return getTable().querySelector('tbody');
+ }
+ // returns the th element for nth column
+ function getNthColumn(n) {
+ return getTableHeader().querySelectorAll('th')[n];
+ }
+
+ function onFilterInput() {
+ const searchValue = document.getElementById('fileSearch').value;
+ const rows = document.getElementsByTagName('tbody')[0].children;
+ for (let i = 0; i < rows.length; i++) {
+ const row = rows[i];
+ if (
+ row.textContent
+ .toLowerCase()
+ .includes(searchValue.toLowerCase())
+ ) {
+ row.style.display = '';
+ } else {
+ row.style.display = 'none';
+ }
+ }
+ }
+
+ // loads the search box
+ function addSearchBox() {
+ var template = document.getElementById('filterTemplate');
+ var templateClone = template.content.cloneNode(true);
+ templateClone.getElementById('fileSearch').oninput = onFilterInput;
+ template.parentElement.appendChild(templateClone);
+ }
+
+ // loads all columns
+ function loadColumns() {
+ var colNodes = getTableHeader().querySelectorAll('th'),
+ colNode,
+ cols = [],
+ col,
+ i;
+
+ for (i = 0; i < colNodes.length; i += 1) {
+ colNode = colNodes[i];
+ col = {
+ key: colNode.getAttribute('data-col'),
+ sortable: !colNode.getAttribute('data-nosort'),
+ type: colNode.getAttribute('data-type') || 'string'
+ };
+ cols.push(col);
+ if (col.sortable) {
+ col.defaultDescSort = col.type === 'number';
+ colNode.innerHTML =
+ colNode.innerHTML + '';
+ }
+ }
+ return cols;
+ }
+ // attaches a data attribute to every tr element with an object
+ // of data values keyed by column name
+ function loadRowData(tableRow) {
+ var tableCols = tableRow.querySelectorAll('td'),
+ colNode,
+ col,
+ data = {},
+ i,
+ val;
+ for (i = 0; i < tableCols.length; i += 1) {
+ colNode = tableCols[i];
+ col = cols[i];
+ val = colNode.getAttribute('data-value');
+ if (col.type === 'number') {
+ val = Number(val);
+ }
+ data[col.key] = val;
+ }
+ return data;
+ }
+ // loads all row data
+ function loadData() {
+ var rows = getTableBody().querySelectorAll('tr'),
+ i;
+
+ for (i = 0; i < rows.length; i += 1) {
+ rows[i].data = loadRowData(rows[i]);
+ }
+ }
+ // sorts the table using the data for the ith column
+ function sortByIndex(index, desc) {
+ var key = cols[index].key,
+ sorter = function(a, b) {
+ a = a.data[key];
+ b = b.data[key];
+ return a < b ? -1 : a > b ? 1 : 0;
+ },
+ finalSorter = sorter,
+ tableBody = document.querySelector('.coverage-summary tbody'),
+ rowNodes = tableBody.querySelectorAll('tr'),
+ rows = [],
+ i;
+
+ if (desc) {
+ finalSorter = function(a, b) {
+ return -1 * sorter(a, b);
+ };
+ }
+
+ for (i = 0; i < rowNodes.length; i += 1) {
+ rows.push(rowNodes[i]);
+ tableBody.removeChild(rowNodes[i]);
+ }
+
+ rows.sort(finalSorter);
+
+ for (i = 0; i < rows.length; i += 1) {
+ tableBody.appendChild(rows[i]);
+ }
+ }
+ // removes sort indicators for current column being sorted
+ function removeSortIndicators() {
+ var col = getNthColumn(currentSort.index),
+ cls = col.className;
+
+ cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+ col.className = cls;
+ }
+ // adds sort indicators for current column being sorted
+ function addSortIndicators() {
+ getNthColumn(currentSort.index).className += currentSort.desc
+ ? ' sorted-desc'
+ : ' sorted';
+ }
+ // adds event listeners for all sorter widgets
+ function enableUI() {
+ var i,
+ el,
+ ithSorter = function ithSorter(i) {
+ var col = cols[i];
+
+ return function() {
+ var desc = col.defaultDescSort;
+
+ if (currentSort.index === i) {
+ desc = !currentSort.desc;
+ }
+ sortByIndex(i, desc);
+ removeSortIndicators();
+ currentSort.index = i;
+ currentSort.desc = desc;
+ addSortIndicators();
+ };
+ };
+ for (i = 0; i < cols.length; i += 1) {
+ if (cols[i].sortable) {
+ // add the click event handler on the th so users
+ // dont have to click on those tiny arrows
+ el = getNthColumn(i).querySelector('.sorter').parentElement;
+ if (el.addEventListener) {
+ el.addEventListener('click', ithSorter(i));
+ } else {
+ el.attachEvent('onclick', ithSorter(i));
+ }
+ }
+ }
+ }
+ // adds sorting functionality to the UI
+ return function() {
+ if (!getTable()) {
+ return;
+ }
+ cols = loadColumns();
+ loadData();
+ addSearchBox();
+ addSortIndicators();
+ enableUI();
+ };
+})();
+
+window.addEventListener('load', addSorting);
diff --git a/example/simple-http-page/coverage/lcov.info b/example/simple-http-page/coverage/lcov.info
new file mode 100644
index 0000000..e69de29
diff --git a/example/simple-http-page/dist/index.js b/example/simple-http-page/dist/index.js
new file mode 100644
index 0000000..a6d1432
--- /dev/null
+++ b/example/simple-http-page/dist/index.js
@@ -0,0 +1,16 @@
+/******/ (() => { // webpackBootstrap
+/******/ "use strict";
+/******/ /* webpack/runtime/compat */
+/******/
+/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+/******/
+/************************************************************************/
+var __webpack_exports__ = {};
+
+function main() {
+ console.log("blbl");
+}
+
+module.exports = __webpack_exports__;
+/******/ })()
+;
\ No newline at end of file
diff --git a/example/simple-http-page/eslint.config.mjs b/example/simple-http-page/eslint.config.mjs
new file mode 100644
index 0000000..851cd29
--- /dev/null
+++ b/example/simple-http-page/eslint.config.mjs
@@ -0,0 +1,12 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+
+export default [
+ { files: ["**/*.{js,mjs,cjs,ts}"] },
+ { languageOptions: { globals: globals.browser } },
+ pluginJs.configs.recommended,
+ ...tseslint.configs.recommended,
+];
+
diff --git a/example/simple-http-page/jest.config.js b/example/simple-http-page/jest.config.js
new file mode 100644
index 0000000..d48867a
--- /dev/null
+++ b/example/simple-http-page/jest.config.js
@@ -0,0 +1,9 @@
+module.exports = {
+ clearMocks: true,
+ moduleFileExtensions: ['js', 'ts'],
+ testEnvironment: 'node',
+ testMatch: ['**/*.test.ts'],
+ transform: {
+ '^.+\\.ts$': 'ts-jest'
+ },
+}
diff --git a/example/simple-http-page/package.json b/example/simple-http-page/package.json
new file mode 100644
index 0000000..abbc103
--- /dev/null
+++ b/example/simple-http-page/package.json
@@ -0,0 +1,41 @@
+{
+ "name": "example/simple-http-page",
+ "version": "0.1.0",
+ "main": "dist/index.js",
+ "files": [
+ "dist"
+ ],
+ "private": true,
+ "scripts": {
+ "lint": "eslint src",
+ "test": "jest --silent --coverage",
+ "build": "ncc build src/main.ts -o dist/"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/BunnyWay/edge-script-sdk.git"
+ },
+ "keywords": [
+ "github",
+ "bunny"
+ ],
+ "author": "Bunny Devs",
+ "license": "MIT",
+ "devDependencies": {
+ "@eslint/js": "^9.8.0",
+ "@types/jest": "^29.5.12",
+ "@types/node": "^22.1.0",
+ "@typescript-eslint/eslint-plugin": "^8.0.1",
+ "@typescript-eslint/parser": "^8.0.1",
+ "@vercel/ncc": "^0.38.1",
+ "esbuild": "0.23.0",
+ "eslint": "^9.8.0",
+ "globals": "^15.9.0",
+ "jest": "^29.5.12",
+ "prettier": "^3.3.3",
+ "ts-jest": "^29.2.4",
+ "typescript": "^5.5.4",
+ "typescript-eslint": "^8.0.1"
+ },
+ "dependencies": {}
+}
diff --git a/example/simple-http-page/src/main.ts b/example/simple-http-page/src/main.ts
new file mode 100644
index 0000000..cb59aef
--- /dev/null
+++ b/example/simple-http-page/src/main.ts
@@ -0,0 +1,3 @@
+export function main() {
+ console.log("blbl");
+}
diff --git a/example/simple-http-page/tests/empty.test.ts b/example/simple-http-page/tests/empty.test.ts
new file mode 100644
index 0000000..8791bfb
--- /dev/null
+++ b/example/simple-http-page/tests/empty.test.ts
@@ -0,0 +1,8 @@
+// import { jest } from '@jest/globals';
+
+describe('empty', () => {
+ test('empty test', async () => {
+ expect(true).toBe(true);
+ });
+
+});
diff --git a/example/simple-http-page/tsconfig.json b/example/simple-http-page/tsconfig.json
new file mode 100644
index 0000000..78e3401
--- /dev/null
+++ b/example/simple-http-page/tsconfig.json
@@ -0,0 +1,15 @@
+{
+ "compilerOptions": {
+ "target": "es6",
+ "module": "commonjs",
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "noImplicitAny": false,
+ "esModuleInterop": true
+ },
+ "exclude": [
+ "node_modules",
+ "**/*.test.*"
+ ]
+}
diff --git a/libs/bunny-sdk/.gitignore b/libs/bunny-sdk/.gitignore
new file mode 100644
index 0000000..b11702d
--- /dev/null
+++ b/libs/bunny-sdk/.gitignore
@@ -0,0 +1,40 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+/dist/
+/esm/
+/esm-bunny/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+.vscode
+
+# local env files
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
diff --git a/libs/bunny-sdk/README.md b/libs/bunny-sdk/README.md
new file mode 100644
index 0000000..567bd2d
--- /dev/null
+++ b/libs/bunny-sdk/README.md
@@ -0,0 +1,4 @@
+# @bunny.net/edge-script-sdk
+---
+
+The `@bunny.net/edge-script-sdk`
diff --git a/libs/bunny-sdk/build.mjs b/libs/bunny-sdk/build.mjs
new file mode 100644
index 0000000..09b6b9e
--- /dev/null
+++ b/libs/bunny-sdk/build.mjs
@@ -0,0 +1,63 @@
+import * as esbuild from 'esbuild'
+import path from 'node:path'
+import npmDTS from 'npm-dts';
+import { readFile } from 'fs/promises';
+
+const pkg = JSON.parse(await readFile(new URL('./package.json', import.meta.url)));
+
+const sharedConfig = {
+ entryPoints: ['src/lib.ts'],
+ bundle: true,
+ minify: true,
+ outfile: 'dist/index.js',
+ define: {
+ "VERSION": `"${pkg.version}"`,
+ }
+};
+
+await new npmDTS.Generator({
+ entry: 'src/lib.ts',
+ output: 'dist/index.d.ts',
+}).generate();
+
+// CJS Build
+await esbuild.build({
+ ...sharedConfig,
+ platform: 'node',
+ outfile: "dist/index.js",
+});
+
+
+
+let noNodeImpl = {
+ name: 'example',
+ setup(build) {
+ build.onResolve({ filter: /_impl\/node\/.*/ }, args => {
+ return { path: args.path, namespace: "node-special" }
+ })
+
+ build.onLoad({ filter: /.*/, namespace: 'node-special' }, () => ({
+ contents: "const handler = { get: () => undefined }; const proxy = new Proxy({}, handler); export default proxy;",
+ loader: 'js',
+ }))
+ },
+}
+
+// ESM Build
+await esbuild.build({
+ ...sharedConfig,
+ platform: 'neutral',
+ outfile: "esm/index.js",
+ plugins: [noNodeImpl],
+ // external: ["*/_impl/node.ts", "*/_impl/node/"],
+ format: "esm"
+});
+
+// Bunny Build
+await esbuild.build({
+ ...sharedConfig,
+ platform: 'neutral',
+ outfile: "esm-bunny/index.js",
+ format: "esm",
+ plugins: [noNodeImpl],
+});
diff --git a/libs/bunny-sdk/eslint.config.mjs b/libs/bunny-sdk/eslint.config.mjs
new file mode 100644
index 0000000..851cd29
--- /dev/null
+++ b/libs/bunny-sdk/eslint.config.mjs
@@ -0,0 +1,12 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+
+export default [
+ { files: ["**/*.{js,mjs,cjs,ts}"] },
+ { languageOptions: { globals: globals.browser } },
+ pluginJs.configs.recommended,
+ ...tseslint.configs.recommended,
+];
+
diff --git a/libs/bunny-sdk/jest.config.js b/libs/bunny-sdk/jest.config.js
new file mode 100644
index 0000000..d48867a
--- /dev/null
+++ b/libs/bunny-sdk/jest.config.js
@@ -0,0 +1,9 @@
+module.exports = {
+ clearMocks: true,
+ moduleFileExtensions: ['js', 'ts'],
+ testEnvironment: 'node',
+ testMatch: ['**/*.test.ts'],
+ transform: {
+ '^.+\\.ts$': 'ts-jest'
+ },
+}
diff --git a/libs/bunny-sdk/package.json b/libs/bunny-sdk/package.json
new file mode 100644
index 0000000..506f26f
--- /dev/null
+++ b/libs/bunny-sdk/package.json
@@ -0,0 +1,51 @@
+{
+ "name": "@bunny.net/edgescript-sdk",
+ "version": "0.2.0",
+ "main": "dist/index.js",
+ "module": "esm/index.js",
+ "types": "dist/index.d.ts",
+ "files": [
+ "dist",
+ "esm",
+ "esm-bunny",
+ "dist/index.d.ts"
+ ],
+ "private": true,
+ "scripts": {
+ "lint": "eslint src",
+ "test": "jest --silent --coverage",
+ "build": "rm -rf dist esm && node build.mjs"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/BunnyWay/edge-script-sdk.git"
+ },
+ "keywords": [
+ "github",
+ "bunny"
+ ],
+ "author": "Bunny Devs",
+ "license": "MIT",
+ "devDependencies": {
+ "@deno/shim-deno": "^0.19.2",
+ "@eslint/js": "^9.8.0",
+ "@types/jest": "^29.5.12",
+ "@types/node": "^22.1.0",
+ "@typescript-eslint/eslint-plugin": "^8.0.1",
+ "@typescript-eslint/parser": "^8.0.1",
+ "@vercel/ncc": "^0.38.1",
+ "esbuild": "0.23.0",
+ "eslint": "^9.8.0",
+ "globals": "^15.9.0",
+ "jest": "^29.5.12",
+ "npm-dts": "^1.3.13",
+ "prettier": "^3.3.3",
+ "ts-jest": "^29.2.4",
+ "typescript": "^5.5.4",
+ "typescript-eslint": "^8.0.1"
+ },
+ "dependencies": {
+ "@hono/node-server": "^1.12.0",
+ "hono": "^4.5.5"
+ }
+}
diff --git a/libs/bunny-sdk/src/internal/index.ts b/libs/bunny-sdk/src/internal/index.ts
new file mode 100644
index 0000000..c42aa12
--- /dev/null
+++ b/libs/bunny-sdk/src/internal/index.ts
@@ -0,0 +1,11 @@
+import { BunnySDKV1 } from './v1';
+
+/**
+ * The global BunnySDK available
+ * @internal
+ */
+declare global {
+ const Bunny: {
+ v1: BunnySDKV1,
+ }
+};
diff --git a/libs/bunny-sdk/src/internal/v1.ts b/libs/bunny-sdk/src/internal/v1.ts
new file mode 100644
index 0000000..c6ce412
--- /dev/null
+++ b/libs/bunny-sdk/src/internal/v1.ts
@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+type BunnySDKV1 = {
+ serve: (handler: (request: Request) => Response | Promise) => void,
+};
+
+export {
+ BunnySDKV1,
+}
diff --git a/libs/bunny-sdk/src/lib.ts b/libs/bunny-sdk/src/lib.ts
new file mode 100644
index 0000000..fde98d1
--- /dev/null
+++ b/libs/bunny-sdk/src/lib.ts
@@ -0,0 +1,8 @@
+import * as net from "./net/";
+
+export {
+ /**
+ * The `net` module contains Network related functions and utilities.
+ */
+ net,
+}
diff --git a/libs/bunny-sdk/src/net/_impl/node/serve.ts b/libs/bunny-sdk/src/net/_impl/node/serve.ts
new file mode 100644
index 0000000..2751b56
--- /dev/null
+++ b/libs/bunny-sdk/src/net/_impl/node/serve.ts
@@ -0,0 +1,22 @@
+import * as Tcp from "../../tcp";
+import * as Ip from "../../ip";
+import { ServeHandler, ServerHandler } from "../../serve";
+import * as HonoNode from "@hono/node-server";
+import { Hono } from "hono";
+import * as SocketAddr from "../../socket_addr";
+
+export function node_serve(listener: Tcp.TcpListener, handler: ServerHandler): ServeHandler {
+ const addr = Tcp.unstable_local_addr(listener);
+ const port = SocketAddr.port(addr);
+ const hostname = Ip.toString(SocketAddr.ip(addr));
+
+ const app = new Hono();
+ app.all((c) => {
+ return handler(c.req.raw);
+ })
+
+ HonoNode.serve({
+ fetch: app.fetch, hostname, port
+ });
+ return ({});
+}
diff --git a/libs/bunny-sdk/src/net/index.ts b/libs/bunny-sdk/src/net/index.ts
new file mode 100644
index 0000000..dfc206c
--- /dev/null
+++ b/libs/bunny-sdk/src/net/index.ts
@@ -0,0 +1,10 @@
+import * as tcp from './tcp';
+import * as socketAddr from './socket_addr';
+import * as http from './serve';
+
+
+export {
+ socketAddr,
+ tcp,
+ http,
+};
diff --git a/libs/bunny-sdk/src/net/ip.ts b/libs/bunny-sdk/src/net/ip.ts
new file mode 100644
index 0000000..bc1e3a5
--- /dev/null
+++ b/libs/bunny-sdk/src/net/ip.ts
@@ -0,0 +1,11 @@
+type Enumerate = Acc['length'] extends N
+ ? Acc[number]
+ : Enumerate
+
+type Range = Exclude, Enumerate> | T
+
+export type IPv4 = [Range<0, 255>, Range<0, 255>, Range<0, 255>, Range<0, 255>];
+
+export function toString(ip: IPv4): string {
+ return `${ip[0]}.${ip[1]}.${ip[2]}.${ip[3]}`;
+}
diff --git a/libs/bunny-sdk/src/net/serve.ts b/libs/bunny-sdk/src/net/serve.ts
new file mode 100644
index 0000000..f0012cf
--- /dev/null
+++ b/libs/bunny-sdk/src/net/serve.ts
@@ -0,0 +1,53 @@
+import { internal_getPlatform } from "../platform";
+import * as NodeImpl from "./_impl/node/serve";
+import { TcpListener } from "./tcp";
+import * as Tcp from "./tcp";
+import * as Ip from "./ip";
+import * as SocketAddr from './socket_addr';
+
+/**
+ * A handler for HTTP Requests.
+ * Consumes a request and return a response.
+ */
+type ServerHandler = (request: Request) => Response | Promise;
+
+type ServeHandler = {};
+
+/**
+ * Serves HTTP requests on the given [TcpListener]
+ */
+function serve(listener: { port: number; hostname: string; }, handler: ServerHandler): ServeHandler;
+function serve(listener: TcpListener, handler: ServerHandler): ServeHandler;
+function serve(listener: TcpListener | { port: number; hostname: string; }, handler: ServerHandler): ServeHandler {
+ const platform = internal_getPlatform();
+
+ const listenerUnion = Tcp.isTcpListener(listener) ? listener : Tcp.unstable_new();
+
+ switch (platform.runtime) {
+ case "bunny": {
+ Bunny.v1.serve(handler);
+ return {};
+ }
+ case "node": {
+ return NodeImpl.node_serve(listenerUnion, handler);
+ }
+
+ case "deno": {
+ const addr = Tcp.unstable_local_addr(listenerUnion);
+ const port = SocketAddr.port(addr);
+ const hostname = Ip.toString(SocketAddr.ip(addr));
+
+ Deno.serve({ port, hostname }, handler);
+ return {};
+ }
+ case "unknown": {
+ return {};
+ }
+ }
+}
+
+export {
+ serve,
+ ServeHandler,
+ ServerHandler,
+}
diff --git a/libs/bunny-sdk/src/net/socket_addr.ts b/libs/bunny-sdk/src/net/socket_addr.ts
new file mode 100644
index 0000000..cc8b9af
--- /dev/null
+++ b/libs/bunny-sdk/src/net/socket_addr.ts
@@ -0,0 +1,21 @@
+import { IPv4 } from "./ip";
+
+export type SocketAddr = {
+ readonly _tag: "SocketAddrV4",
+ port: number,
+ ip: IPv4,
+};
+
+/**
+ * Returns the port number associated with this socket address.
+ */
+export function port(addr: SocketAddr): number {
+ return addr.port;
+}
+
+/**
+ * Returns the IP address associated with this socket address.
+ */
+export function ip(addr: SocketAddr): IPv4 {
+ return addr.ip;
+}
diff --git a/libs/bunny-sdk/src/net/tcp.ts b/libs/bunny-sdk/src/net/tcp.ts
new file mode 100644
index 0000000..9c3856e
--- /dev/null
+++ b/libs/bunny-sdk/src/net/tcp.ts
@@ -0,0 +1,36 @@
+import * as SocketAddr from "./socket_addr";
+
+export type TcpListener = {
+ /**
+ * Prevent the construction
+ * @internal
+ */
+ readonly _tag: 'TcpListener';
+ addr: SocketAddr.SocketAddr;
+}
+
+export function isTcpListener(value: unknown): value is TcpListener {
+ return value instanceof Object && value["_tag"] === "TcpListener";
+}
+
+/**
+ * Returns the local socket address of this listener.
+ */
+export function unstable_local_addr(tcp: TcpListener): SocketAddr.SocketAddr {
+ return tcp.addr;
+}
+
+/**
+ * Create a new [TcpListener].
+ */
+export function unstable_new(): TcpListener {
+ return ({
+ _tag: 'TcpListener',
+ addr: {
+ _tag: "SocketAddrV4",
+ port: 8080,
+ ip: [127, 0, 0, 1],
+ },
+ })
+}
+
diff --git a/libs/bunny-sdk/src/platform.ts b/libs/bunny-sdk/src/platform.ts
new file mode 100644
index 0000000..db3fbba
--- /dev/null
+++ b/libs/bunny-sdk/src/platform.ts
@@ -0,0 +1,100 @@
+// Adapted from https://github.com/openai/openai-deno-build/blob/ea31e868608f359c6a948f456efea2b28df6e775/core.ts#L1087
+
+type PlatformName =
+ | "MacOS"
+ | "Linux"
+ | "Windows"
+ | "FreeBSD"
+ | "OpenBSD"
+ | "iOS"
+ | "Android"
+ | `Other:${string}`
+ | "Unknown";
+
+// Defined by `build` step.
+declare const VERSION: string;
+
+
+type Platform = {
+ /**
+ * @internal
+ */
+ readonly _tag: "_Platform";
+ name: PlatformName;
+ version: string;
+ runtime: "bunny" | "node" | "deno" | "unknown";
+ runtime_version: string;
+};
+
+const normalizePlatform = (platform: string): PlatformName => {
+ // Node platforms:
+ // - https://nodejs.org/api/process.html#processplatform
+ // Deno platforms:
+ // - https://doc.deno.land/deno/stable/~/Deno.build
+ // - https://github.com/denoland/deno/issues/14799
+
+ platform = platform.toLowerCase();
+
+ if (platform.includes("ios")) return "iOS";
+ if (platform === "android") return "Android";
+ if (platform === "darwin") return "MacOS";
+ if (platform === "win32") return "Windows";
+ if (platform === "freebsd") return "FreeBSD";
+ if (platform === "openbsd") return "OpenBSD";
+ if (platform === "linux") return "Linux";
+ if (platform) return `Other:${platform}`;
+ return "Unknown";
+};
+
+const internal_getPlatform = (): Platform => {
+ // Check if Bunny
+ if (typeof Bunny !== "undefined") {
+ return {
+ _tag: "_Platform",
+ version: VERSION,
+ name: "Unknown",
+ runtime: "bunny",
+ runtime_version: "unknown",
+ };
+ }
+
+ // Check if Deno
+ if (typeof Deno !== "undefined" && Deno.build != null) {
+ return {
+ _tag: "_Platform",
+ version: VERSION,
+ name: normalizePlatform(Deno.build.os),
+ runtime: "deno",
+ runtime_version: typeof Deno.version === "string"
+ ? Deno.version
+ : Deno.version?.deno ?? "unknown",
+ };
+ }
+ // Check if Node.js
+ if (
+ Object.prototype.toString.call(
+ typeof process !== "undefined" ? process : 0,
+ ) === "[object process]"
+ ) {
+ return {
+ _tag: "_Platform",
+ version: VERSION,
+ name: normalizePlatform(process.platform),
+ runtime: "node",
+ runtime_version: process.version,
+ };
+ }
+
+ return {
+ _tag: "_Platform",
+ version: VERSION,
+ name: "Unknown",
+ runtime: "unknown",
+ runtime_version: "unknown",
+ };
+};
+
+export {
+ internal_getPlatform,
+ Platform,
+};
diff --git a/libs/bunny-sdk/tests/empty.test.ts b/libs/bunny-sdk/tests/empty.test.ts
new file mode 100644
index 0000000..8791bfb
--- /dev/null
+++ b/libs/bunny-sdk/tests/empty.test.ts
@@ -0,0 +1,8 @@
+// import { jest } from '@jest/globals';
+
+describe('empty', () => {
+ test('empty test', async () => {
+ expect(true).toBe(true);
+ });
+
+});
diff --git a/libs/bunny-sdk/tsconfig.eslint.json b/libs/bunny-sdk/tsconfig.eslint.json
new file mode 100644
index 0000000..3f39751
--- /dev/null
+++ b/libs/bunny-sdk/tsconfig.eslint.json
@@ -0,0 +1,6 @@
+{
+ "extends": "./tsconfig.json",
+ "exclude": [
+ "node_modules"
+ ]
+}
diff --git a/libs/bunny-sdk/tsconfig.json b/libs/bunny-sdk/tsconfig.json
new file mode 100644
index 0000000..78e3401
--- /dev/null
+++ b/libs/bunny-sdk/tsconfig.json
@@ -0,0 +1,15 @@
+{
+ "compilerOptions": {
+ "target": "es6",
+ "module": "commonjs",
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "noImplicitAny": false,
+ "esModuleInterop": true
+ },
+ "exclude": [
+ "node_modules",
+ "**/*.test.*"
+ ]
+}
diff --git a/libs/bunny-sdk/types/deno.d.ts b/libs/bunny-sdk/types/deno.d.ts
new file mode 100644
index 0000000..604653b
--- /dev/null
+++ b/libs/bunny-sdk/types/deno.d.ts
@@ -0,0 +1,16686 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+///
+///
+///
+
+/** Deno provides extra properties on `import.meta`. These are included here
+ * to ensure that these are still available when using the Deno namespace in
+ * conjunction with other type libs, like `dom`.
+ *
+ * @category ES Modules
+ */
+declare interface ImportMeta {
+ /** A string representation of the fully qualified module URL. When the
+ * module is loaded locally, the value will be a file URL (e.g.
+ * `file:///path/module.ts`).
+ *
+ * You can also parse the string as a URL to determine more information about
+ * how the current module was loaded. For example to determine if a module was
+ * local or not:
+ *
+ * ```ts
+ * const url = new URL(import.meta.url);
+ * if (url.protocol === "file:") {
+ * console.log("this module was loaded locally");
+ * }
+ * ```
+ */
+ url: string;
+
+ /** The absolute path of the current module.
+ *
+ * This property is only provided for local modules (ie. using `file://` URLs).
+ *
+ * Example:
+ * ```
+ * // Unix
+ * console.log(import.meta.filename); // /home/alice/my_module.ts
+ *
+ * // Windows
+ * console.log(import.meta.filename); // C:\alice\my_module.ts
+ * ```
+ */
+ filename?: string;
+
+ /** The absolute path of the directory containing the current module.
+ *
+ * This property is only provided for local modules (ie. using `file://` URLs).
+ *
+ * * Example:
+ * ```
+ * // Unix
+ * console.log(import.meta.dirname); // /home/alice/
+ *
+ * // Windows
+ * console.log(import.meta.dirname); // C:\alice\
+ * ```
+ */
+ dirname?: 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;
+
+ /** A function that returns resolved specifier as if it would be imported
+ * using `import(specifier)`.
+ *
+ * ```ts
+ * console.log(import.meta.resolve("./foo.js"));
+ * // file:///dev/foo.js
+ * ```
+ */
+ resolve(specifier: string): string;
+}
+
+/** Deno supports [User Timing Level 3](https://w3c.github.io/user-timing)
+ * which is not widely supported yet in other runtimes.
+ *
+ * Check out the
+ * [Performance API](https://developer.mozilla.org/en-US/docs/Web/API/Performance)
+ * documentation on MDN for further information about how to use the API.
+ *
+ * @category Performance
+ */
+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;
+}
+
+/**
+ * Options which are used in conjunction with `performance.mark`. Check out the
+ * MDN
+ * [`performance.mark()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark#markoptions)
+ * documentation for more details.
+ *
+ * @category Performance
+ */
+declare interface PerformanceMarkOptions {
+ /** Metadata to be included in the mark. */
+ // deno-lint-ignore no-explicit-any
+ detail?: any;
+
+ /** Timestamp to be used as the mark time. */
+ startTime?: number;
+}
+
+/**
+ * Options which are used in conjunction with `performance.measure`. Check out the
+ * MDN
+ * [`performance.mark()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure#measureoptions)
+ * documentation for more details.
+ *
+ * @category Performance
+ */
+declare interface PerformanceMeasureOptions {
+ /** Metadata to be included in the measure. */
+ // deno-lint-ignore 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;
+}
+
+/** The global namespace where Deno specific, non-standard APIs are located. */
+declare namespace Deno {
+ /** A set of error constructors that are raised by Deno APIs.
+ *
+ * Can be used to provide more specific handling of failures within code
+ * which is using Deno APIs. For example, handling attempting to open a file
+ * which does not exist:
+ *
+ * ```ts
+ * try {
+ * const file = await Deno.open("./some/file.txt");
+ * } catch (error) {
+ * if (error instanceof Deno.errors.NotFound) {
+ * console.error("the file was not found");
+ * } else {
+ * // otherwise re-throw
+ * throw error;
+ * }
+ * }
+ * ```
+ *
+ * @category Errors
+ */
+ export namespace errors {
+ /**
+ * Raised when the underlying operating system indicates that the file
+ * was not found.
+ *
+ * @category Errors */
+ export class NotFound extends Error {}
+ /**
+ * Raised when the underlying operating system indicates the current user
+ * which the Deno process is running under does not have the appropriate
+ * permissions to a file or resource, or the user _did not_ provide required
+ * `--allow-*` flag.
+ *
+ * @category Errors */
+ export class PermissionDenied extends Error {}
+ /**
+ * Raised when the underlying operating system reports that a connection to
+ * a resource is refused.
+ *
+ * @category Errors */
+ export class ConnectionRefused extends Error {}
+ /**
+ * Raised when the underlying operating system reports that a connection has
+ * been reset. With network servers, it can be a _normal_ occurrence where a
+ * client will abort a connection instead of properly shutting it down.
+ *
+ * @category Errors */
+ export class ConnectionReset extends Error {}
+ /**
+ * Raised when the underlying operating system reports an `ECONNABORTED`
+ * error.
+ *
+ * @category Errors */
+ export class ConnectionAborted extends Error {}
+ /**
+ * Raised when the underlying operating system reports an `ENOTCONN` error.
+ *
+ * @category Errors */
+ export class NotConnected extends Error {}
+ /**
+ * Raised when attempting to open a server listener on an address and port
+ * that already has a listener.
+ *
+ * @category Errors */
+ export class AddrInUse extends Error {}
+ /**
+ * Raised when the underlying operating system reports an `EADDRNOTAVAIL`
+ * error.
+ *
+ * @category Errors */
+ export class AddrNotAvailable extends Error {}
+ /**
+ * Raised when trying to write to a resource and a broken pipe error occurs.
+ * This can happen when trying to write directly to `stdout` or `stderr`
+ * and the operating system is unable to pipe the output for a reason
+ * external to the Deno runtime.
+ *
+ * @category Errors */
+ export class BrokenPipe extends Error {}
+ /**
+ * Raised when trying to create a resource, like a file, that already
+ * exits.
+ *
+ * @category Errors */
+ export class AlreadyExists extends Error {}
+ /**
+ * Raised when an operation to returns data that is invalid for the
+ * operation being performed.
+ *
+ * @category Errors */
+ export class InvalidData extends Error {}
+ /**
+ * Raised when the underlying operating system reports that an I/O operation
+ * has timed out (`ETIMEDOUT`).
+ *
+ * @category Errors */
+ export class TimedOut extends Error {}
+ /**
+ * Raised when the underlying operating system reports an `EINTR` error. In
+ * many cases, this underlying IO error will be handled internally within
+ * Deno, or result in an @{link BadResource} error instead.
+ *
+ * @category Errors */
+ export class Interrupted extends Error {}
+ /**
+ * Raised when the underlying operating system would need to block to
+ * complete but an asynchronous (non-blocking) API is used.
+ *
+ * @category Errors */
+ export class WouldBlock extends Error {}
+ /**
+ * Raised when expecting to write to a IO buffer resulted in zero bytes
+ * being written.
+ *
+ * @category Errors */
+ export class WriteZero extends Error {}
+ /**
+ * Raised when attempting to read bytes from a resource, but the EOF was
+ * unexpectedly encountered.
+ *
+ * @category Errors */
+ export class UnexpectedEof extends Error {}
+ /**
+ * The underlying IO resource is invalid or closed, and so the operation
+ * could not be performed.
+ *
+ * @category Errors */
+ export class BadResource extends Error {}
+ /**
+ * Raised in situations where when attempting to load a dynamic import,
+ * too many redirects were encountered.
+ *
+ * @category Errors */
+ export class Http extends Error {}
+ /**
+ * Raised when the underlying IO resource is not available because it is
+ * being awaited on in another block of code.
+ *
+ * @category Errors */
+ export class Busy extends Error {}
+ /**
+ * Raised when the underlying Deno API is asked to perform a function that
+ * is not currently supported.
+ *
+ * @category Errors */
+ export class NotSupported extends Error {}
+ /**
+ * Raised when too many symbolic links were encountered when resolving the
+ * filename.
+ *
+ * @category Errors */
+ export class FilesystemLoop extends Error {}
+ /**
+ * Raised when trying to open, create or write to a directory.
+ *
+ * @category Errors */
+ export class IsADirectory extends Error {}
+ /**
+ * Raised when performing a socket operation but the remote host is
+ * not reachable.
+ *
+ * @category Errors */
+ export class NetworkUnreachable extends Error {}
+ /**
+ * Raised when trying to perform an operation on a path that is not a
+ * directory, when directory is required.
+ *
+ * @category Errors */
+ export class NotADirectory extends Error {}
+ }
+
+ /** The current process ID of this instance of the Deno CLI.
+ *
+ * ```ts
+ * console.log(Deno.pid);
+ * ```
+ *
+ * @category Runtime Environment
+ */
+ export const pid: number;
+
+ /**
+ * The process ID of parent process of this instance of the Deno CLI.
+ *
+ * ```ts
+ * console.log(Deno.ppid);
+ * ```
+ *
+ * @category Runtime Environment
+ */
+ export const ppid: number;
+
+ /** @category Runtime Environment */
+ export interface MemoryUsage {
+ /** The number of bytes of the current Deno's process resident set size,
+ * which is the amount of memory occupied in main memory (RAM). */
+ rss: number;
+ /** The total size of the heap for V8, in bytes. */
+ heapTotal: number;
+ /** The amount of the heap used for V8, in bytes. */
+ heapUsed: number;
+ /** Memory, in bytes, associated with JavaScript objects outside of the
+ * JavaScript isolate. */
+ external: number;
+ }
+
+ /**
+ * Returns an object describing the memory usage of the Deno process and the
+ * V8 subsystem measured in bytes.
+ *
+ * @category Runtime Environment
+ */
+ export function memoryUsage(): MemoryUsage;
+
+ /**
+ * Get the `hostname` of the machine the Deno process is running on.
+ *
+ * ```ts
+ * console.log(Deno.hostname());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ *
+ * @tags allow-sys
+ * @category Runtime Environment
+ */
+ export function hostname(): string;
+
+ /**
+ * 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-sys` permission.
+ *
+ * On Windows there is no API available to retrieve this information and this method returns `[ 0, 0, 0 ]`.
+ *
+ * @tags allow-sys
+ * @category Observability
+ */
+ export function loadavg(): number[];
+
+ /**
+ * The information for a network interface returned from a call to
+ * {@linkcode Deno.networkInterfaces}.
+ *
+ * @category Network
+ */
+ export interface NetworkInterfaceInfo {
+ /** The network interface name. */
+ name: string;
+ /** The IP protocol version. */
+ family: "IPv4" | "IPv6";
+ /** The IP address bound to the interface. */
+ address: string;
+ /** The netmask applied to the interface. */
+ netmask: string;
+ /** The IPv6 scope id or `null`. */
+ scopeid: number | null;
+ /** The CIDR range. */
+ cidr: string;
+ /** The MAC address. */
+ mac: string;
+ }
+
+ /**
+ * Returns an array of the network interface information.
+ *
+ * ```ts
+ * console.log(Deno.networkInterfaces());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ *
+ * @tags allow-sys
+ * @category Network
+ */
+ export function networkInterfaces(): NetworkInterfaceInfo[];
+
+ /**
+ * Displays the total amount of free and used physical and swap memory in the
+ * system, as well as the buffers and caches used by the kernel.
+ *
+ * This is similar to the `free` command in Linux
+ *
+ * ```ts
+ * console.log(Deno.systemMemoryInfo());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ *
+ * @tags allow-sys
+ * @category Runtime Environment
+ */
+ export function systemMemoryInfo(): SystemMemoryInfo;
+
+ /**
+ * Information returned from a call to {@linkcode Deno.systemMemoryInfo}.
+ *
+ * @category Runtime Environment
+ */
+ export interface SystemMemoryInfo {
+ /** Total installed memory in bytes. */
+ total: number;
+ /** Unused memory in bytes. */
+ free: number;
+ /** Estimation of how much memory, in bytes, is available for starting new
+ * applications, without swapping. Unlike the data provided by the cache or
+ * free fields, this field takes into account page cache and also that not
+ * all reclaimable memory will be reclaimed due to items being in use.
+ */
+ available: number;
+ /** Memory used by kernel buffers. */
+ buffers: number;
+ /** Memory used by the page cache and slabs. */
+ cached: number;
+ /** Total swap memory. */
+ swapTotal: number;
+ /** Unused swap memory. */
+ swapFree: number;
+ }
+
+ /** Reflects the `NO_COLOR` environment variable at program start.
+ *
+ * When the value is `true`, the Deno CLI will attempt to not send color codes
+ * to `stderr` or `stdout` and other command line programs should also attempt
+ * to respect this value.
+ *
+ * See: https://no-color.org/
+ *
+ * @category Runtime Environment
+ */
+ export const noColor: boolean;
+
+ /**
+ * Returns the release version of the Operating System.
+ *
+ * ```ts
+ * console.log(Deno.osRelease());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ * Under consideration to possibly move to Deno.build or Deno.versions and if
+ * it should depend sys-info, which may not be desirable.
+ *
+ * @tags allow-sys
+ * @category Runtime Environment
+ */
+ export function osRelease(): string;
+
+ /**
+ * Returns the Operating System uptime in number of seconds.
+ *
+ * ```ts
+ * console.log(Deno.osUptime());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ *
+ * @tags allow-sys
+ * @category Runtime Environment
+ */
+ export function osUptime(): number;
+
+ /**
+ * Options which define the permissions within a test or worker context.
+ *
+ * `"inherit"` ensures that all permissions of the parent process will be
+ * applied to the test context. `"none"` ensures the test context has no
+ * permissions. A `PermissionOptionsObject` provides a more specific
+ * set of permissions to the test context.
+ *
+ * @category Permissions */
+ export type PermissionOptions =
+ | "inherit"
+ | "none"
+ | PermissionOptionsObject;
+
+ /**
+ * A set of options which can define the permissions within a test or worker
+ * context at a highly specific level.
+ *
+ * @category Permissions */
+ export interface PermissionOptionsObject {
+ /** Specifies if the `env` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `env` permission will be inherited.
+ * If set to `true`, the global `env` permission will be requested.
+ * If set to `false`, the global `env` permission will be revoked.
+ *
+ * @default {false}
+ */
+ env?: "inherit" | boolean | string[];
+
+ /** Specifies if the `sys` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `sys` permission will be inherited.
+ * If set to `true`, the global `sys` permission will be requested.
+ * If set to `false`, the global `sys` permission will be revoked.
+ *
+ * @default {false}
+ */
+ sys?: "inherit" | boolean | string[];
+
+ /** Specifies if the `hrtime` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `hrtime` permission will be inherited.
+ * If set to `true`, the global `hrtime` permission will be requested.
+ * If set to `false`, the global `hrtime` permission will be revoked.
+ *
+ * @default {false}
+ */
+ hrtime?: "inherit" | boolean;
+
+ /** Specifies if the `net` permission should be requested or revoked.
+ * if set to `"inherit"`, the current `net` permission will be inherited.
+ * if set to `true`, the global `net` permission will be requested.
+ * if set to `false`, the global `net` permission will be revoked.
+ * if set to `string[]`, the `net` permission will be requested with the
+ * specified host strings with the format `"[:]`.
+ *
+ * @default {false}
+ *
+ * Examples:
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test({
+ * name: "inherit",
+ * permissions: {
+ * net: "inherit",
+ * },
+ * async fn() {
+ * const status = await Deno.permissions.query({ name: "net" })
+ * assertEquals(status.state, "granted");
+ * },
+ * });
+ * ```
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test({
+ * name: "true",
+ * permissions: {
+ * net: true,
+ * },
+ * async fn() {
+ * const status = await Deno.permissions.query({ name: "net" });
+ * assertEquals(status.state, "granted");
+ * },
+ * });
+ * ```
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test({
+ * name: "false",
+ * permissions: {
+ * net: false,
+ * },
+ * async fn() {
+ * const status = await Deno.permissions.query({ name: "net" });
+ * assertEquals(status.state, "denied");
+ * },
+ * });
+ * ```
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test({
+ * name: "localhost:8080",
+ * permissions: {
+ * net: ["localhost:8080"],
+ * },
+ * async fn() {
+ * const status = await Deno.permissions.query({ name: "net", host: "localhost:8080" });
+ * assertEquals(status.state, "granted");
+ * },
+ * });
+ * ```
+ */
+ net?: "inherit" | boolean | string[];
+
+ /** Specifies if the `ffi` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `ffi` permission will be inherited.
+ * If set to `true`, the global `ffi` permission will be requested.
+ * If set to `false`, the global `ffi` permission will be revoked.
+ *
+ * @default {false}
+ */
+ ffi?: "inherit" | boolean | Array;
+
+ /** Specifies if the `read` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `read` permission will be inherited.
+ * If set to `true`, the global `read` permission will be requested.
+ * If set to `false`, the global `read` permission will be revoked.
+ * If set to `Array`, the `read` permission will be requested with the
+ * specified file paths.
+ *
+ * @default {false}
+ */
+ read?: "inherit" | boolean | Array;
+
+ /** Specifies if the `run` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `run` permission will be inherited.
+ * If set to `true`, the global `run` permission will be requested.
+ * If set to `false`, the global `run` permission will be revoked.
+ *
+ * @default {false}
+ */
+ run?: "inherit" | boolean | Array;
+
+ /** Specifies if the `write` permission should be requested or revoked.
+ * If set to `"inherit"`, the current `write` permission will be inherited.
+ * If set to `true`, the global `write` permission will be requested.
+ * If set to `false`, the global `write` permission will be revoked.
+ * If set to `Array`, the `write` permission will be requested with the
+ * specified file paths.
+ *
+ * @default {false}
+ */
+ write?: "inherit" | boolean | Array;
+ }
+
+ /**
+ * Context that is passed to a testing function, which can be used to either
+ * gain information about the current test, or register additional test
+ * steps within the current test.
+ *
+ * @category Testing */
+ export interface TestContext {
+ /** The current test name. */
+ name: string;
+ /** The string URL of the current test. */
+ origin: string;
+ /** If the current test is a step of another test, the parent test context
+ * will be set here. */
+ parent?: TestContext;
+
+ /** Run a sub step of the parent test or step. Returns a promise
+ * that resolves to a boolean signifying if the step completed successfully.
+ *
+ * The returned promise never rejects unless the arguments are invalid.
+ *
+ * If the test was ignored the promise returns `false`.
+ *
+ * ```ts
+ * Deno.test({
+ * name: "a parent test",
+ * async fn(t) {
+ * console.log("before the step");
+ * await t.step({
+ * name: "step 1",
+ * fn(t) {
+ * console.log("current step:", t.name);
+ * }
+ * });
+ * console.log("after the step");
+ * }
+ * });
+ * ```
+ */
+ step(definition: TestStepDefinition): Promise;
+
+ /** Run a sub step of the parent test or step. Returns a promise
+ * that resolves to a boolean signifying if the step completed successfully.
+ *
+ * The returned promise never rejects unless the arguments are invalid.
+ *
+ * If the test was ignored the promise returns `false`.
+ *
+ * ```ts
+ * Deno.test(
+ * "a parent test",
+ * async (t) => {
+ * console.log("before the step");
+ * await t.step(
+ * "step 1",
+ * (t) => {
+ * console.log("current step:", t.name);
+ * }
+ * );
+ * console.log("after the step");
+ * }
+ * );
+ * ```
+ */
+ step(
+ name: string,
+ fn: (t: TestContext) => void | Promise,
+ ): Promise;
+
+ /** Run a sub step of the parent test or step. Returns a promise
+ * that resolves to a boolean signifying if the step completed successfully.
+ *
+ * The returned promise never rejects unless the arguments are invalid.
+ *
+ * If the test was ignored the promise returns `false`.
+ *
+ * ```ts
+ * Deno.test(async function aParentTest(t) {
+ * console.log("before the step");
+ * await t.step(function step1(t) {
+ * console.log("current step:", t.name);
+ * });
+ * console.log("after the step");
+ * });
+ * ```
+ */
+ step(fn: (t: TestContext) => void | Promise): Promise;
+ }
+
+ /** @category Testing */
+ export interface TestStepDefinition {
+ /** The test function that will be tested when this step is executed. The
+ * function can take an argument which will provide information about the
+ * current step's context. */
+ fn: (t: TestContext) => void | Promise;
+ /** The name of the step. */
+ name: string;
+ /** If truthy the current test step will be ignored.
+ *
+ * This is a quick way to skip over a step, but also can be used for
+ * conditional logic, like determining if an environment feature is present.
+ */
+ ignore?: boolean;
+ /** Check that the number of async completed operations after the test step
+ * is the same as number of dispatched operations. This ensures that the
+ * code tested does not start async operations which it then does
+ * not await. This helps in preventing logic errors and memory leaks
+ * in the application code.
+ *
+ * Defaults to the parent test or step's value. */
+ sanitizeOps?: boolean;
+ /** Ensure the test step does not "leak" resources - like open files or
+ * network connections - by ensuring the open resources at the start of the
+ * step match the open resources at the end of the step.
+ *
+ * Defaults to the parent test or step's value. */
+ sanitizeResources?: boolean;
+ /** Ensure the test step does not prematurely cause the process to exit,
+ * for example via a call to {@linkcode Deno.exit}.
+ *
+ * Defaults to the parent test or step's value. */
+ sanitizeExit?: boolean;
+ }
+
+ /** @category Testing */
+ export interface TestDefinition {
+ fn: (t: TestContext) => void | Promise;
+ /** The name of the test. */
+ name: string;
+ /** If truthy the current test step will be ignored.
+ *
+ * It is a quick way to skip over a step, but also can be used for
+ * conditional logic, like determining if an environment feature is present.
+ */
+ ignore?: boolean;
+ /** If at least 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 operations after the test step
+ * is the same as number of dispatched operations. This ensures that the
+ * code tested does not start async operations which it then does
+ * not await. This helps in preventing logic errors and memory leaks
+ * in the application code.
+ *
+ * @default {true} */
+ sanitizeOps?: boolean;
+ /** Ensure the test step does not "leak" resources - like open files or
+ * network connections - by ensuring the open resources at the start of the
+ * test match the open resources at the end of the test.
+ *
+ * @default {true} */
+ sanitizeResources?: boolean;
+ /** Ensure the test case does not prematurely cause the process to exit,
+ * for example via a call to {@linkcode Deno.exit}.
+ *
+ * @default {true} */
+ sanitizeExit?: boolean;
+ /** Specifies the permissions that should be used to run the test.
+ *
+ * Set this to "inherit" to keep the calling runtime permissions, set this
+ * to "none" to revoke all permissions, or set a more specific set of
+ * permissions using a {@linkcode PermissionOptionsObject}.
+ *
+ * @default {"inherit"} */
+ permissions?: PermissionOptions;
+ }
+
+ /** 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 { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test({
+ * name: "example test",
+ * fn() {
+ * assertEquals("world", "world");
+ * },
+ * });
+ *
+ * Deno.test({
+ * name: "example ignored test",
+ * ignore: Deno.build.os === "windows",
+ * fn() {
+ * // 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");
+ * }
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ export const test: DenoTest;
+
+ /**
+ * @category Testing
+ */
+ interface DenoTest {
+ /** 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 { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test({
+ * name: "example test",
+ * fn() {
+ * assertEquals("world", "world");
+ * },
+ * });
+ *
+ * Deno.test({
+ * name: "example ignored test",
+ * ignore: Deno.build.os === "windows",
+ * fn() {
+ * // 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");
+ * }
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ (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 { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test("My test description", () => {
+ * assertEquals("hello", "hello");
+ * });
+ *
+ * Deno.test("My async test description", async () => {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ (
+ name: string,
+ fn: (t: TestContext) => void | Promise,
+ ): 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. Declared function must have a name.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test(function myTestName() {
+ * assertEquals("hello", "hello");
+ * });
+ *
+ * Deno.test(async function myOtherTestName() {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ (fn: (t: TestContext) => void | Promise): 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/assert/mod.ts";
+ *
+ * Deno.test("My test description", { permissions: { read: true } }, (): void => {
+ * assertEquals("hello", "hello");
+ * });
+ *
+ * Deno.test("My async test description", { permissions: { read: false } }, async (): Promise => {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ (
+ name: string,
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): 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 { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test(
+ * {
+ * name: "My test description",
+ * permissions: { read: true },
+ * },
+ * () => {
+ * assertEquals("hello", "hello");
+ * },
+ * );
+ *
+ * Deno.test(
+ * {
+ * name: "My async test description",
+ * permissions: { read: false },
+ * },
+ * async () => {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * },
+ * );
+ * ```
+ *
+ * @category Testing
+ */
+ (
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): 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. Declared function must have a name.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.test(
+ * { permissions: { read: true } },
+ * function myTestName() {
+ * assertEquals("hello", "hello");
+ * },
+ * );
+ *
+ * Deno.test(
+ * { permissions: { read: false } },
+ * async function myOtherTestName() {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * },
+ * );
+ * ```
+ *
+ * @category Testing
+ */
+ (
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for ignoring a particular test case.
+ *
+ * @category Testing
+ */
+ ignore(t: Omit): void;
+
+ /** Shorthand property for ignoring a particular test case.
+ *
+ * @category Testing
+ */
+ ignore(
+ name: string,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for ignoring a particular test case.
+ *
+ * @category Testing
+ */
+ ignore(fn: (t: TestContext) => void | Promise): void;
+
+ /** Shorthand property for ignoring a particular test case.
+ *
+ * @category Testing
+ */
+ ignore(
+ name: string,
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for ignoring a particular test case.
+ *
+ * @category Testing
+ */
+ ignore(
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for ignoring a particular test case.
+ *
+ * @category Testing
+ */
+ ignore(
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for focusing a particular test case.
+ *
+ * @category Testing
+ */
+ only(t: Omit): void;
+
+ /** Shorthand property for focusing a particular test case.
+ *
+ * @category Testing
+ */
+ only(
+ name: string,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for focusing a particular test case.
+ *
+ * @category Testing
+ */
+ only(fn: (t: TestContext) => void | Promise): void;
+
+ /** Shorthand property for focusing a particular test case.
+ *
+ * @category Testing
+ */
+ only(
+ name: string,
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for focusing a particular test case.
+ *
+ * @category Testing
+ */
+ only(
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+
+ /** Shorthand property for focusing a particular test case.
+ *
+ * @category Testing
+ */
+ only(
+ options: Omit,
+ fn: (t: TestContext) => void | Promise,
+ ): void;
+ }
+
+ /**
+ * Context that is passed to a benchmarked function. The instance is shared
+ * between iterations of the benchmark. Its methods can be used for example
+ * to override of the measured portion of the function.
+ *
+ * @category Testing
+ */
+ export interface BenchContext {
+ /** The current benchmark name. */
+ name: string;
+ /** The string URL of the current benchmark. */
+ origin: string;
+
+ /** Restarts the timer for the bench measurement. This should be called
+ * after doing setup work which should not be measured.
+ *
+ * Warning: This method should not be used for benchmarks averaging less
+ * than 10μs per iteration. In such cases it will be disabled but the call
+ * will still have noticeable overhead, resulting in a warning.
+ *
+ * ```ts
+ * Deno.bench("foo", async (t) => {
+ * const data = await Deno.readFile("data.txt");
+ * t.start();
+ * // some operation on `data`...
+ * });
+ * ```
+ */
+ start(): void;
+
+ /** End the timer early for the bench measurement. This should be called
+ * before doing teardown work which should not be measured.
+ *
+ * Warning: This method should not be used for benchmarks averaging less
+ * than 10μs per iteration. In such cases it will be disabled but the call
+ * will still have noticeable overhead, resulting in a warning.
+ *
+ * ```ts
+ * Deno.bench("foo", async (t) => {
+ * using file = await Deno.open("data.txt");
+ * t.start();
+ * // some operation on `file`...
+ * t.end();
+ * });
+ * ```
+ */
+ end(): void;
+ }
+
+ /**
+ * The interface for defining a benchmark test using {@linkcode Deno.bench}.
+ *
+ * @category Testing
+ */
+ export interface BenchDefinition {
+ /** The test function which will be benchmarked. */
+ fn: (b: BenchContext) => void | Promise;
+ /** The name of the test, which will be used in displaying the results. */
+ name: string;
+ /** If truthy, the benchmark test will be ignored/skipped. */
+ ignore?: boolean;
+ /** Group name for the benchmark.
+ *
+ * Grouped benchmarks produce a group time summary, where the difference
+ * in performance between each test of the group is compared. */
+ group?: string;
+ /** Benchmark should be used as the baseline for other benchmarks.
+ *
+ * If there are multiple baselines in a group, the first one is used as the
+ * baseline. */
+ baseline?: boolean;
+ /** If at least one bench has `only` set to true, only run benches that have
+ * `only` set to `true` and fail the bench suite. */
+ only?: boolean;
+ /** Ensure the bench case does not prematurely cause the process to exit,
+ * for example via a call to {@linkcode Deno.exit}.
+ *
+ * @default {true} */
+ sanitizeExit?: boolean;
+ /** Specifies the permissions that should be used to run the bench.
+ *
+ * Set this to `"inherit"` to keep the calling thread's permissions.
+ *
+ * Set this to `"none"` to revoke all permissions.
+ *
+ * @default {"inherit"}
+ */
+ permissions?: PermissionOptions;
+ }
+
+ /**
+ * Register a benchmark test which will be run when `deno bench` is used on
+ * the command line and the containing module looks like a bench module.
+ *
+ * If the test function (`fn`) returns a promise or is async, the test runner
+ * will await resolution to consider the test complete.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.bench({
+ * name: "example test",
+ * fn() {
+ * assertEquals("world", "world");
+ * },
+ * });
+ *
+ * Deno.bench({
+ * name: "example ignored test",
+ * ignore: Deno.build.os === "windows",
+ * fn() {
+ * // This test is ignored only on Windows machines
+ * },
+ * });
+ *
+ * Deno.bench({
+ * 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");
+ * }
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ export function bench(b: BenchDefinition): void;
+
+ /**
+ * Register a benchmark test which will be run when `deno bench` is used on
+ * the command line and the containing module looks like a bench module.
+ *
+ * If the test function (`fn`) returns a promise or is async, the test runner
+ * will await resolution to consider the test complete.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.bench("My test description", () => {
+ * assertEquals("hello", "hello");
+ * });
+ *
+ * Deno.bench("My async test description", async () => {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ export function bench(
+ name: string,
+ fn: (b: BenchContext) => void | Promise,
+ ): void;
+
+ /**
+ * Register a benchmark test which will be run when `deno bench` is used on
+ * the command line and the containing module looks like a bench module.
+ *
+ * If the test function (`fn`) returns a promise or is async, the test runner
+ * will await resolution to consider the test complete.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.bench(function myTestName() {
+ * assertEquals("hello", "hello");
+ * });
+ *
+ * Deno.bench(async function myOtherTestName() {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+ export function bench(fn: (b: BenchContext) => void | Promise): void;
+
+ /**
+ * Register a benchmark test which will be run when `deno bench` is used on
+ * the command line and the containing module looks like a bench module.
+ *
+ * If the test function (`fn`) returns a promise or is async, the test runner
+ * will await resolution to consider the test complete.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.bench(
+ * "My test description",
+ * { permissions: { read: true } },
+ * () => {
+ * assertEquals("hello", "hello");
+ * }
+ * );
+ *
+ * Deno.bench(
+ * "My async test description",
+ * { permissions: { read: false } },
+ * async () => {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * }
+ * );
+ * ```
+ *
+ * @category Testing
+ */
+ export function bench(
+ name: string,
+ options: Omit,
+ fn: (b: BenchContext) => void | Promise,
+ ): void;
+
+ /**
+ * Register a benchmark test which will be run when `deno bench` is used on
+ * the command line and the containing module looks like a bench module.
+ *
+ * If the test function (`fn`) returns a promise or is async, the test runner
+ * will await resolution to consider the test complete.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.bench(
+ * { name: "My test description", permissions: { read: true } },
+ * () => {
+ * assertEquals("hello", "hello");
+ * }
+ * );
+ *
+ * Deno.bench(
+ * { name: "My async test description", permissions: { read: false } },
+ * async () => {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * }
+ * );
+ * ```
+ *
+ * @category Testing
+ */
+ export function bench(
+ options: Omit,
+ fn: (b: BenchContext) => void | Promise,
+ ): void;
+
+ /**
+ * Register a benchmark test which will be run when `deno bench` is used on
+ * the command line and the containing module looks like a bench module.
+ *
+ * If the test function (`fn`) returns a promise or is async, the test runner
+ * will await resolution to consider the test complete.
+ *
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+ *
+ * Deno.bench(
+ * { permissions: { read: true } },
+ * function myTestName() {
+ * assertEquals("hello", "hello");
+ * }
+ * );
+ *
+ * Deno.bench(
+ * { permissions: { read: false } },
+ * async function myOtherTestName() {
+ * const decoder = new TextDecoder("utf-8");
+ * const data = await Deno.readFile("hello_world.txt");
+ * assertEquals(decoder.decode(data), "Hello world");
+ * }
+ * );
+ * ```
+ *
+ * @category Testing
+ */
+ export function bench(
+ options: Omit,
+ fn: (b: BenchContext) => void | Promise,
+ ): void;
+
+ /** Exit the Deno process with optional exit code.
+ *
+ * If no exit code is supplied then Deno will exit with return code of `0`.
+ *
+ * In worker contexts this is an alias to `self.close();`.
+ *
+ * ```ts
+ * Deno.exit(5);
+ * ```
+ *
+ * @category Runtime Environment
+ */
+ export function exit(code?: number): never;
+
+ /** An interface containing methods to interact with the process environment
+ * variables.
+ *
+ * @tags allow-env
+ * @category Runtime Environment
+ */
+ export interface Env {
+ /** Retrieve the value of an environment variable.
+ *
+ * Returns `undefined` if the supplied environment variable is not defined.
+ *
+ * ```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.
+ *
+ * @tags allow-env
+ */
+ 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.
+ *
+ * @tags allow-env
+ */
+ 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.
+ *
+ * @tags allow-env
+ */
+ delete(key: string): void;
+
+ /** Check whether an environment variable is present or not.
+ *
+ * ```ts
+ * Deno.env.set("SOME_VAR", "Value");
+ * Deno.env.has("SOME_VAR"); // outputs true
+ * ```
+ *
+ * Requires `allow-env` permission.
+ *
+ * @tags allow-env
+ */
+ has(key: string): boolean;
+
+ /** Returns a snapshot of the environment variables at invocation as a
+ * simple object of keys and values.
+ *
+ * ```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.
+ *
+ * @tags allow-env
+ */
+ toObject(): { [index: string]: string };
+ }
+
+ /** An interface containing methods to interact with the process environment
+ * variables.
+ *
+ * @tags allow-env
+ * @category Runtime Environment
+ */
+ export const env: Env;
+
+ /**
+ * Returns the path to the current deno executable.
+ *
+ * ```ts
+ * console.log(Deno.execPath()); // e.g. "/home/alice/.local/bin/deno"
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category Runtime Environment
+ */
+ 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 {@linkcode Deno.errors.NotFound} if directory not found.
+ *
+ * Throws {@linkcode Deno.errors.PermissionDenied} if the user does not have
+ * operating system file access rights.
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category Runtime Environment
+ */
+ export function chdir(directory: string | URL): 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 {@linkcode Deno.errors.NotFound} if directory not available.
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category Runtime Environment
+ */
+ export function cwd(): string;
+
+ /**
+ * Creates `newpath` as a hard link to `oldpath`.
+ *
+ * ```ts
+ * await Deno.link("old/name", "new/name");
+ * ```
+ *
+ * Requires `allow-read` and `allow-write` permissions.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function link(oldpath: string, newpath: string): Promise;
+
+ /**
+ * Synchronously creates `newpath` as a hard link to `oldpath`.
+ *
+ * ```ts
+ * Deno.linkSync("old/name", "new/name");
+ * ```
+ *
+ * Requires `allow-read` and `allow-write` permissions.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function linkSync(oldpath: string, newpath: string): void;
+
+ /**
+ * A enum which defines the seek mode for IO related APIs that support
+ * seeking.
+ *
+ * @category I/O */
+ export enum SeekMode {
+ /* Seek from the start of the file/resource. */
+ Start = 0,
+ /* Seek from the current position within the file/resource. */
+ Current = 1,
+ /* Seek from the end of the current file/resource. */
+ End = 2,
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to read
+ * bytes into an array buffer asynchronously.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O */
+ 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
+ * [`itereateReader`](https://deno.land/std/streams/iterate_reader.ts?s=iterateReader)
+ * from
+ * [`std/streams/iterate_reader.ts`](https://deno.land/std/streams/iterate_reader.ts)
+ * to turn a `Reader` into an {@linkcode AsyncIterator}.
+ */
+ read(p: Uint8Array): Promise;
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to read
+ * bytes into an array buffer synchronously.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O */
+ 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 `readSync()` 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, `readSync()` 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
+ * [`itereateReaderSync`](https://deno.land/std/streams/iterate_reader.ts?s=iterateReaderSync)
+ * from from
+ * [`std/streams/iterate_reader.ts`](https://deno.land/std/streams/iterate_reader.ts)
+ * to turn a `ReaderSync` into an {@linkcode Iterator}.
+ */
+ readSync(p: Uint8Array): number | null;
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to write
+ * bytes from an array buffer to a file/resource asynchronously.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O */
+ 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.
+ *
+ * This function is one of the lowest
+ * level APIs and most users should not work with this directly, but rather use
+ * [`writeAll()`](https://deno.land/std/streams/write_all.ts?s=writeAll) from
+ * [`std/streams/write_all.ts`](https://deno.land/std/streams/write_all.ts)
+ * instead.
+ *
+ * Implementations should not retain a reference to `p`.
+ */
+ write(p: Uint8Array): Promise;
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to write
+ * bytes from an array buffer to a file/resource synchronously.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O */
+ 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;
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to close
+ * files/resources that were previously opened.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O */
+ export interface Closer {
+ /** Closes the resource, "freeing" the backing file/resource. */
+ close(): void;
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to seek
+ * within an open file/resource asynchronously.
+ *
+ * @category I/O */
+ 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 resolves with the updated offset.
+ */
+ seek(offset: number | bigint, whence: SeekMode): Promise;
+ }
+
+ /**
+ * An abstract interface which when implemented provides an interface to seek
+ * within an open file/resource synchronously.
+ *
+ * @category I/O */
+ 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.
+ *
+ * It returns the updated offset.
+ */
+ seekSync(offset: number | bigint, 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.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ *
+ * @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;
+
+ /**
+ * Turns a Reader, `r`, into an async iterator.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function iter(
+ r: Reader,
+ options?: { bufSize?: number },
+ ): AsyncIterableIterator;
+
+ /**
+ * Turns a ReaderSync, `r`, into an iterator.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function iterSync(
+ r: ReaderSync,
+ options?: {
+ bufSize?: number;
+ },
+ ): IterableIterator;
+
+ /** Open a file and resolve to an instance of {@linkcode Deno.FsFile}. The
+ * file does not need to previously exist if using the `create` or `createNew`
+ * open options. The caller may have the resulting file automatically closed
+ * by the runtime once it's out of scope by declaring the file variable with
+ * the `using` keyword.
+ *
+ * ```ts
+ * using file = await Deno.open("/foo/bar.txt", { read: true, write: true });
+ * // Do work with file
+ * ```
+ *
+ * Alternatively, the caller may manually close the resource when finished with
+ * it.
+ *
+ * ```ts
+ * const file = await Deno.open("/foo/bar.txt", { read: true, write: true });
+ * // Do work with file
+ * file.close();
+ * ```
+ *
+ * Requires `allow-read` and/or `allow-write` permissions depending on
+ * options.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function open(
+ path: string | URL,
+ options?: OpenOptions,
+ ): Promise;
+
+ /** Synchronously open a file and return an instance of
+ * {@linkcode Deno.FsFile}. The file does not need to previously exist if
+ * using the `create` or `createNew` open options. The caller may have the
+ * resulting file automatically closed by the runtime once it's out of scope
+ * by declaring the file variable with the `using` keyword.
+ *
+ * ```ts
+ * using file = Deno.openSync("/foo/bar.txt", { read: true, write: true });
+ * // Do work with file
+ * ```
+ *
+ * Alternatively, the caller may manually close the resource when finished with
+ * it.
+ *
+ * ```ts
+ * const file = Deno.openSync("/foo/bar.txt", { read: true, write: true });
+ * // Do work with file
+ * file.close();
+ * ```
+ *
+ * Requires `allow-read` and/or `allow-write` permissions depending on
+ * options.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function openSync(path: string | URL, options?: OpenOptions): FsFile;
+
+ /** Creates a file if none exists or truncates an existing file and resolves to
+ * an instance of {@linkcode Deno.FsFile}.
+ *
+ * ```ts
+ * const file = await Deno.create("/foo/bar.txt");
+ * ```
+ *
+ * Requires `allow-read` and `allow-write` permissions.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function create(path: string | URL): Promise;
+
+ /** Creates a file if none exists or truncates an existing file and returns
+ * an instance of {@linkcode Deno.FsFile}.
+ *
+ * ```ts
+ * const file = Deno.createSync("/foo/bar.txt");
+ * ```
+ *
+ * Requires `allow-read` and `allow-write` permissions.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function createSync(path: string | URL): FsFile;
+
+ /** 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 {@linkcode ReadableStream} and
+ * {@linkcode https://deno.land/std/streams/mod.ts?s=toArrayBuffer|toArrayBuffer}
+ * 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":
+ * using 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"
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function read(rid: number, buffer: Uint8Array): Promise;
+
+ /** 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 {@linkcode ReadableStream} and
+ * {@linkcode https://deno.land/std/streams/mod.ts?s=toArrayBuffer|toArrayBuffer}
+ * 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":
+ * using 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"
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function readSync(rid: number, buffer: Uint8Array): number | null;
+
+ /** 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 {@linkcode WritableStream}, {@linkcode ReadableStream.from} and
+ * {@linkcode ReadableStream.pipeTo}.
+ *
+ * **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");
+ * using file = await Deno.open("/foo/bar.txt", { write: true });
+ * const bytesWritten = await Deno.write(file.rid, data); // 11
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function write(rid: number, data: Uint8Array): Promise;
+
+ /** 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 {@linkcode WritableStream}, {@linkcode ReadableStream.from} and
+ * {@linkcode ReadableStream.pipeTo}.
+ *
+ * **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");
+ * using file = Deno.openSync("/foo/bar.txt", { write: true });
+ * const bytesWritten = Deno.writeSync(file.rid, data); // 11
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function writeSync(rid: number, data: Uint8Array): 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
+ * // Given file.rid pointing to file with "Hello world", which is 11 bytes long:
+ * using file = await Deno.open(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * await file.write(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:
+ * using file = await Deno.open(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * await file.write(new TextEncoder().encode("Hello world"));
+ *
+ * // 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" (i.e. 11-2)
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function seek(
+ rid: number,
+ offset: number | bigint,
+ whence: SeekMode,
+ ): Promise;
+
+ /** 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
+ * using 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:
+ * using file = Deno.openSync(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * Deno.writeSync(file.rid, new TextEncoder().encode("Hello world"));
+ *
+ * // 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" (i.e. 11-2)
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function seekSync(
+ rid: number,
+ offset: number | bigint,
+ whence: SeekMode,
+ ): number;
+
+ /**
+ * 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 file.write(new TextEncoder().encode("Hello World"));
+ * await file.truncate(1);
+ * await Deno.fsync(file.rid);
+ * console.log(await Deno.readTextFile("my_file.txt")); // H
+ * ```
+ *
+ * @category File System
+ */
+ export function fsync(rid: number): Promise;
+
+ /**
+ * 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"));
+ * file.truncateSync(1);
+ * Deno.fsyncSync(file.rid);
+ * console.log(Deno.readTextFileSync("my_file.txt")); // H
+ * ```
+ *
+ * @category File System
+ */
+ export function fsyncSync(rid: number): void;
+
+ /**
+ * 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 file.write(new TextEncoder().encode("Hello World"));
+ * await Deno.fdatasync(file.rid);
+ * console.log(await Deno.readTextFile("my_file.txt")); // Hello World
+ * ```
+ *
+ * @category File System
+ */
+ export function fdatasync(rid: number): Promise;
+
+ /**
+ * 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(Deno.readTextFileSync("my_file.txt")); // Hello World
+ * ```
+ *
+ * @category File System
+ */
+ export function fdatasyncSync(rid: number): void;
+
+ /** 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);
+ * ```
+ *
+ * It is recommended to define the variable with the `using` keyword so the
+ * runtime will automatically close the resource when it goes out of scope.
+ * Doing so negates the need to manually close the resource.
+ *
+ * ```ts
+ * using file = await Deno.open("my_file.txt");
+ * // do work with "file" object
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function close(rid: number): void;
+
+ /** The Deno abstraction for reading and writing files.
+ *
+ * This is the most straight forward way of handling files within Deno and is
+ * recommended over using the discreet functions within the `Deno` namespace.
+ *
+ * ```ts
+ * using file = await Deno.open("/foo/bar.txt", { read: true });
+ * const fileInfo = await file.stat();
+ * if (fileInfo.isFile) {
+ * const buf = new Uint8Array(100);
+ * const numberOfBytesRead = await file.read(buf); // 11 bytes
+ * const text = new TextDecoder().decode(buf); // "hello world"
+ * }
+ * ```
+ *
+ * @category File System
+ */
+ export class FsFile
+ implements
+ Reader,
+ ReaderSync,
+ Writer,
+ WriterSync,
+ Seeker,
+ SeekerSync,
+ Closer,
+ Disposable {
+ /**
+ * The resource ID associated with the file instance. The resource ID
+ * should be considered an opaque reference to resource.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ readonly rid: number;
+ /** A {@linkcode ReadableStream} instance representing to the byte contents
+ * of the file. This makes it easy to interoperate with other web streams
+ * based APIs.
+ *
+ * ```ts
+ * using file = await Deno.open("my_file.txt", { read: true });
+ * const decoder = new TextDecoder();
+ * for await (const chunk of file.readable) {
+ * console.log(decoder.decode(chunk));
+ * }
+ * ```
+ */
+ readonly readable: ReadableStream;
+ /** A {@linkcode WritableStream} instance to write the contents of the
+ * file. This makes it easy to interoperate with other web streams based
+ * APIs.
+ *
+ * ```ts
+ * const items = ["hello", "world"];
+ * using file = await Deno.open("my_file.txt", { write: true });
+ * const encoder = new TextEncoder();
+ * const writer = file.writable.getWriter();
+ * for (const item of items) {
+ * await writer.write(encoder.encode(item));
+ * }
+ * ```
+ */
+ readonly writable: WritableStream;
+ /**
+ * The constructor which takes a resource ID. Generally `FsFile` should
+ * not be constructed directly. Instead use {@linkcode Deno.open} or
+ * {@linkcode Deno.openSync} to create a new instance of `FsFile`.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ constructor(rid: number);
+ /** Write the contents of the array buffer (`p`) to the file.
+ *
+ * Resolves to the number of bytes written.
+ *
+ * **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");
+ * using file = await Deno.open("/foo/bar.txt", { write: true });
+ * const bytesWritten = await file.write(data); // 11
+ * ```
+ *
+ * @category I/O
+ */
+ write(p: Uint8Array): Promise;
+ /** Synchronously write the contents of the array buffer (`p`) to the file.
+ *
+ * Returns the number of bytes written.
+ *
+ * **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");
+ * using file = Deno.openSync("/foo/bar.txt", { write: true });
+ * const bytesWritten = file.writeSync(data); // 11
+ * ```
+ */
+ writeSync(p: Uint8Array): number;
+ /** Truncates (or extends) the file to reach the specified `len`. If `len`
+ * is not specified, then the entire file contents are truncated.
+ *
+ * ### Truncate the entire file
+ *
+ * ```ts
+ * using file = await Deno.open("my_file.txt", { write: true });
+ * await file.truncate();
+ * ```
+ *
+ * ### Truncate part of the file
+ *
+ * ```ts
+ * // if "my_file.txt" contains the text "hello world":
+ * using file = await Deno.open("my_file.txt", { write: true });
+ * await file.truncate(7);
+ * const buf = new Uint8Array(100);
+ * await file.read(buf);
+ * const text = new TextDecoder().decode(buf); // "hello w"
+ * ```
+ */
+ truncate(len?: number): Promise;
+ /** Synchronously truncates (or extends) the file to reach the specified
+ * `len`. If `len` is not specified, then the entire file contents are
+ * truncated.
+ *
+ * ### Truncate the entire file
+ *
+ * ```ts
+ * using file = Deno.openSync("my_file.txt", { write: true });
+ * file.truncateSync();
+ * ```
+ *
+ * ### Truncate part of the file
+ *
+ * ```ts
+ * // if "my_file.txt" contains the text "hello world":
+ * using file = Deno.openSync("my_file.txt", { write: true });
+ * file.truncateSync(7);
+ * const buf = new Uint8Array(100);
+ * file.readSync(buf);
+ * const text = new TextDecoder().decode(buf); // "hello w"
+ * ```
+ */
+ truncateSync(len?: number): void;
+ /** Read the file into an array buffer (`p`).
+ *
+ * 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.
+ *
+ * **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":
+ * using file = await Deno.open("/foo/bar.txt");
+ * const buf = new Uint8Array(100);
+ * const numberOfBytesRead = await file.read(buf); // 11 bytes
+ * const text = new TextDecoder().decode(buf); // "hello world"
+ * ```
+ */
+ read(p: Uint8Array): Promise;
+ /** Synchronously read from the file into an array buffer (`p`).
+ *
+ * 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.
+ *
+ * **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":
+ * using file = Deno.openSync("/foo/bar.txt");
+ * const buf = new Uint8Array(100);
+ * const numberOfBytesRead = file.readSync(buf); // 11 bytes
+ * const text = new TextDecoder().decode(buf); // "hello world"
+ * ```
+ */
+ readSync(p: Uint8Array): number | null;
+ /** Seek to the given `offset` under mode given by `whence`. The call
+ * resolves to the new position within the resource (bytes from the start).
+ *
+ * ```ts
+ * // Given file pointing to file with "Hello world", which is 11 bytes long:
+ * using file = await Deno.open(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * await file.write(new TextEncoder().encode("Hello world"));
+ *
+ * // advance cursor 6 bytes
+ * const cursorPosition = await file.seek(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:
+ * const file = await Deno.open(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * await file.write(new TextEncoder().encode("Hello world"));
+ *
+ * // Seek 6 bytes from the start of the file
+ * console.log(await file.seek(6, Deno.SeekMode.Start)); // "6"
+ * // Seek 2 more bytes from the current position
+ * console.log(await file.seek(2, Deno.SeekMode.Current)); // "8"
+ * // Seek backwards 2 bytes from the end of the file
+ * console.log(await file.seek(-2, Deno.SeekMode.End)); // "9" (i.e. 11-2)
+ * ```
+ */
+ seek(offset: number | bigint, whence: SeekMode): Promise;
+ /** Synchronously seek to the given `offset` under mode given by `whence`.
+ * The new position within the resource (bytes from the start) is returned.
+ *
+ * ```ts
+ * using file = Deno.openSync(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * file.writeSync(new TextEncoder().encode("Hello world"));
+ *
+ * // advance cursor 6 bytes
+ * const cursorPosition = file.seekSync(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:
+ * using file = Deno.openSync(
+ * "hello.txt",
+ * { read: true, write: true, truncate: true, create: true },
+ * );
+ * file.writeSync(new TextEncoder().encode("Hello world"));
+ *
+ * // Seek 6 bytes from the start of the file
+ * console.log(file.seekSync(6, Deno.SeekMode.Start)); // "6"
+ * // Seek 2 more bytes from the current position
+ * console.log(file.seekSync(2, Deno.SeekMode.Current)); // "8"
+ * // Seek backwards 2 bytes from the end of the file
+ * console.log(file.seekSync(-2, Deno.SeekMode.End)); // "9" (i.e. 11-2)
+ * ```
+ */
+ seekSync(offset: number | bigint, whence: SeekMode): number;
+ /** Resolves to a {@linkcode Deno.FileInfo} for the file.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * using file = await Deno.open("hello.txt");
+ * const fileInfo = await file.stat();
+ * assert(fileInfo.isFile);
+ * ```
+ */
+ stat(): Promise;
+ /** Synchronously returns a {@linkcode Deno.FileInfo} for the file.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * using file = Deno.openSync("hello.txt")
+ * const fileInfo = file.statSync();
+ * assert(fileInfo.isFile);
+ * ```
+ */
+ statSync(): FileInfo;
+ /** **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 file.write(new TextEncoder().encode("Hello World"));
+ * await file.truncate(1);
+ * await file.sync();
+ * console.log(await Deno.readTextFile("my_file.txt")); // H
+ * ```
+ *
+ * @category I/O
+ */
+ sync(): Promise;
+ /** **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 },
+ * );
+ * file.writeSync(new TextEncoder().encode("Hello World"));
+ * file.truncateSync(1);
+ * file.syncSync();
+ * console.log(Deno.readTextFileSync("my_file.txt")); // H
+ * ```
+ *
+ * @category I/O
+ */
+ syncSync(): void;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Flushes any pending data operations of the given file stream to disk.
+ * ```ts
+ * using file = await Deno.open(
+ * "my_file.txt",
+ * { read: true, write: true, create: true },
+ * );
+ * await file.write(new TextEncoder().encode("Hello World"));
+ * await file.syncData();
+ * console.log(await Deno.readTextFile("my_file.txt")); // Hello World
+ * ```
+ *
+ * @category I/O
+ */
+ syncData(): Promise;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Synchronously flushes any pending data operations of the given file stream
+ * to disk.
+ *
+ * ```ts
+ * using file = Deno.openSync(
+ * "my_file.txt",
+ * { read: true, write: true, create: true },
+ * );
+ * file.writeSync(new TextEncoder().encode("Hello World"));
+ * file.syncDataSync();
+ * console.log(Deno.readTextFileSync("my_file.txt")); // Hello World
+ * ```
+ *
+ * @category I/O
+ */
+ syncDataSync(): void;
+ /**
+ * Changes the access (`atime`) and modification (`mtime`) times of the
+ * file stream resource. Given times are either in seconds (UNIX epoch
+ * time) or as `Date` objects.
+ *
+ * ```ts
+ * using file = await Deno.open("file.txt", { create: true, write: true });
+ * await file.utime(1556495550, new Date());
+ * ```
+ *
+ * @category File System
+ */
+ utime(atime: number | Date, mtime: number | Date): Promise;
+ /**
+ * Synchronously changes the access (`atime`) and modification (`mtime`)
+ * times of the file stream resource. Given times are either in seconds
+ * (UNIX epoch time) or as `Date` objects.
+ *
+ * ```ts
+ * using file = Deno.openSync("file.txt", { create: true, write: true });
+ * file.utime(1556495550, new Date());
+ * ```
+ *
+ * @category File System
+ */
+ utimeSync(atime: number | Date, mtime: number | Date): void;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Checks if the file resource is a TTY (terminal).
+ *
+ * ```ts
+ * // This example is system and context specific
+ * using file = await Deno.open("/dev/tty6");
+ * file.isTerminal(); // true
+ * ```
+ */
+ isTerminal(): boolean;
+ /** **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
+ * using file = await Deno.open("/dev/tty6");
+ * file.setRaw(true, { cbreak: true });
+ * ```
+ */
+ setRaw(mode: boolean, options?: SetRawOptions): void;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Acquire an advisory file-system lock for the file.
+ *
+ * @param [exclusive=false]
+ */
+ lock(exclusive?: boolean): Promise;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Synchronously acquire an advisory file-system lock synchronously for the file.
+ *
+ * @param [exclusive=false]
+ */
+ lockSync(exclusive?: boolean): void;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Release an advisory file-system lock for the file.
+ */
+ unlock(): Promise;
+ /** **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Synchronously release an advisory file-system lock for the file.
+ */
+ unlockSync(): void;
+ /** Close the file. Closing a file when you are finished with it is
+ * important to avoid leaking resources.
+ *
+ * ```ts
+ * using file = await Deno.open("my_file.txt");
+ * // do work with "file" object
+ * ```
+ */
+ close(): void;
+
+ [Symbol.dispose](): void;
+ }
+
+ /**
+ * The Deno abstraction for reading and writing files.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export const File: typeof FsFile;
+
+ /** Gets the size of the console as columns/rows.
+ *
+ * ```ts
+ * const { columns, rows } = Deno.consoleSize();
+ * ```
+ *
+ * This returns the size of the console window as reported by the operating
+ * system. It's not a reflection of how many characters will fit within the
+ * console window, but can be used as part of that calculation.
+ *
+ * @category I/O
+ */
+ export function consoleSize(): {
+ columns: number;
+ rows: number;
+ };
+
+ /** @category I/O */
+ export interface SetRawOptions {
+ /**
+ * The `cbreak` option can be used to indicate that characters that
+ * correspond to a signal should still be generated. When disabling raw
+ * mode, this option is ignored. This functionality currently only works on
+ * Linux and Mac OS.
+ */
+ cbreak: boolean;
+ }
+
+ /** A reference to `stdin` which can be used to read directly from `stdin`.
+ * It implements the Deno specific {@linkcode Reader}, {@linkcode ReaderSync},
+ * and {@linkcode Closer} interfaces as well as provides a
+ * {@linkcode ReadableStream} interface.
+ *
+ * ### Reading chunks from the readable stream
+ *
+ * ```ts
+ * const decoder = new TextDecoder();
+ * for await (const chunk of Deno.stdin.readable) {
+ * const text = decoder.decode(chunk);
+ * // do something with the text
+ * }
+ * ```
+ *
+ * @category I/O
+ */
+ export const stdin: Reader & ReaderSync & Closer & {
+ /**
+ * The resource ID assigned to `stdin`. This can be used with the discreet
+ * I/O functions in the `Deno` namespace.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ readonly rid: number;
+ /** A readable stream interface to `stdin`. */
+ readonly readable: ReadableStream;
+ /**
+ * 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.stdin.setRaw(true, { cbreak: true });
+ * ```
+ *
+ * @category I/O
+ */
+ setRaw(mode: boolean, options?: SetRawOptions): void;
+ /**
+ * Checks if `stdin` is a TTY (terminal).
+ *
+ * ```ts
+ * // This example is system and context specific
+ * Deno.stdin.isTerminal(); // true
+ * ```
+ *
+ * @category I/O
+ */
+ isTerminal(): boolean;
+ };
+ /** A reference to `stdout` which can be used to write directly to `stdout`.
+ * It implements the Deno specific {@linkcode Writer}, {@linkcode WriterSync},
+ * and {@linkcode Closer} interfaces as well as provides a
+ * {@linkcode WritableStream} interface.
+ *
+ * These are low level constructs, and the {@linkcode console} interface is a
+ * more straight forward way to interact with `stdout` and `stderr`.
+ *
+ * @category I/O
+ */
+ export const stdout: Writer & WriterSync & Closer & {
+ /**
+ * The resource ID assigned to `stdout`. This can be used with the discreet
+ * I/O functions in the `Deno` namespace.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ readonly rid: number;
+ /** A writable stream interface to `stdout`. */
+ readonly writable: WritableStream;
+ /**
+ * Checks if `stdout` is a TTY (terminal).
+ *
+ * ```ts
+ * // This example is system and context specific
+ * Deno.stdout.isTerminal(); // true
+ * ```
+ *
+ * @category I/O
+ */
+ isTerminal(): boolean;
+ };
+ /** A reference to `stderr` which can be used to write directly to `stderr`.
+ * It implements the Deno specific {@linkcode Writer}, {@linkcode WriterSync},
+ * and {@linkcode Closer} interfaces as well as provides a
+ * {@linkcode WritableStream} interface.
+ *
+ * These are low level constructs, and the {@linkcode console} interface is a
+ * more straight forward way to interact with `stdout` and `stderr`.
+ *
+ * @category I/O
+ */
+ export const stderr: Writer & WriterSync & Closer & {
+ /**
+ * The resource ID assigned to `stderr`. This can be used with the discreet
+ * I/O functions in the `Deno` namespace.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ readonly rid: number;
+ /** A writable stream interface to `stderr`. */
+ readonly writable: WritableStream;
+ /**
+ * Checks if `stderr` is a TTY (terminal).
+ *
+ * ```ts
+ * // This example is system and context specific
+ * Deno.stderr.isTerminal(); // true
+ * ```
+ *
+ * @category I/O
+ */
+ isTerminal(): boolean;
+ };
+
+ /**
+ * Options which can be set when doing {@linkcode Deno.open} and
+ * {@linkcode Deno.openSync}.
+ *
+ * @category File System */
+ export interface OpenOptions {
+ /** Sets the option for read access. This option, when `true`, means that
+ * the file should be read-able if opened.
+ *
+ * @default {true} */
+ 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.
+ *
+ * @default {false} */
+ 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 }`.
+ *
+ * @default {false} */
+ 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.
+ *
+ * @default {false} */
+ 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.
+ *
+ * @default {false} */
+ create?: boolean;
+ /** 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.
+ *
+ * @default {false} */
+ createNew?: boolean;
+ /** Permissions to use if creating the file (defaults to `0o666`, before
+ * the process's umask).
+ *
+ * Ignored on Windows. */
+ mode?: number;
+ }
+
+ /**
+ * Options which can be set when using {@linkcode Deno.readFile} or
+ * {@linkcode Deno.readFileSync}.
+ *
+ * @category File System */
+ export interface ReadFileOptions {
+ /**
+ * An abort signal to allow cancellation of the file read operation.
+ * If the signal becomes aborted the readFile operation will be stopped
+ * and the promise returned will be rejected with an AbortError.
+ */
+ signal?: AbortSignal;
+ }
+
+ /**
+ * Check if a given resource id (`rid`) is a TTY (a terminal).
+ *
+ * ```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
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function isatty(rid: number): boolean;
+
+ /**
+ * A variable-sized buffer of bytes with `read()` and `write()` methods.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ 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 synchronously; it's provided for
+ * compatibility with `Reader` interfaces.
+ */
+ read(p: Uint8Array): Promise;
+ writeSync(p: Uint8Array): number;
+ /** NOTE: This methods writes bytes synchronously; it's provided for
+ * compatibility with `Writer` interface. */
+ write(p: Uint8Array): Promise;
+ /** 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;
+ /** 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`.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function readAll(r: Reader): Promise;
+
+ /**
+ * Synchronously reads Reader `r` until EOF (`null`) and returns the content
+ * as `Uint8Array`.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function readAllSync(r: ReaderSync): Uint8Array;
+
+ /**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function writeAll(w: Writer, arr: Uint8Array): Promise;
+
+ /**
+ * Synchronously write all the content of the array buffer (`arr`) to the
+ * writer (`w`).
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category I/O
+ */
+ export function writeAllSync(w: WriterSync, arr: Uint8Array): void;
+
+ /**
+ * Options which can be set when using {@linkcode Deno.mkdir} and
+ * {@linkcode Deno.mkdirSync}.
+ *
+ * @category File System */
+ export interface MkdirOptions {
+ /** 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.
+ *
+ * @default {false} */
+ recursive?: boolean;
+ /** Permissions to use when creating the directory (defaults to `0o777`,
+ * before the process's umask).
+ *
+ * Ignored on Windows. */
+ mode?: number;
+ }
+
+ /** 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function mkdir(
+ path: string | URL,
+ options?: MkdirOptions,
+ ): Promise;
+
+ /** 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function mkdirSync(path: string | URL, options?: MkdirOptions): void;
+
+ /**
+ * Options which can be set when using {@linkcode Deno.makeTempDir},
+ * {@linkcode Deno.makeTempDirSync}, {@linkcode Deno.makeTempFile}, and
+ * {@linkcode Deno.makeTempFileSync}.
+ *
+ * @category File System */
+ 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;
+ }
+
+ /** Creates a new temporary directory in the default directory for temporary
+ * files, 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ // TODO(ry) Doesn't check permissions.
+ export function makeTempDir(options?: MakeTempOptions): Promise;
+
+ /** Synchronously creates a new temporary directory in the default directory
+ * for temporary files, 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ // TODO(ry) Doesn't check permissions.
+ export function makeTempDirSync(options?: MakeTempOptions): string;
+
+ /** Creates a new temporary file in the default directory for temporary
+ * files, unless `dir` is specified.
+ *
+ * Other 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function makeTempFile(options?: MakeTempOptions): Promise;
+
+ /** Synchronously creates a new temporary file in the default directory for
+ * temporary files, unless `dir` is specified.
+ *
+ * Other 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function makeTempFileSync(options?: MakeTempOptions): string;
+
+ /** 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function chmod(path: string | URL, mode: number): Promise;
+
+ /** 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 {@linkcode Deno.chmod}.
+ *
+ * NOTE: This API currently throws on Windows
+ *
+ * Requires `allow-write` permission.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function chmodSync(path: string | URL, mode: number): 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.
+ *
+ * @tags allow-write
+ * @category File System
+ *
+ * @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;
+
+ /** 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.
+ *
+ * @tags allow-write
+ * @category File System
+ *
+ * @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;
+
+ /**
+ * Options which can be set when using {@linkcode Deno.remove} and
+ * {@linkcode Deno.removeSync}.
+ *
+ * @category File System */
+ export interface RemoveOptions {
+ /** If set to `true`, path will be removed even if it's a non-empty directory.
+ *
+ * @default {false} */
+ recursive?: boolean;
+ }
+
+ /** 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function remove(
+ path: string | URL,
+ options?: RemoveOptions,
+ ): Promise;
+
+ /** 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function removeSync(path: string | URL, options?: RemoveOptions): 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-like OSes, 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.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function renameSync(
+ oldpath: string | URL,
+ newpath: string | URL,
+ ): 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-like OSes, 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.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function rename(
+ oldpath: string | URL,
+ newpath: string | URL,
+ ): Promise;
+
+ /** Asynchronously reads and returns the entire contents of a file as an UTF-8
+ * decoded string. Reading a directory throws an error.
+ *
+ * ```ts
+ * const data = await Deno.readTextFile("hello.txt");
+ * console.log(data);
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readTextFile(
+ path: string | URL,
+ options?: ReadFileOptions,
+ ): Promise;
+
+ /** Synchronously reads and returns the entire contents of a file as an UTF-8
+ * decoded string. Reading a directory throws an error.
+ *
+ * ```ts
+ * const data = Deno.readTextFileSync("hello.txt");
+ * console.log(data);
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readTextFileSync(path: string | URL): string;
+
+ /** 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.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readFile(
+ path: string | URL,
+ options?: ReadFileOptions,
+ ): Promise;
+
+ /** 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.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readFileSync(path: string | URL): Uint8Array;
+
+ /** Provides information about a file and is returned by
+ * {@linkcode Deno.stat}, {@linkcode Deno.lstat}, {@linkcode Deno.statSync},
+ * and {@linkcode Deno.lstatSync} or from calling `stat()` and `statSync()`
+ * on an {@linkcode Deno.FsFile} instance.
+ *
+ * @category File System
+ */
+ 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. */
+ dev: number;
+ /** Inode number.
+ *
+ * _Linux/Mac OS only._ */
+ ino: number | null;
+ /** The underlying raw `st_mode` bits that contain the standard Unix
+ * permissions for this file/directory.
+ *
+ * _Linux/Mac OS only._ */
+ 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;
+ /** True if this is info for a block device.
+ *
+ * _Linux/Mac OS only._ */
+ isBlockDevice: boolean | null;
+ /** True if this is info for a char device.
+ *
+ * _Linux/Mac OS only._ */
+ isCharDevice: boolean | null;
+ /** True if this is info for a fifo.
+ *
+ * _Linux/Mac OS only._ */
+ isFifo: boolean | null;
+ /** True if this is info for a socket.
+ *
+ * _Linux/Mac OS only._ */
+ isSocket: boolean | null;
+ }
+
+ /** 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.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function realPath(path: string | URL): Promise;
+
+ /** Synchronously 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.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function realPathSync(path: string | URL): string;
+
+ /**
+ * Information about a directory entry returned from {@linkcode Deno.readDir}
+ * and {@linkcode Deno.readDirSync}.
+ *
+ * @category File System */
+ export interface DirEntry {
+ /** The file name of the entry. It is just the entity name and does not
+ * include the full path. */
+ name: string;
+ /** True if this is info for a regular file. Mutually exclusive to
+ * `DirEntry.isDirectory` and `DirEntry.isSymlink`. */
+ isFile: boolean;
+ /** True if this is info for a regular directory. Mutually exclusive to
+ * `DirEntry.isFile` and `DirEntry.isSymlink`. */
+ isDirectory: boolean;
+ /** True if this is info for a symlink. Mutually exclusive to
+ * `DirEntry.isFile` and `DirEntry.isDirectory`. */
+ isSymlink: boolean;
+ }
+
+ /** Reads the directory given by `path` and returns an async iterable of
+ * {@linkcode Deno.DirEntry}. The order of entries is not guaranteed.
+ *
+ * ```ts
+ * for await (const dirEntry of Deno.readDir("/")) {
+ * console.log(dirEntry.name);
+ * }
+ * ```
+ *
+ * Throws error if `path` is not a directory.
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readDir(path: string | URL): AsyncIterable;
+
+ /** Synchronously reads the directory given by `path` and returns an iterable
+ * of {@linkcode Deno.DirEntry}. The order of entries is not guaranteed.
+ *
+ * ```ts
+ * for (const dirEntry of Deno.readDirSync("/")) {
+ * console.log(dirEntry.name);
+ * }
+ * ```
+ *
+ * Throws error if `path` is not a directory.
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readDirSync(path: string | URL): Iterable;
+
+ /** 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`.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function copyFile(
+ fromPath: string | URL,
+ toPath: string | URL,
+ ): Promise;
+
+ /** 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`.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function copyFileSync(
+ fromPath: string | URL,
+ toPath: string | URL,
+ ): void;
+
+ /** 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.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readLink(path: string | URL): Promise;
+
+ /** Synchronously 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.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function readLinkSync(path: string | URL): string;
+
+ /** Resolves to a {@linkcode 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/assert/mod.ts";
+ * const fileInfo = await Deno.lstat("hello.txt");
+ * assert(fileInfo.isFile);
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function lstat(path: string | URL): Promise;
+
+ /** Synchronously returns a {@linkcode 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/assert/mod.ts";
+ * const fileInfo = Deno.lstatSync("hello.txt");
+ * assert(fileInfo.isFile);
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function lstatSync(path: string | URL): FileInfo;
+
+ /** Resolves to a {@linkcode Deno.FileInfo} for the specified `path`. Will
+ * always follow symlinks.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ * const fileInfo = await Deno.stat("hello.txt");
+ * assert(fileInfo.isFile);
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function stat(path: string | URL): Promise;
+
+ /** Synchronously returns a {@linkcode Deno.FileInfo} for the specified
+ * `path`. Will always follow symlinks.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ * const fileInfo = Deno.statSync("hello.txt");
+ * assert(fileInfo.isFile);
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function statSync(path: string | URL): FileInfo;
+
+ /** Options for writing to a file.
+ *
+ * @category File System
+ */
+ export interface WriteFileOptions {
+ /** If set to `true`, will append to a file instead of overwriting previous
+ * contents.
+ *
+ * @default {false} */
+ append?: boolean;
+ /** Sets the option to allow creating a new file, if one doesn't already
+ * exist at the specified path.
+ *
+ * @default {true} */
+ create?: boolean;
+ /** If set to `true`, no file, directory, or symlink is allowed to exist at
+ * the target location. When createNew is set to `true`, `create` is ignored.
+ *
+ * @default {false} */
+ createNew?: boolean;
+ /** Permissions always applied to file. */
+ mode?: number;
+ /** An abort signal to allow cancellation of the file write operation.
+ *
+ * If the signal becomes aborted the write file operation will be stopped
+ * and the promise returned will be rejected with an {@linkcode AbortError}.
+ */
+ signal?: AbortSignal;
+ }
+
+ /** 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`.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function writeFile(
+ path: string | URL,
+ data: Uint8Array | ReadableStream,
+ options?: WriteFileOptions,
+ ): Promise;
+
+ /** 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`.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function writeFileSync(
+ path: string | URL,
+ data: Uint8Array,
+ options?: WriteFileOptions,
+ ): void;
+
+ /** 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`.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function writeTextFile(
+ path: string | URL,
+ data: string | ReadableStream,
+ options?: WriteFileOptions,
+ ): Promise;
+
+ /** Synchronously write string `data` to the given `path`, by default creating
+ * a new file if needed, else overwriting.
+ *
+ * ```ts
+ * 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`.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function writeTextFileSync(
+ path: string | URL,
+ data: string,
+ options?: WriteFileOptions,
+ ): void;
+
+ /** Truncates (or extends) the specified file, to reach the specified `len`.
+ * If `len` is not specified then the entire file contents are truncated.
+ *
+ * ### Truncate the entire file
+ * ```ts
+ * await Deno.truncate("my_file.txt");
+ * ```
+ *
+ * ### Truncate part of the file
+ *
+ * ```ts
+ * const file = await Deno.makeTempFile();
+ * await Deno.writeTextFile(file, "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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function truncate(name: string, len?: number): Promise;
+
+ /** Synchronously truncates (or extends) the specified file, to reach the
+ * specified `len`. If `len` is not specified then the entire file contents
+ * are truncated.
+ *
+ * ### Truncate the entire file
+ *
+ * ```ts
+ * Deno.truncateSync("my_file.txt");
+ * ```
+ *
+ * ### Truncate part of the file
+ *
+ * ```ts
+ * 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function truncateSync(name: string, len?: number): void;
+
+ /** @category Observability
+ *
+ * @deprecated This will be removed in Deno 2.0.
+ */
+ export interface OpMetrics {
+ opsDispatched: number;
+ opsDispatchedSync: number;
+ opsDispatchedAsync: number;
+ opsDispatchedAsyncUnref: number;
+ opsCompleted: number;
+ opsCompletedSync: number;
+ opsCompletedAsync: number;
+ opsCompletedAsyncUnref: number;
+ bytesSentControl: number;
+ bytesSentData: number;
+ bytesReceived: number;
+ }
+
+ /** @category Observability
+ *
+ * @deprecated This will be removed in Deno 2.0.
+ */
+ export interface Metrics extends OpMetrics {
+ ops: Record;
+ }
+
+ /** 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 sandbox and the rest of Deno.
+ *
+ * ```shell
+ * > 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 │
+ * └─────────────────────────┴────────┘
+ * ```
+ *
+ * @category Observability
+ *
+ * @deprecated This will be removed in Deno 2.0.
+ */
+ export function metrics(): Metrics;
+
+ /**
+ * A map of open resources that Deno is tracking. The key is the resource ID
+ * (_rid_) and the value is its representation.
+ *
+ * @deprecated This will be removed in Deno 2.0.
+ *
+ * @category Observability */
+ interface ResourceMap {
+ [rid: number]: unknown;
+ }
+
+ /** Returns a map of open resource IDs (_rid_) along with their string
+ * representations. This is an internal API and as such resource
+ * representation has `unknown` type; that means it can change any time and
+ * should not be depended upon.
+ *
+ * ```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" }
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0.
+ *
+ * @category Observability
+ */
+ export function resources(): ResourceMap;
+
+ /**
+ * Additional information for FsEvent objects with the "other" kind.
+ *
+ * - `"rescan"`: rescan notices indicate either a lapse in the events or a
+ * change in the filesystem such that events received so far can no longer
+ * be relied on to represent the state of the filesystem now. An
+ * application that simply reacts to file changes may not care about this.
+ * An application that keeps an in-memory representation of the filesystem
+ * will need to care, and will need to refresh that representation directly
+ * from the filesystem.
+ *
+ * @category File System
+ */
+ export type FsEventFlag = "rescan";
+
+ /**
+ * Represents a unique file system event yielded by a
+ * {@linkcode Deno.FsWatcher}.
+ *
+ * @category File System */
+ export interface FsEvent {
+ /** The kind/type of the file system event. */
+ kind: "any" | "access" | "create" | "modify" | "remove" | "other";
+ /** An array of paths that are associated with the file system event. */
+ paths: string[];
+ /** Any additional flags associated with the event. */
+ flag?: FsEventFlag;
+ }
+
+ /**
+ * Returned by {@linkcode Deno.watchFs}. It is an async iterator yielding up
+ * system events. To stop watching the file system by calling `.close()`
+ * method.
+ *
+ * @category File System
+ */
+ export interface FsWatcher extends AsyncIterable, Disposable {
+ /**
+ * The resource id.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ readonly rid: number;
+ /** Stops watching the file system and closes the watcher resource. */
+ close(): void;
+ /**
+ * Stops watching the file system and closes the watcher resource.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ return?(value?: any): Promise>;
+ [Symbol.asyncIterator](): AsyncIterableIterator;
+ }
+
+ /** 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`).
+ *
+ * The 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" ] }
+ * }
+ * ```
+ *
+ * Call `watcher.close()` to stop watching.
+ *
+ * ```ts
+ * const watcher = Deno.watchFs("/");
+ *
+ * setTimeout(() => {
+ * watcher.close();
+ * }, 5000);
+ *
+ * for await (const event of watcher) {
+ * console.log(">>>> event", event);
+ * }
+ * ```
+ *
+ * Requires `allow-read` permission.
+ *
+ * @tags allow-read
+ * @category File System
+ */
+ export function watchFs(
+ paths: string | string[],
+ options?: { recursive: boolean },
+ ): FsWatcher;
+
+ /**
+ * Options which can be used with {@linkcode Deno.run}.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category Sub Process */
+ export interface RunOptions {
+ /** Arguments to pass.
+ *
+ * _Note_: the first element needs to be a path to the executable that is
+ * being run. */
+ cmd: readonly string[] | [string | URL, ...string[]];
+ /** The current working directory that should be used when running the
+ * sub-process. */
+ cwd?: string;
+ /** Any environment variables to be set when running the sub-process. */
+ env?: Record;
+ /** By default subprocess inherits `stdout` of parent process. To change
+ * this this option can be set to a resource ID (_rid_) of an open file,
+ * `"inherit"`, `"piped"`, or `"null"`:
+ *
+ * - _number_: the resource ID of an open file/resource. This allows you to
+ * write to a file.
+ * - `"inherit"`: The default if unspecified. The subprocess inherits from the
+ * parent.
+ * - `"piped"`: A new pipe should be arranged to connect the parent and child
+ * sub-process.
+ * - `"null"`: This stream will be ignored. This is the equivalent of attaching
+ * the stream to `/dev/null`.
+ */
+ stdout?: "inherit" | "piped" | "null" | number;
+ /** By default subprocess inherits `stderr` of parent process. To change
+ * this this option can be set to a resource ID (_rid_) of an open file,
+ * `"inherit"`, `"piped"`, or `"null"`:
+ *
+ * - _number_: the resource ID of an open file/resource. This allows you to
+ * write to a file.
+ * - `"inherit"`: The default if unspecified. The subprocess inherits from the
+ * parent.
+ * - `"piped"`: A new pipe should be arranged to connect the parent and child
+ * sub-process.
+ * - `"null"`: This stream will be ignored. This is the equivalent of attaching
+ * the stream to `/dev/null`.
+ */
+ stderr?: "inherit" | "piped" | "null" | number;
+ /** By default subprocess inherits `stdin` of parent process. To change
+ * this this option can be set to a resource ID (_rid_) of an open file,
+ * `"inherit"`, `"piped"`, or `"null"`:
+ *
+ * - _number_: the resource ID of an open file/resource. This allows you to
+ * read from a file.
+ * - `"inherit"`: The default if unspecified. The subprocess inherits from the
+ * parent.
+ * - `"piped"`: A new pipe should be arranged to connect the parent and child
+ * sub-process.
+ * - `"null"`: This stream will be ignored. This is the equivalent of attaching
+ * the stream to `/dev/null`.
+ */
+ stdin?: "inherit" | "piped" | "null" | number;
+ }
+
+ /**
+ * The status resolved from the `.status()` method of a
+ * {@linkcode Deno.Process} instance.
+ *
+ * If `success` is `true`, then `code` will be `0`, but if `success` is
+ * `false`, the sub-process exit code will be set in `code`.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category Sub Process */
+ export type ProcessStatus =
+ | {
+ success: true;
+ code: 0;
+ signal?: undefined;
+ }
+ | {
+ success: false;
+ code: number;
+ signal?: number;
+ };
+
+ /**
+ * Represents an instance of a sub process that is returned from
+ * {@linkcode Deno.run} which can be used to manage the sub-process.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category Sub Process */
+ export class Process {
+ /** The resource ID of the sub-process. */
+ readonly rid: number;
+ /** The operating system's process ID for the sub-process. */
+ readonly pid: number;
+ /** A reference to the sub-processes `stdin`, which allows interacting with
+ * the sub-process at a low level. */
+ readonly stdin: T["stdin"] extends "piped" ? Writer & Closer & {
+ writable: WritableStream;
+ }
+ : (Writer & Closer & { writable: WritableStream }) | null;
+ /** A reference to the sub-processes `stdout`, which allows interacting with
+ * the sub-process at a low level. */
+ readonly stdout: T["stdout"] extends "piped" ? Reader & Closer & {
+ readable: ReadableStream;
+ }
+ : (Reader & Closer & { readable: ReadableStream }) | null;
+ /** A reference to the sub-processes `stderr`, which allows interacting with
+ * the sub-process at a low level. */
+ readonly stderr: T["stderr"] extends "piped" ? Reader & Closer & {
+ readable: ReadableStream;
+ }
+ : (Reader & Closer & { readable: ReadableStream }) | null;
+ /** Wait for the process to exit and return its exit status.
+ *
+ * Calling this function multiple times will return the same status.
+ *
+ * The `stdin` reference to the process will be closed before waiting to
+ * avoid a deadlock.
+ *
+ * If `stdout` and/or `stderr` were set to `"piped"`, they must be closed
+ * manually before the process can exit.
+ *
+ * To run process to completion and collect output from both `stdout` and
+ * `stderr` use:
+ *
+ * ```ts
+ * const p = Deno.run({ cmd: [ "echo", "hello world" ], stderr: 'piped', stdout: 'piped' });
+ * const [status, stdout, stderr] = await Promise.all([
+ * p.status(),
+ * p.output(),
+ * p.stderrOutput()
+ * ]);
+ * p.close();
+ * ```
+ */
+ status(): Promise;
+ /** 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;
+ /** 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;
+ /** Clean up resources associated with the sub-process instance. */
+ close(): void;
+ /** Send a signal to process.
+ * Default signal is `"SIGTERM"`.
+ *
+ * ```ts
+ * const p = Deno.run({ cmd: [ "sleep", "20" ]});
+ * p.kill("SIGTERM");
+ * p.close();
+ * ```
+ */
+ kill(signo?: Signal): void;
+ }
+
+ /** Operating signals which can be listened for or sent to sub-processes. What
+ * signals and what their standard behaviors are OS dependent.
+ *
+ * @category Runtime Environment */
+ export type Signal =
+ | "SIGABRT"
+ | "SIGALRM"
+ | "SIGBREAK"
+ | "SIGBUS"
+ | "SIGCHLD"
+ | "SIGCONT"
+ | "SIGEMT"
+ | "SIGFPE"
+ | "SIGHUP"
+ | "SIGILL"
+ | "SIGINFO"
+ | "SIGINT"
+ | "SIGIO"
+ | "SIGKILL"
+ | "SIGPIPE"
+ | "SIGPROF"
+ | "SIGPWR"
+ | "SIGQUIT"
+ | "SIGSEGV"
+ | "SIGSTKFLT"
+ | "SIGSTOP"
+ | "SIGSYS"
+ | "SIGTERM"
+ | "SIGTRAP"
+ | "SIGTSTP"
+ | "SIGTTIN"
+ | "SIGTTOU"
+ | "SIGURG"
+ | "SIGUSR1"
+ | "SIGUSR2"
+ | "SIGVTALRM"
+ | "SIGWINCH"
+ | "SIGXCPU"
+ | "SIGXFSZ";
+
+ /** Registers the given function as a listener of the given signal event.
+ *
+ * ```ts
+ * Deno.addSignalListener(
+ * "SIGTERM",
+ * () => {
+ * console.log("SIGTERM!")
+ * }
+ * );
+ * ```
+ *
+ * _Note_: On Windows only `"SIGINT"` (CTRL+C) and `"SIGBREAK"` (CTRL+Break)
+ * are supported.
+ *
+ * @category Runtime Environment
+ */
+ export function addSignalListener(signal: Signal, handler: () => void): void;
+
+ /** Removes the given signal listener that has been registered with
+ * {@linkcode Deno.addSignalListener}.
+ *
+ * ```ts
+ * const listener = () => {
+ * console.log("SIGTERM!")
+ * };
+ * Deno.addSignalListener("SIGTERM", listener);
+ * Deno.removeSignalListener("SIGTERM", listener);
+ * ```
+ *
+ * _Note_: On Windows only `"SIGINT"` (CTRL+C) and `"SIGBREAK"` (CTRL+Break)
+ * are supported.
+ *
+ * @category Runtime Environment
+ */
+ export function removeSignalListener(
+ signal: Signal,
+ handler: () => void,
+ ): void;
+
+ /**
+ * 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: ["curl", "https://example.com"],
+ * });
+ * const status = await p.status();
+ * ```
+ *
+ * Subprocess uses same working directory as parent process unless `opt.cwd`
+ * is specified.
+ *
+ * Environmental variables from parent process can be cleared using `opt.clearEnv`.
+ * Doesn't guarantee that only `opt.env` variables are present,
+ * as the OS may set environmental variables for processes.
+ *
+ * Environmental variables for subprocess can be specified using `opt.env`
+ * mapping.
+ *
+ * `opt.uid` sets the child process’s user ID. This translates to a setuid call
+ * in the child process. Failure in the setuid call will cause the spawn to fail.
+ *
+ * `opt.gid` is similar to `opt.uid`, but sets the group ID of the child process.
+ * This has the same semantics as the uid field.
+ *
+ * By default subprocess inherits stdio of parent process. To change
+ * this this, `opt.stdin`, `opt.stdout`, and `opt.stderr` can be set
+ * independently to a resource ID (_rid_) of an open file, `"inherit"`,
+ * `"piped"`, or `"null"`:
+ *
+ * - _number_: the resource ID of an open file/resource. This allows you to
+ * read or write to a file.
+ * - `"inherit"`: The default if unspecified. The subprocess inherits from the
+ * parent.
+ * - `"piped"`: A new pipe should be arranged to connect the parent and child
+ * sub-process.
+ * - `"null"`: This stream will be ignored. This is the equivalent of attaching
+ * the stream to `/dev/null`.
+ *
+ * Details of the spawned process are returned as an instance of
+ * {@linkcode Deno.Process}.
+ *
+ * Requires `allow-run` permission.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @tags allow-run
+ * @category Sub Process
+ */
+ export function run(opt: T): Process;
+
+ /** Create a child process.
+ *
+ * If any stdio options are not set to `"piped"`, accessing the corresponding
+ * field on the `Command` or its `CommandOutput` will throw a `TypeError`.
+ *
+ * If `stdin` is set to `"piped"`, the `stdin` {@linkcode WritableStream}
+ * needs to be closed manually.
+ *
+ * @example Spawn a subprocess and pipe the output to a file
+ *
+ * ```ts
+ * const command = new Deno.Command(Deno.execPath(), {
+ * args: [
+ * "eval",
+ * "console.log('Hello World')",
+ * ],
+ * stdin: "piped",
+ * stdout: "piped",
+ * });
+ * const child = command.spawn();
+ *
+ * // open a file and pipe the subprocess output to it.
+ * child.stdout.pipeTo(
+ * Deno.openSync("output", { write: true, create: true }).writable,
+ * );
+ *
+ * // manually close stdin
+ * child.stdin.close();
+ * const status = await child.status;
+ * ```
+ *
+ * @example Spawn a subprocess and collect its output
+ *
+ * ```ts
+ * const command = new Deno.Command(Deno.execPath(), {
+ * args: [
+ * "eval",
+ * "console.log('hello'); console.error('world')",
+ * ],
+ * });
+ * const { code, stdout, stderr } = await command.output();
+ * console.assert(code === 0);
+ * console.assert("hello\n" === new TextDecoder().decode(stdout));
+ * console.assert("world\n" === new TextDecoder().decode(stderr));
+ * ```
+ *
+ * @example Spawn a subprocess and collect its output synchronously
+ *
+ * ```ts
+ * const command = new Deno.Command(Deno.execPath(), {
+ * args: [
+ * "eval",
+ * "console.log('hello'); console.error('world')",
+ * ],
+ * });
+ * const { code, stdout, stderr } = command.outputSync();
+ * console.assert(code === 0);
+ * console.assert("hello\n" === new TextDecoder().decode(stdout));
+ * console.assert("world\n" === new TextDecoder().decode(stderr));
+ * ```
+ *
+ * @tags allow-run
+ * @category Sub Process
+ */
+ export class Command {
+ constructor(command: string | URL, options?: CommandOptions);
+ /**
+ * Executes the {@linkcode Deno.Command}, waiting for it to finish and
+ * collecting all of its output.
+ * If `spawn()` was called, calling this function will collect the remaining
+ * output.
+ *
+ * Will throw an error if `stdin: "piped"` is set.
+ *
+ * If options `stdout` or `stderr` are not set to `"piped"`, accessing the
+ * corresponding field on {@linkcode Deno.CommandOutput} will throw a `TypeError`.
+ */
+ output(): Promise;
+ /**
+ * Synchronously executes the {@linkcode Deno.Command}, waiting for it to
+ * finish and collecting all of its output.
+ *
+ * Will throw an error if `stdin: "piped"` is set.
+ *
+ * If options `stdout` or `stderr` are not set to `"piped"`, accessing the
+ * corresponding field on {@linkcode Deno.CommandOutput} will throw a `TypeError`.
+ */
+ outputSync(): CommandOutput;
+ /**
+ * Spawns a streamable subprocess, allowing to use the other methods.
+ */
+ spawn(): ChildProcess;
+ }
+
+ /**
+ * The interface for handling a child process returned from
+ * {@linkcode Deno.Command.spawn}.
+ *
+ * @category Sub Process
+ */
+ export class ChildProcess implements AsyncDisposable {
+ get stdin(): WritableStream;
+ get stdout(): ReadableStream;
+ get stderr(): ReadableStream;
+ readonly pid: number;
+ /** Get the status of the child. */
+ readonly status: Promise;
+
+ /** Waits for the child to exit completely, returning all its output and
+ * status. */
+ output(): Promise;
+ /** Kills the process with given {@linkcode Deno.Signal}.
+ *
+ * Defaults to `SIGTERM` if no signal is provided.
+ *
+ * @param [signo="SIGTERM"]
+ */
+ kill(signo?: Signal): void;
+
+ /** Ensure that the status of the child process prevents the Deno process
+ * from exiting. */
+ ref(): void;
+ /** Ensure that the status of the child process does not block the Deno
+ * process from exiting. */
+ unref(): void;
+
+ [Symbol.asyncDispose](): Promise;
+ }
+
+ /**
+ * Options which can be set when calling {@linkcode Deno.Command}.
+ *
+ * @category Sub Process
+ */
+ export interface CommandOptions {
+ /** Arguments to pass to the process. */
+ args?: string[];
+ /**
+ * The working directory of the process.
+ *
+ * If not specified, the `cwd` of the parent process is used.
+ */
+ cwd?: string | URL;
+ /**
+ * Clear environmental variables from parent process.
+ *
+ * Doesn't guarantee that only `env` variables are present, as the OS may
+ * set environmental variables for processes.
+ *
+ * @default {false}
+ */
+ clearEnv?: boolean;
+ /** Environmental variables to pass to the subprocess. */
+ env?: Record;
+ /**
+ * Sets the child process’s user ID. This translates to a setuid call in the
+ * child process. Failure in the set uid call will cause the spawn to fail.
+ */
+ uid?: number;
+ /** Similar to `uid`, but sets the group ID of the child process. */
+ gid?: number;
+ /**
+ * An {@linkcode AbortSignal} that allows closing the process using the
+ * corresponding {@linkcode AbortController} by sending the process a
+ * SIGTERM signal.
+ *
+ * Not supported in {@linkcode Deno.Command.outputSync}.
+ */
+ signal?: AbortSignal;
+
+ /** How `stdin` of the spawned process should be handled.
+ *
+ * Defaults to `"inherit"` for `output` & `outputSync`,
+ * and `"inherit"` for `spawn`. */
+ stdin?: "piped" | "inherit" | "null";
+ /** How `stdout` of the spawned process should be handled.
+ *
+ * Defaults to `"piped"` for `output` & `outputSync`,
+ * and `"inherit"` for `spawn`. */
+ stdout?: "piped" | "inherit" | "null";
+ /** How `stderr` of the spawned process should be handled.
+ *
+ * Defaults to `"piped"` for `output` & `outputSync`,
+ * and `"inherit"` for `spawn`. */
+ stderr?: "piped" | "inherit" | "null";
+
+ /** Skips quoting and escaping of the arguments on windows. This option
+ * is ignored on non-windows platforms.
+ *
+ * @default {false} */
+ windowsRawArguments?: boolean;
+ }
+
+ /**
+ * @category Sub Process
+ */
+ export interface CommandStatus {
+ /** If the child process exits with a 0 status code, `success` will be set
+ * to `true`, otherwise `false`. */
+ success: boolean;
+ /** The exit code of the child process. */
+ code: number;
+ /** The signal associated with the child process. */
+ signal: Signal | null;
+ }
+
+ /**
+ * The interface returned from calling {@linkcode Deno.Command.output} or
+ * {@linkcode Deno.Command.outputSync} which represents the result of spawning the
+ * child process.
+ *
+ * @category Sub Process
+ */
+ export interface CommandOutput extends CommandStatus {
+ /** The buffered output from the child process' `stdout`. */
+ readonly stdout: Uint8Array;
+ /** The buffered output from the child process' `stderr`. */
+ readonly stderr: Uint8Array;
+ }
+
+ /** Option which can be specified when performing {@linkcode Deno.inspect}.
+ *
+ * @category Console and Debugging */
+ export interface InspectOptions {
+ /** Stylize output with ANSI colors.
+ *
+ * @default {false} */
+ colors?: boolean;
+ /** Try to fit more than one entry of a collection on the same line.
+ *
+ * @default {true} */
+ compact?: boolean;
+ /** Traversal depth for nested objects.
+ *
+ * @default {4} */
+ depth?: number;
+ /** The maximum length for an inspection to take up a single line.
+ *
+ * @default {80} */
+ breakLength?: number;
+ /** Whether or not to escape sequences.
+ *
+ * @default {true} */
+ escapeSequences?: boolean;
+ /** The maximum number of iterable entries to print.
+ *
+ * @default {100} */
+ iterableLimit?: number;
+ /** Show a Proxy's target and handler.
+ *
+ * @default {false} */
+ showProxy?: boolean;
+ /** Sort Object, Set and Map entries by key.
+ *
+ * @default {false} */
+ sorted?: boolean;
+ /** Add a trailing comma for multiline collections.
+ *
+ * @default {false} */
+ trailingComma?: boolean;
+ /** Evaluate the result of calling getters.
+ *
+ * @default {false} */
+ getters?: boolean;
+ /** Show an object's non-enumerable properties.
+ *
+ * @default {false} */
+ showHidden?: boolean;
+ /** The maximum length of a string before it is truncated with an
+ * ellipsis. */
+ strAbbreviateSize?: number;
+ }
+
+ /** Converts the input into a string that has the same format as printed by
+ * `console.log()`.
+ *
+ * ```ts
+ * const obj = {
+ * a: 10,
+ * b: "hello",
+ * };
+ * const objAsString = Deno.inspect(obj); // { a: 10, b: "hello" }
+ * console.log(obj); // prints same value as objAsString, e.g. { a: 10, b: "hello" }
+ * ```
+ *
+ * A custom inspect functions can be registered on objects, via the symbol
+ * `Symbol.for("Deno.customInspect")`, to control and customize the output
+ * of `inspect()` or when using `console` logging:
+ *
+ * ```ts
+ * class A {
+ * x = 10;
+ * y = "hello";
+ * [Symbol.for("Deno.customInspect")]() {
+ * 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"
+ * ```
+ *
+ * A depth can be specified by using the `depth` option:
+ *
+ * ```ts
+ * Deno.inspect({a: {b: {c: {d: 'hello'}}}}, {depth: 2}); // { a: { b: [Object] } }
+ * ```
+ *
+ * @category Console and Debugging
+ */
+ export function inspect(value: unknown, options?: InspectOptions): string;
+
+ /** The name of a privileged feature which needs permission.
+ *
+ * @category Permissions
+ */
+ export type PermissionName =
+ | "run"
+ | "read"
+ | "write"
+ | "net"
+ | "env"
+ | "sys"
+ | "ffi"
+ | "hrtime";
+
+ /** The current status of the permission:
+ *
+ * - `"granted"` - the permission has been granted.
+ * - `"denied"` - the permission has been explicitly denied.
+ * - `"prompt"` - the permission has not explicitly granted nor denied.
+ *
+ * @category Permissions
+ */
+ export type PermissionState =
+ | "granted"
+ | "denied"
+ | "prompt";
+
+ /** The permission descriptor for the `allow-run` and `deny-run` permissions, which controls
+ * access to what sub-processes can be executed by Deno. The option `command`
+ * allows scoping the permission to a specific executable.
+ *
+ * **Warning, in practice, `allow-run` is effectively the same as `allow-all`
+ * in the sense that malicious code could execute any arbitrary code on the
+ * host.**
+ *
+ * @category Permissions */
+ export interface RunPermissionDescriptor {
+ name: "run";
+ /** An `allow-run` or `deny-run` permission can be scoped to a specific executable,
+ * which would be relative to the start-up CWD of the Deno CLI. */
+ command?: string | URL;
+ }
+
+ /** The permission descriptor for the `allow-read` and `deny-read` permissions, which controls
+ * access to reading resources from the local host. The option `path` allows
+ * scoping the permission to a specific path (and if the path is a directory
+ * any sub paths).
+ *
+ * Permission granted under `allow-read` only allows runtime code to attempt
+ * to read, the underlying operating system may apply additional permissions.
+ *
+ * @category Permissions */
+ export interface ReadPermissionDescriptor {
+ name: "read";
+ /** An `allow-read` or `deny-read` permission can be scoped to a specific path (and if
+ * the path is a directory, any sub paths). */
+ path?: string | URL;
+ }
+
+ /** The permission descriptor for the `allow-write` and `deny-write` permissions, which
+ * controls access to writing to resources from the local host. The option
+ * `path` allow scoping the permission to a specific path (and if the path is
+ * a directory any sub paths).
+ *
+ * Permission granted under `allow-write` only allows runtime code to attempt
+ * to write, the underlying operating system may apply additional permissions.
+ *
+ * @category Permissions */
+ export interface WritePermissionDescriptor {
+ name: "write";
+ /** An `allow-write` or `deny-write` permission can be scoped to a specific path (and if
+ * the path is a directory, any sub paths). */
+ path?: string | URL;
+ }
+
+ /** The permission descriptor for the `allow-net` and `deny-net` permissions, which controls
+ * access to opening network ports and connecting to remote hosts via the
+ * network. The option `host` allows scoping the permission for outbound
+ * connection to a specific host and port.
+ *
+ * @category Permissions */
+ export interface NetPermissionDescriptor {
+ name: "net";
+ /** Optional host string of the form `"[:]"`. Examples:
+ *
+ * "github.com"
+ * "deno.land:8080"
+ */
+ host?: string;
+ }
+
+ /** The permission descriptor for the `allow-env` and `deny-env` permissions, which controls
+ * access to being able to read and write to the process environment variables
+ * as well as access other information about the environment. The option
+ * `variable` allows scoping the permission to a specific environment
+ * variable.
+ *
+ * @category Permissions */
+ export interface EnvPermissionDescriptor {
+ name: "env";
+ /** Optional environment variable name (e.g. `PATH`). */
+ variable?: string;
+ }
+
+ /** The permission descriptor for the `allow-sys` and `deny-sys` permissions, which controls
+ * access to sensitive host system information, which malicious code might
+ * attempt to exploit. The option `kind` allows scoping the permission to a
+ * specific piece of information.
+ *
+ * @category Permissions */
+ export interface SysPermissionDescriptor {
+ name: "sys";
+ /** The specific information to scope the permission to. */
+ kind?:
+ | "loadavg"
+ | "hostname"
+ | "systemMemoryInfo"
+ | "networkInterfaces"
+ | "osRelease"
+ | "osUptime"
+ | "uid"
+ | "gid"
+ | "cpus";
+ }
+
+ /** The permission descriptor for the `allow-ffi` and `deny-ffi` permissions, which controls
+ * access to loading _foreign_ code and interfacing with it via the
+ * [Foreign Function Interface API](https://deno.land/manual/runtime/ffi_api)
+ * available in Deno. The option `path` allows scoping the permission to a
+ * specific path on the host.
+ *
+ * @category Permissions */
+ export interface FfiPermissionDescriptor {
+ name: "ffi";
+ /** Optional path on the local host to scope the permission to. */
+ path?: string | URL;
+ }
+
+ /** The permission descriptor for the `allow-hrtime` and `deny-hrtime` permissions, which
+ * controls if the runtime code has access to high resolution time. High
+ * resolution time is considered sensitive information, because it can be used
+ * by malicious code to gain information about the host that it might not
+ * otherwise have access to.
+ *
+ * @category Permissions */
+ export interface HrtimePermissionDescriptor {
+ name: "hrtime";
+ }
+
+ /** Permission descriptors which define a permission and can be queried,
+ * requested, or revoked.
+ *
+ * View the specifics of the individual descriptors for more information about
+ * each permission kind.
+ *
+ * @category Permissions
+ */
+ export type PermissionDescriptor =
+ | RunPermissionDescriptor
+ | ReadPermissionDescriptor
+ | WritePermissionDescriptor
+ | NetPermissionDescriptor
+ | EnvPermissionDescriptor
+ | SysPermissionDescriptor
+ | FfiPermissionDescriptor
+ | HrtimePermissionDescriptor;
+
+ /** The interface which defines what event types are supported by
+ * {@linkcode PermissionStatus} instances.
+ *
+ * @category Permissions */
+ export interface PermissionStatusEventMap {
+ "change": Event;
+ }
+
+ /** An {@linkcode EventTarget} returned from the {@linkcode Deno.permissions}
+ * API which can provide updates to any state changes of the permission.
+ *
+ * @category Permissions */
+ export class PermissionStatus extends EventTarget {
+ // deno-lint-ignore no-explicit-any
+ onchange: ((this: PermissionStatus, ev: Event) => any) | null;
+ readonly state: PermissionState;
+ /**
+ * Describes if permission is only granted partially, eg. an access
+ * might be granted to "/foo" directory, but denied for "/foo/bar".
+ * In such case this field will be set to `true` when querying for
+ * read permissions of "/foo" directory.
+ */
+ readonly partial: boolean;
+ addEventListener(
+ type: K,
+ listener: (
+ this: PermissionStatus,
+ ev: PermissionStatusEventMap[K],
+ ) => any,
+ options?: boolean | AddEventListenerOptions,
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions,
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (
+ this: PermissionStatus,
+ ev: PermissionStatusEventMap[K],
+ ) => any,
+ options?: boolean | EventListenerOptions,
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions,
+ ): void;
+ }
+
+ /**
+ * Deno's permission management API.
+ *
+ * The class which provides the interface for the {@linkcode Deno.permissions}
+ * global instance and is based on the web platform
+ * [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API),
+ * though some proposed parts of the API which are useful in a server side
+ * runtime context were removed or abandoned in the web platform specification
+ * which is why it was chosen to locate it in the {@linkcode Deno} namespace
+ * instead.
+ *
+ * By default, if the `stdin`/`stdout` is TTY for the Deno CLI (meaning it can
+ * send and receive text), then the CLI will prompt the user to grant
+ * permission when an un-granted permission is requested. This behavior can
+ * be changed by using the `--no-prompt` command at startup. When prompting
+ * the CLI will request the narrowest permission possible, potentially making
+ * it annoying to the user. The permissions APIs allow the code author to
+ * request a wider set of permissions at one time in order to provide a better
+ * user experience.
+ *
+ * @category Permissions */
+ export class Permissions {
+ /** Resolves to the current status of a permission.
+ *
+ * Note, if the permission is already granted, `request()` will not prompt
+ * the user again, therefore `query()` is only necessary if you are going
+ * to react differently existing permissions without wanting to modify them
+ * or prompt the user to modify them.
+ *
+ * ```ts
+ * const status = await Deno.permissions.query({ name: "read", path: "/etc" });
+ * console.log(status.state);
+ * ```
+ */
+ query(desc: PermissionDescriptor): Promise;
+
+ /** Returns the current status of a permission.
+ *
+ * Note, if the permission is already granted, `request()` will not prompt
+ * the user again, therefore `querySync()` is only necessary if you are going
+ * to react differently existing permissions without wanting to modify them
+ * or prompt the user to modify them.
+ *
+ * ```ts
+ * const status = Deno.permissions.querySync({ name: "read", path: "/etc" });
+ * console.log(status.state);
+ * ```
+ */
+ querySync(desc: PermissionDescriptor): PermissionStatus;
+
+ /** Revokes a permission, and resolves to the state of the permission.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * const status = await Deno.permissions.revoke({ name: "run" });
+ * assert(status.state !== "granted")
+ * ```
+ */
+ revoke(desc: PermissionDescriptor): Promise;
+
+ /** Revokes a permission, and returns the state of the permission.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * const status = Deno.permissions.revokeSync({ name: "run" });
+ * assert(status.state !== "granted")
+ * ```
+ */
+ revokeSync(desc: PermissionDescriptor): PermissionStatus;
+
+ /** Requests the permission, and resolves to the state of the permission.
+ *
+ * If the permission is already granted, the user will not be prompted to
+ * grant the permission again.
+ *
+ * ```ts
+ * const status = await Deno.permissions.request({ name: "env" });
+ * if (status.state === "granted") {
+ * console.log("'env' permission is granted.");
+ * } else {
+ * console.log("'env' permission is denied.");
+ * }
+ * ```
+ */
+ request(desc: PermissionDescriptor): Promise;
+
+ /** Requests the permission, and returns the state of the permission.
+ *
+ * If the permission is already granted, the user will not be prompted to
+ * grant the permission again.
+ *
+ * ```ts
+ * const status = Deno.permissions.requestSync({ name: "env" });
+ * if (status.state === "granted") {
+ * console.log("'env' permission is granted.");
+ * } else {
+ * console.log("'env' permission is denied.");
+ * }
+ * ```
+ */
+ requestSync(desc: PermissionDescriptor): PermissionStatus;
+ }
+
+ /** Deno's permission management API.
+ *
+ * It is a singleton instance of the {@linkcode Permissions} object and is
+ * based on the web platform
+ * [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API),
+ * though some proposed parts of the API which are useful in a server side
+ * runtime context were removed or abandoned in the web platform specification
+ * which is why it was chosen to locate it in the {@linkcode Deno} namespace
+ * instead.
+ *
+ * By default, if the `stdin`/`stdout` is TTY for the Deno CLI (meaning it can
+ * send and receive text), then the CLI will prompt the user to grant
+ * permission when an un-granted permission is requested. This behavior can
+ * be changed by using the `--no-prompt` command at startup. When prompting
+ * the CLI will request the narrowest permission possible, potentially making
+ * it annoying to the user. The permissions APIs allow the code author to
+ * request a wider set of permissions at one time in order to provide a better
+ * user experience.
+ *
+ * Requesting already granted permissions will not prompt the user and will
+ * return that the permission was granted.
+ *
+ * ### Querying
+ *
+ * ```ts
+ * const status = await Deno.permissions.query({ name: "read", path: "/etc" });
+ * console.log(status.state);
+ * ```
+ *
+ * ```ts
+ * const status = Deno.permissions.querySync({ name: "read", path: "/etc" });
+ * console.log(status.state);
+ * ```
+ *
+ * ### Revoking
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * const status = await Deno.permissions.revoke({ name: "run" });
+ * assert(status.state !== "granted")
+ * ```
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * const status = Deno.permissions.revokeSync({ name: "run" });
+ * assert(status.state !== "granted")
+ * ```
+ *
+ * ### Requesting
+ *
+ * ```ts
+ * const status = await Deno.permissions.request({ name: "env" });
+ * if (status.state === "granted") {
+ * console.log("'env' permission is granted.");
+ * } else {
+ * console.log("'env' permission is denied.");
+ * }
+ * ```
+ *
+ * ```ts
+ * const status = Deno.permissions.requestSync({ name: "env" });
+ * if (status.state === "granted") {
+ * console.log("'env' permission is granted.");
+ * } else {
+ * console.log("'env' permission is denied.");
+ * }
+ * ```
+ *
+ * @category Permissions
+ */
+ export const permissions: Permissions;
+
+ /** Information related to the build of the current Deno runtime.
+ *
+ * Users are discouraged from code branching based on this information, as
+ * assumptions about what is available in what build environment might change
+ * over time. Developers should specifically sniff out the features they
+ * intend to use.
+ *
+ * The intended use for the information is for logging and debugging purposes.
+ *
+ * @category Runtime Environment
+ */
+ export const build: {
+ /** The [LLVM](https://llvm.org/) target triple, which is the combination
+ * of `${arch}-${vendor}-${os}` and represent the specific build target that
+ * the current runtime was built for. */
+ target: string;
+ /** Instruction set architecture that the Deno CLI was built for. */
+ arch: "x86_64" | "aarch64";
+ /** The operating system that the Deno CLI was built for. `"darwin"` is
+ * also known as OSX or MacOS. */
+ os:
+ | "darwin"
+ | "linux"
+ | "android"
+ | "windows"
+ | "freebsd"
+ | "netbsd"
+ | "aix"
+ | "solaris"
+ | "illumos";
+ /** The computer vendor that the Deno CLI was built for. */
+ vendor: string;
+ /** Optional environment flags that were set for this build of Deno CLI. */
+ env?: string;
+ };
+
+ /** Version information related to the current Deno CLI runtime environment.
+ *
+ * Users are discouraged from code branching based on this information, as
+ * assumptions about what is available in what build environment might change
+ * over time. Developers should specifically sniff out the features they
+ * intend to use.
+ *
+ * The intended use for the information is for logging and debugging purposes.
+ *
+ * @category Runtime Environment
+ */
+ export const version: {
+ /** Deno CLI's version. For example: `"1.26.0"`. */
+ deno: string;
+ /** The V8 version used by Deno. For example: `"10.7.100.0"`.
+ *
+ * V8 is the underlying JavaScript runtime platform that Deno is built on
+ * top of. */
+ v8: string;
+ /** The TypeScript version used by Deno. For example: `"4.8.3"`.
+ *
+ * A version of the TypeScript type checker and language server is built-in
+ * to the Deno CLI. */
+ typescript: string;
+ };
+
+ /** Returns the script arguments to the program.
+ *
+ * Give the following command line invocation of Deno:
+ *
+ * ```sh
+ * deno run --allow-read https://examples.deno.land/command-line-arguments.ts Sushi
+ * ```
+ *
+ * Then `Deno.args` will contain:
+ *
+ * ```ts
+ * [ "Sushi" ]
+ * ```
+ *
+ * If you are looking for a structured way to parse arguments, there is the
+ * [`std/flags`](https://deno.land/std/flags) module as part of the Deno
+ * standard library.
+ *
+ * @category Runtime Environment
+ */
+ 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.
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category Console and Debugging
+ */
+ export const customInspect: unique symbol;
+
+ /** The URL of the entrypoint module entered from the command-line. It
+ * requires read permission to the CWD.
+ *
+ * Also see {@linkcode ImportMeta} for other related information.
+ *
+ * @tags allow-read
+ * @category Runtime Environment
+ */
+ export const mainModule: string;
+
+ /** Options that can be used with {@linkcode symlink} and
+ * {@linkcode symlinkSync}.
+ *
+ * @category File System */
+ export interface SymlinkOptions {
+ /** If the symbolic link should be either a file or directory. This option
+ * only applies to Windows and is ignored on other operating systems. */
+ type: "file" | "dir";
+ }
+
+ /**
+ * 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 full `allow-read` and `allow-write` permissions.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function symlink(
+ oldpath: string | URL,
+ newpath: string | URL,
+ options?: SymlinkOptions,
+ ): Promise;
+
+ /**
+ * 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 full `allow-read` and `allow-write` permissions.
+ *
+ * @tags allow-read, allow-write
+ * @category File System
+ */
+ export function symlinkSync(
+ oldpath: string | URL,
+ newpath: string | URL,
+ options?: SymlinkOptions,
+ ): void;
+
+ /**
+ * Truncates or extends the specified file stream, to reach the specified
+ * `len`.
+ *
+ * If `len` is not specified then the entire file contents are truncated as if
+ * `len` was set to `0`.
+ *
+ * If the file previously was larger than this new length, the extra data is
+ * lost.
+ *
+ * If the file previously was shorter, it is extended, and the extended part
+ * reads as null bytes ('\0').
+ *
+ * ### Truncate the entire file
+ *
+ * ```ts
+ * const file = await Deno.open(
+ * "my_file.txt",
+ * { read: true, write: true, create: true }
+ * );
+ * await Deno.ftruncate(file.rid);
+ * ```
+ *
+ * ### Truncate part of the file
+ *
+ * ```ts
+ * const file = await Deno.open(
+ * "my_file.txt",
+ * { read: true, write: true, create: true }
+ * );
+ * await file.write(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
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export function ftruncate(rid: number, len?: number): Promise;
+
+ /**
+ * 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 as if
+ * `len` was set to `0`.
+ *
+ * If the file previously was larger than this new length, the extra data is
+ * lost.
+ *
+ * If the file previously was shorter, it is extended, and the extended part
+ * reads as null bytes ('\0').
+ *
+ * ### Truncate the entire file
+ *
+ * ```ts
+ * const file = Deno.openSync(
+ * "my_file.txt",
+ * { read: true, write: true, truncate: true, create: true }
+ * );
+ * Deno.ftruncateSync(file.rid);
+ * ```
+ *
+ * ### Truncate part of the file
+ *
+ * ```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, 7);
+ * Deno.seekSync(file.rid, 0, Deno.SeekMode.Start);
+ * const data = new Uint8Array(32);
+ * Deno.readSync(file.rid, data);
+ * console.log(new TextDecoder().decode(data)); // Hello W
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export function ftruncateSync(rid: number, len?: number): void;
+
+ /**
+ * Synchronously changes the access (`atime`) and modification (`mtime`) times
+ * of a file stream resource referenced by `rid`. Given times are either in
+ * seconds (UNIX epoch time) or as `Date` objects.
+ *
+ * ```ts
+ * const file = Deno.openSync("file.txt", { create: true, write: true });
+ * Deno.futimeSync(file.rid, 1556495550, new Date());
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export function futimeSync(
+ rid: number,
+ atime: number | Date,
+ mtime: number | Date,
+ ): void;
+
+ /**
+ * Changes the access (`atime`) and modification (`mtime`) times of a file
+ * stream resource referenced by `rid`. Given times are either in seconds
+ * (UNIX epoch time) or as `Date` objects.
+ *
+ * ```ts
+ * const file = await Deno.open("file.txt", { create: true, write: true });
+ * await Deno.futime(file.rid, 1556495550, new Date());
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export function futime(
+ rid: number,
+ atime: number | Date,
+ mtime: number | Date,
+ ): Promise;
+
+ /**
+ * Returns a `Deno.FileInfo` for the given file stream.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * const file = await Deno.open("file.txt", { read: true });
+ * const fileInfo = await Deno.fstat(file.rid);
+ * assert(fileInfo.isFile);
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export function fstat(rid: number): Promise;
+
+ /**
+ * Synchronously returns a {@linkcode Deno.FileInfo} for the given file
+ * stream.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std/assert/mod.ts";
+ *
+ * const file = Deno.openSync("file.txt", { read: true });
+ * const fileInfo = Deno.fstatSync(file.rid);
+ * assert(fileInfo.isFile);
+ * ```
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ *
+ * @category File System
+ */
+ export function fstatSync(rid: number): FileInfo;
+
+ /**
+ * 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function utimeSync(
+ path: string | URL,
+ atime: number | Date,
+ mtime: number | Date,
+ ): void;
+
+ /**
+ * 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.
+ *
+ * @tags allow-write
+ * @category File System
+ */
+ export function utime(
+ path: string | URL,
+ atime: number | Date,
+ mtime: number | Date,
+ ): Promise;
+
+ /** The event yielded from an {@linkcode HttpConn} which represents an HTTP
+ * request from a remote client.
+ *
+ * @category HTTP Server
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ export interface RequestEvent {
+ /** The request from the client in the form of the web platform
+ * {@linkcode Request}. */
+ readonly request: Request;
+ /** The method to be used to respond to the event. The response needs to
+ * either be an instance of {@linkcode Response} or a promise that resolves
+ * with an instance of `Response`.
+ *
+ * When the response is successfully processed then the promise returned
+ * will be resolved. If there are any issues with sending the response,
+ * the promise will be rejected. */
+ respondWith(r: Response | PromiseLike): Promise;
+ }
+
+ /** The async iterable that is returned from {@linkcode Deno.serveHttp} which
+ * yields up {@linkcode RequestEvent} events, representing individual
+ * requests on the HTTP server connection.
+ *
+ * @category HTTP Server
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ export interface HttpConn extends AsyncIterable, Disposable {
+ /** The resource ID associated with this connection. Generally users do not
+ * need to be aware of this identifier. */
+ readonly rid: number;
+
+ /** An alternative to the async iterable interface which provides promises
+ * which resolve with either a {@linkcode RequestEvent} when there is
+ * another request or `null` when the client has closed the connection. */
+ nextRequest(): Promise;
+ /** Initiate a server side closure of the connection, indicating to the
+ * client that you refuse to accept any more requests on this connection.
+ *
+ * Typically the client closes the connection, which will result in the
+ * async iterable terminating or the `nextRequest()` method returning
+ * `null`. */
+ close(): void;
+ }
+
+ /**
+ * Provides an interface to handle HTTP request and responses over TCP or TLS
+ * connections. The method returns an {@linkcode HttpConn} which yields up
+ * {@linkcode RequestEvent} events, which utilize the web platform standard
+ * {@linkcode Request} and {@linkcode Response} objects to handle the request.
+ *
+ * ```ts
+ * const conn = Deno.listen({ port: 80 });
+ * const httpConn = Deno.serveHttp(await conn.accept());
+ * const e = await httpConn.nextRequest();
+ * if (e) {
+ * e.respondWith(new Response("Hello World"));
+ * }
+ * ```
+ *
+ * Alternatively, you can also use the async iterator approach:
+ *
+ * ```ts
+ * async function handleHttp(conn: Deno.Conn) {
+ * for await (const e of Deno.serveHttp(conn)) {
+ * e.respondWith(new Response("Hello World"));
+ * }
+ * }
+ *
+ * for await (const conn of Deno.listen({ port: 80 })) {
+ * handleHttp(conn);
+ * }
+ * ```
+ *
+ * If `httpConn.nextRequest()` encounters an error or returns `null` then the
+ * underlying {@linkcode HttpConn} resource is closed automatically.
+ *
+ * Also see the experimental Flash HTTP server {@linkcode Deno.serve} which
+ * provides a ground up rewrite of handling of HTTP requests and responses
+ * within the Deno CLI.
+ *
+ * Note that this function *consumes* the given connection passed to it, thus
+ * the original connection will be unusable after calling this. Additionally,
+ * you need to ensure that the connection is not being used elsewhere when
+ * calling this function in order for the connection to be consumed properly.
+ *
+ * For instance, if there is a `Promise` that is waiting for read operation on
+ * the connection to complete, it is considered that the connection is being
+ * used elsewhere. In such a case, this function will fail.
+ *
+ * @category HTTP Server
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ export function serveHttp(conn: Conn): HttpConn;
+
+ /** The object that is returned from a {@linkcode Deno.upgradeWebSocket}
+ * request.
+ *
+ * @category Web Sockets */
+ export interface WebSocketUpgrade {
+ /** The response object that represents the HTTP response to the client,
+ * which should be used to the {@linkcode RequestEvent} `.respondWith()` for
+ * the upgrade to be successful. */
+ response: Response;
+ /** The {@linkcode WebSocket} interface to communicate to the client via a
+ * web socket. */
+ socket: WebSocket;
+ }
+
+ /** Options which can be set when performing a
+ * {@linkcode Deno.upgradeWebSocket} upgrade of a {@linkcode Request}
+ *
+ * @category Web Sockets */
+ export interface UpgradeWebSocketOptions {
+ /** Sets the `.protocol` property on the client side web socket to the
+ * value provided here, which should be one of the strings specified in the
+ * `protocols` parameter when requesting the web socket. This is intended
+ * for clients and servers to specify sub-protocols to use to communicate to
+ * each other. */
+ protocol?: string;
+ /** If the client does not respond to this frame with a
+ * `pong` within the timeout specified, the connection is deemed
+ * unhealthy and is closed. The `close` and `error` event will be emitted.
+ *
+ * The unit is seconds, with a default of 120.
+ * Set to `0` to disable timeouts. */
+ idleTimeout?: number;
+ }
+
+ /**
+ * Upgrade an incoming HTTP request to a WebSocket.
+ *
+ * Given a {@linkcode Request}, returns a pair of {@linkcode WebSocket} and
+ * {@linkcode Response} instances. The original request must be responded to
+ * with the returned response for the websocket upgrade to be successful.
+ *
+ * ```ts
+ * const conn = Deno.listen({ port: 80 });
+ * const httpConn = Deno.serveHttp(await conn.accept());
+ * const e = await httpConn.nextRequest();
+ * if (e) {
+ * const { socket, response } = Deno.upgradeWebSocket(e.request);
+ * socket.onopen = () => {
+ * socket.send("Hello World!");
+ * };
+ * socket.onmessage = (e) => {
+ * console.log(e.data);
+ * socket.close();
+ * };
+ * socket.onclose = () => console.log("WebSocket has been closed.");
+ * socket.onerror = (e) => console.error("WebSocket error:", e);
+ * e.respondWith(response);
+ * }
+ * ```
+ *
+ * If the request body is disturbed (read from) before the upgrade is
+ * completed, upgrading fails.
+ *
+ * This operation does not yet consume the request or open the websocket. This
+ * only happens once the returned response has been passed to `respondWith()`.
+ *
+ * @category Web Sockets
+ */
+ export function upgradeWebSocket(
+ request: Request,
+ options?: UpgradeWebSocketOptions,
+ ): WebSocketUpgrade;
+
+ /** Send a signal to process under given `pid`. The value and meaning of the
+ * `signal` to the process is operating system and process dependant.
+ * {@linkcode Signal} provides the most common signals. Default signal
+ * is `"SIGTERM"`.
+ *
+ * The term `kill` is adopted from the UNIX-like command line command `kill`
+ * which also signals processes.
+ *
+ * If `pid` is negative, the signal will be sent to the process group
+ * identified by `pid`. An error will be thrown if a negative `pid` is used on
+ * Windows.
+ *
+ * ```ts
+ * const p = Deno.run({
+ * cmd: ["sleep", "10000"]
+ * });
+ *
+ * Deno.kill(p.pid, "SIGINT");
+ * ```
+ *
+ * Requires `allow-run` permission.
+ *
+ * @tags allow-run
+ * @category Sub Process
+ */
+ export function kill(pid: number, signo?: Signal): void;
+
+ /** The type of the resource record to resolve via DNS using
+ * {@linkcode Deno.resolveDns}.
+ *
+ * Only the listed types are supported currently.
+ *
+ * @category Network
+ */
+ export type RecordType =
+ | "A"
+ | "AAAA"
+ | "ANAME"
+ | "CAA"
+ | "CNAME"
+ | "MX"
+ | "NAPTR"
+ | "NS"
+ | "PTR"
+ | "SOA"
+ | "SRV"
+ | "TXT";
+
+ /**
+ * Options which can be set when using {@linkcode Deno.resolveDns}.
+ *
+ * @category Network */
+ export interface ResolveDnsOptions {
+ /** The name server to be used for lookups.
+ *
+ * If not specified, defaults to the system configuration. For example
+ * `/etc/resolv.conf` on Unix-like systems. */
+ nameServer?: {
+ /** The IP address of the name server. */
+ ipAddr: string;
+ /** The port number the query will be sent to.
+ *
+ * @default {53} */
+ port?: number;
+ };
+ /**
+ * An abort signal to allow cancellation of the DNS resolution operation.
+ * If the signal becomes aborted the resolveDns operation will be stopped
+ * and the promise returned will be rejected with an AbortError.
+ */
+ signal?: AbortSignal;
+ }
+
+ /** If {@linkcode Deno.resolveDns} is called with `"CAA"` record type
+ * specified, it will resolve with an array of objects with this interface.
+ *
+ * @category Network
+ */
+ export interface CAARecord {
+ /** If `true`, indicates that the corresponding property tag **must** be
+ * understood if the semantics of the CAA record are to be correctly
+ * interpreted by an issuer.
+ *
+ * Issuers **must not** issue certificates for a domain if the relevant CAA
+ * Resource Record set contains unknown property tags that have `critical`
+ * set. */
+ critical: boolean;
+ /** An string that represents the identifier of the property represented by
+ * the record. */
+ tag: string;
+ /** The value associated with the tag. */
+ value: string;
+ }
+
+ /** If {@linkcode Deno.resolveDns} is called with `"MX"` record type
+ * specified, it will return an array of objects with this interface.
+ *
+ * @category Network */
+ export interface MXRecord {
+ /** A priority value, which is a relative value compared to the other
+ * preferences of MX records for the domain. */
+ preference: number;
+ /** The server that mail should be delivered to. */
+ exchange: string;
+ }
+
+ /** If {@linkcode Deno.resolveDns} is called with `"NAPTR"` record type
+ * specified, it will return an array of objects with this interface.
+ *
+ * @category Network */
+ export interface NAPTRRecord {
+ order: number;
+ preference: number;
+ flags: string;
+ services: string;
+ regexp: string;
+ replacement: string;
+ }
+
+ /** If {@linkcode Deno.resolveDns} is called with `"SOA"` record type
+ * specified, it will return an array of objects with this interface.
+ *
+ * @category Network */
+ export interface SOARecord {
+ mname: string;
+ rname: string;
+ serial: number;
+ refresh: number;
+ retry: number;
+ expire: number;
+ minimum: number;
+ }
+
+ /** If {@linkcode Deno.resolveDns} is called with `"SRV"` record type
+ * specified, it will return an array of objects with this interface.
+ *
+ * @category Network
+ */
+ export interface SRVRecord {
+ priority: number;
+ weight: number;
+ port: number;
+ target: string;
+ }
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "A" | "AAAA" | "ANAME" | "CNAME" | "NS" | "PTR",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "CAA",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "MX",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "NAPTR",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "SOA",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "SRV",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: "TXT",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /**
+ * Performs DNS resolution against the given query, returning resolved
+ * records.
+ *
+ * Fails in the cases such as:
+ *
+ * - the query is in invalid format.
+ * - the options have an invalid parameter. For example `nameServer.port` is
+ * beyond the range of 16-bit unsigned integer.
+ * - the request timed out.
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 53 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ *
+ * @tags allow-net
+ * @category Network
+ */
+ export function resolveDns(
+ query: string,
+ recordType: RecordType,
+ options?: ResolveDnsOptions,
+ ): Promise<
+ | string[]
+ | CAARecord[]
+ | MXRecord[]
+ | NAPTRRecord[]
+ | SOARecord[]
+ | SRVRecord[]
+ | string[][]
+ >;
+
+ /**
+ * Make the timer of the given `id` block the event loop from finishing.
+ *
+ * @category Timers
+ */
+ export function refTimer(id: number): void;
+
+ /**
+ * Make the timer of the given `id` not block the event loop from finishing.
+ *
+ * @category Timers
+ */
+ export function unrefTimer(id: number): void;
+
+ /**
+ * Returns the user id of the process on POSIX platforms. Returns null on Windows.
+ *
+ * ```ts
+ * console.log(Deno.uid());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ *
+ * @tags allow-sys
+ * @category Runtime Environment
+ */
+ export function uid(): number | null;
+
+ /**
+ * Returns the group id of the process on POSIX platforms. Returns null on windows.
+ *
+ * ```ts
+ * console.log(Deno.gid());
+ * ```
+ *
+ * Requires `allow-sys` permission.
+ *
+ * @tags allow-sys
+ * @category Runtime Environment
+ */
+ export function gid(): number | null;
+
+ /** Information for a HTTP request.
+ *
+ * @category HTTP Server
+ */
+ export interface ServeHandlerInfo {
+ /** The remote address of the connection. */
+ remoteAddr: Deno.NetAddr;
+ }
+
+ /** A handler for HTTP requests. Consumes a request and returns a response.
+ *
+ * If a handler throws, the server calling the handler will assume the impact
+ * of the error is isolated to the individual request. It will catch the error
+ * and if necessary will close the underlying connection.
+ *
+ * @category HTTP Server
+ */
+ export type ServeHandler = (
+ request: Request,
+ info: ServeHandlerInfo,
+ ) => Response | Promise;
+
+ /** Options which can be set when calling {@linkcode Deno.serve}.
+ *
+ * @category HTTP Server
+ */
+ export interface ServeOptions {
+ /** The port to listen on.
+ *
+ * @default {8000} */
+ port?: number;
+
+ /** A literal IP address or host name that can be resolved to an IP address.
+ *
+ * __Note about `0.0.0.0`__ While listening `0.0.0.0` works on all platforms,
+ * the browsers on Windows don't work with the address `0.0.0.0`.
+ * You should show the message like `server running on localhost:8080` instead of
+ * `server running on 0.0.0.0:8080` if your program supports Windows.
+ *
+ * @default {"0.0.0.0"} */
+ hostname?: string;
+
+ /** An {@linkcode AbortSignal} to close the server and all connections. */
+ signal?: AbortSignal;
+
+ /** Sets `SO_REUSEPORT` on POSIX systems. */
+ reusePort?: boolean;
+
+ /** The handler to invoke when route handlers throw an error. */
+ onError?: (error: unknown) => Response | Promise;
+
+ /** The callback which is called when the server starts listening. */
+ onListen?: (params: { hostname: string; port: number }) => void;
+ }
+
+ /** Additional options which are used when opening a TLS (HTTPS) server.
+ *
+ * @category HTTP Server
+ */
+ export interface ServeTlsOptions extends ServeOptions {
+ /** Server private key in PEM format */
+ cert: string;
+
+ /** Cert chain in PEM format */
+ key: string;
+ }
+
+ /**
+ * @category HTTP Server
+ */
+ export interface ServeInit {
+ /** The handler to invoke to process each incoming request. */
+ handler: ServeHandler;
+ }
+
+ /** @category HTTP Server */
+ export interface ServeUnixOptions {
+ /** The unix domain socket path to listen on. */
+ path: string;
+
+ /** An {@linkcode AbortSignal} to close the server and all connections. */
+ signal?: AbortSignal;
+
+ /** The handler to invoke when route handlers throw an error. */
+ onError?: (error: unknown) => Response | Promise;
+
+ /** The callback which is called when the server starts listening. */
+ onListen?: (params: { path: string }) => void;
+ }
+
+ /** Information for a unix domain socket HTTP request.
+ *
+ * @category HTTP Server
+ */
+ export interface ServeUnixHandlerInfo {
+ /** The remote address of the connection. */
+ remoteAddr: Deno.UnixAddr;
+ }
+
+ /** A handler for unix domain socket HTTP requests. Consumes a request and returns a response.
+ *
+ * If a handler throws, the server calling the handler will assume the impact
+ * of the error is isolated to the individual request. It will catch the error
+ * and if necessary will close the underlying connection.
+ *
+ * @category HTTP Server
+ */
+ export type ServeUnixHandler = (
+ request: Request,
+ info: ServeUnixHandlerInfo,
+ ) => Response | Promise;
+
+ /**
+ * @category HTTP Server
+ */
+ export interface ServeUnixInit {
+ /** The handler to invoke to process each incoming request. */
+ handler: ServeUnixHandler;
+ }
+
+ /** An instance of the server created using `Deno.serve()` API.
+ *
+ * @category HTTP Server
+ */
+ export interface HttpServer extends AsyncDisposable {
+ /** A promise that resolves once server finishes - eg. when aborted using
+ * the signal passed to {@linkcode ServeOptions.signal}.
+ */
+ finished: Promise;
+
+ /**
+ * Make the server block the event loop from finishing.
+ *
+ * Note: the server blocks the event loop from finishing by default.
+ * This method is only meaningful after `.unref()` is called.
+ */
+ ref(): void;
+
+ /** Make the server not block the event loop from finishing. */
+ unref(): void;
+
+ /** Gracefully close the server. No more new connections will be accepted,
+ * while pending requests will be allowed to finish.
+ */
+ shutdown(): Promise;
+ }
+
+ /**
+ * @category HTTP Server
+ *
+ * @deprecated This will be removed in Deno 2.0. See the
+ * {@link https://docs.deno.com/runtime/manual/advanced/migrate_deprecations | Deno 1.x to 2.x Migration Guide}
+ * for migration instructions.
+ */
+ export type Server = HttpServer;
+
+ /** Serves HTTP requests with the given handler.
+ *
+ * The below example serves with the port `8000` on hostname `"127.0.0.1"`.
+ *
+ * ```ts
+ * Deno.serve((_req) => new Response("Hello, world"));
+ * ```
+ *
+ * @category HTTP Server
+ */
+ export function serve(handler: ServeHandler): HttpServer;
+ /** Serves HTTP requests with the given option bag and handler.
+ *
+ * You can specify the socket path with `path` option.
+ *
+ * ```ts
+ * Deno.serve(
+ * { path: "path/to/socket" },
+ * (_req) => new Response("Hello, world")
+ * );
+ * ```
+ *
+ * You can stop the server with an {@linkcode AbortSignal}. The abort signal
+ * needs to be passed as the `signal` option in the options bag. The server
+ * aborts when the abort signal is aborted. To wait for the server to close,
+ * await the promise returned from the `Deno.serve` API.
+ *
+ * ```ts
+ * const ac = new AbortController();
+ *
+ * const server = Deno.serve(
+ * { signal: ac.signal, path: "path/to/socket" },
+ * (_req) => new Response("Hello, world")
+ * );
+ * server.finished.then(() => console.log("Server closed"));
+ *
+ * console.log("Closing server...");
+ * ac.abort();
+ * ```
+ *
+ * By default `Deno.serve` prints the message
+ * `Listening on path/to/socket` on listening. If you like to
+ * change this behavior, you can specify a custom `onListen` callback.
+ *
+ * ```ts
+ * Deno.serve({
+ * onListen({ path }) {
+ * console.log(`Server started at ${path}`);
+ * // ... more info specific to your server ..
+ * },
+ * path: "path/to/socket",
+ * }, (_req) => new Response("Hello, world"));
+ * ```
+ *
+ * @category HTTP Server
+ */
+ export function serve(
+ options: ServeUnixOptions,
+ handler: ServeUnixHandler,
+ ): HttpServer;
+ /** Serves HTTP requests with the given option bag and handler.
+ *
+ * You can specify an object with a port and hostname option, which is the
+ * address to listen on. The default is port `8000` on hostname `"127.0.0.1"`.
+ *
+ * You can change the address to listen on using the `hostname` and `port`
+ * options. The below example serves on port `3000` and hostname `"0.0.0.0"`.
+ *
+ * ```ts
+ * Deno.serve(
+ * { port: 3000, hostname: "0.0.0.0" },
+ * (_req) => new Response("Hello, world")
+ * );
+ * ```
+ *
+ * You can stop the server with an {@linkcode AbortSignal}. The abort signal
+ * needs to be passed as the `signal` option in the options bag. The server
+ * aborts when the abort signal is aborted. To wait for the server to close,
+ * await the promise returned from the `Deno.serve` API.
+ *
+ * ```ts
+ * const ac = new AbortController();
+ *
+ * const server = Deno.serve(
+ * { signal: ac.signal },
+ * (_req) => new Response("Hello, world")
+ * );
+ * server.finished.then(() => console.log("Server closed"));
+ *
+ * console.log("Closing server...");
+ * ac.abort();
+ * ```
+ *
+ * By default `Deno.serve` prints the message
+ * `Listening on http://:/` on listening. If you like to
+ * change this behavior, you can specify a custom `onListen` callback.
+ *
+ * ```ts
+ * Deno.serve({
+ * onListen({ port, hostname }) {
+ * console.log(`Server started at http://${hostname}:${port}`);
+ * // ... more info specific to your server ..
+ * },
+ * }, (_req) => new Response("Hello, world"));
+ * ```
+ *
+ * To enable TLS you must specify the `key` and `cert` options.
+ *
+ * ```ts
+ * const cert = "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----\n";
+ * const key = "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n";
+ * Deno.serve({ cert, key }, (_req) => new Response("Hello, world"));
+ * ```
+ *
+ * @category HTTP Server
+ */
+ export function serve(
+ options: ServeOptions | ServeTlsOptions,
+ handler: ServeHandler,
+ ): HttpServer;
+ /** Serves HTTP requests with the given option bag.
+ *
+ * You can specify an object with the path option, which is the
+ * unix domain socket to listen on.
+ *
+ * ```ts
+ * const ac = new AbortController();
+ *
+ * const server = Deno.serve({
+ * path: "path/to/socket",
+ * handler: (_req) => new Response("Hello, world"),
+ * signal: ac.signal,
+ * onListen({ path }) {
+ * console.log(`Server started at ${path}`);
+ * },
+ * });
+ * server.finished.then(() => console.log("Server closed"));
+ *
+ * console.log("Closing server...");
+ * ac.abort();
+ * ```
+ *
+ * @category HTTP Server
+ */
+ export function serve(
+ options: ServeUnixInit & ServeUnixOptions,
+ ): HttpServer;
+ /** Serves HTTP requests with the given option bag.
+ *
+ * You can specify an object with a port and hostname option, which is the
+ * address to listen on. The default is port `8000` on hostname `"127.0.0.1"`.
+ *
+ * ```ts
+ * const ac = new AbortController();
+ *
+ * const server = Deno.serve({
+ * port: 3000,
+ * hostname: "0.0.0.0",
+ * handler: (_req) => new Response("Hello, world"),
+ * signal: ac.signal,
+ * onListen({ port, hostname }) {
+ * console.log(`Server started at http://${hostname}:${port}`);
+ * },
+ * });
+ * server.finished.then(() => console.log("Server closed"));
+ *
+ * console.log("Closing server...");
+ * ac.abort();
+ * ```
+ *
+ * @category HTTP Server
+ */
+ export function serve(
+ options: ServeInit & (ServeOptions | ServeTlsOptions),
+ ): HttpServer;
+}
+
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore-file no-explicit-any
+
+///
+///
+
+/** @category Console and Debugging */
+declare interface Console {
+ assert(condition?: boolean, ...data: any[]): void;
+ clear(): void;
+ count(label?: string): void;
+ countReset(label?: string): void;
+ debug(...data: any[]): void;
+ dir(item?: any, options?: any): void;
+ dirxml(...data: any[]): void;
+ error(...data: any[]): void;
+ group(...data: any[]): void;
+ groupCollapsed(...data: any[]): void;
+ groupEnd(): void;
+ info(...data: any[]): void;
+ log(...data: any[]): void;
+ table(tabularData?: any, properties?: string[]): void;
+ time(label?: string): void;
+ timeEnd(label?: string): void;
+ timeLog(label?: string, ...data: any[]): void;
+ trace(...data: any[]): void;
+ warn(...data: any[]): void;
+
+ /** This method is a noop, unless used in inspector */
+ timeStamp(label?: string): void;
+
+ /** This method is a noop, unless used in inspector */
+ profile(label?: string): void;
+
+ /** This method is a noop, unless used in inspector */
+ profileEnd(label?: string): void;
+}
+
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore-file no-explicit-any no-var
+
+///
+///
+
+/** @category Web APIs */
+declare 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 search parameters that match a name, and optional value,
+ * from the list of all search parameters.
+ *
+ * ```ts
+ * let searchParams = new URLSearchParams([['name', 'value']]);
+ * searchParams.delete('name');
+ * searchParams.delete('name', 'value');
+ * ```
+ */
+ delete(name: string, value?: 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 value indicating if a given parameter,
+ * or parameter and value pair, exists.
+ *
+ * ```ts
+ * searchParams.has('name');
+ * searchParams.has('name', 'value');
+ * ```
+ */
+ has(name: string, value?: 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;
+
+ /** 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;
+
+ /** 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;
+
+ /** Contains the number of search parameters
+ *
+ * ```ts
+ * searchParams.size
+ * ```
+ */
+ size: number;
+}
+
+/** @category Web APIs */
+declare var URLSearchParams: {
+ readonly prototype: URLSearchParams;
+ new (
+ init?: Iterable | Record | string,
+ ): URLSearchParams;
+};
+
+/** The URL interface represents an object providing static methods used for
+ * creating object URLs.
+ *
+ * @category Web APIs
+ */
+declare 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;
+}
+
+/** The URL interface represents an object providing static methods used for
+ * creating object URLs.
+ *
+ * @category Web APIs
+ */
+declare var URL: {
+ readonly prototype: URL;
+ new (url: string | URL, base?: string | URL): URL;
+ canParse(url: string | URL, base?: string | URL): boolean;
+ createObjectURL(blob: Blob): string;
+ revokeObjectURL(url: string): void;
+};
+
+/** @category Web APIs */
+declare interface URLPatternInit {
+ protocol?: string;
+ username?: string;
+ password?: string;
+ hostname?: string;
+ port?: string;
+ pathname?: string;
+ search?: string;
+ hash?: string;
+ baseURL?: string;
+}
+
+/** @category Web APIs */
+declare type URLPatternInput = string | URLPatternInit;
+
+/** @category Web APIs */
+declare interface URLPatternComponentResult {
+ input: string;
+ groups: Record;
+}
+
+/** `URLPatternResult` is the object returned from `URLPattern.exec`.
+ *
+ * @category Web APIs
+ */
+declare interface URLPatternResult {
+ /** The inputs provided when matching. */
+ inputs: [URLPatternInit] | [URLPatternInit, string];
+
+ /** The matched result for the `protocol` matcher. */
+ protocol: URLPatternComponentResult;
+ /** The matched result for the `username` matcher. */
+ username: URLPatternComponentResult;
+ /** The matched result for the `password` matcher. */
+ password: URLPatternComponentResult;
+ /** The matched result for the `hostname` matcher. */
+ hostname: URLPatternComponentResult;
+ /** The matched result for the `port` matcher. */
+ port: URLPatternComponentResult;
+ /** The matched result for the `pathname` matcher. */
+ pathname: URLPatternComponentResult;
+ /** The matched result for the `search` matcher. */
+ search: URLPatternComponentResult;
+ /** The matched result for the `hash` matcher. */
+ hash: URLPatternComponentResult;
+}
+
+/**
+ * The URLPattern API provides a web platform primitive for matching URLs based
+ * on a convenient pattern syntax.
+ *
+ * The syntax is based on path-to-regexp. Wildcards, named capture groups,
+ * regular groups, and group modifiers are all supported.
+ *
+ * ```ts
+ * // Specify the pattern as structured data.
+ * const pattern = new URLPattern({ pathname: "/users/:user" });
+ * const match = pattern.exec("https://blog.example.com/users/joe");
+ * console.log(match.pathname.groups.user); // joe
+ * ```
+ *
+ * ```ts
+ * // Specify a fully qualified string pattern.
+ * const pattern = new URLPattern("https://example.com/books/:id");
+ * console.log(pattern.test("https://example.com/books/123")); // true
+ * console.log(pattern.test("https://deno.land/books/123")); // false
+ * ```
+ *
+ * ```ts
+ * // Specify a relative string pattern with a base URL.
+ * const pattern = new URLPattern("/article/:id", "https://blog.example.com");
+ * console.log(pattern.test("https://blog.example.com/article")); // false
+ * console.log(pattern.test("https://blog.example.com/article/123")); // true
+ * ```
+ *
+ * @category Web APIs
+ */
+declare interface URLPattern {
+ /**
+ * Test if the given input matches the stored pattern.
+ *
+ * The input can either be provided as an absolute URL string with an optional base,
+ * relative URL string with a required base, or as individual components
+ * in the form of an `URLPatternInit` object.
+ *
+ * ```ts
+ * const pattern = new URLPattern("https://example.com/books/:id");
+ *
+ * // Test an absolute url string.
+ * console.log(pattern.test("https://example.com/books/123")); // true
+ *
+ * // Test a relative url with a base.
+ * console.log(pattern.test("/books/123", "https://example.com")); // true
+ *
+ * // Test an object of url components.
+ * console.log(pattern.test({ pathname: "/books/123" })); // true
+ * ```
+ */
+ test(input: URLPatternInput, baseURL?: string): boolean;
+
+ /**
+ * Match the given input against the stored pattern.
+ *
+ * The input can either be provided as an absolute URL string with an optional base,
+ * relative URL string with a required base, or as individual components
+ * in the form of an `URLPatternInit` object.
+ *
+ * ```ts
+ * const pattern = new URLPattern("https://example.com/books/:id");
+ *
+ * // Match an absolute url string.
+ * let match = pattern.exec("https://example.com/books/123");
+ * console.log(match.pathname.groups.id); // 123
+ *
+ * // Match a relative url with a base.
+ * match = pattern.exec("/books/123", "https://example.com");
+ * console.log(match.pathname.groups.id); // 123
+ *
+ * // Match an object of url components.
+ * match = pattern.exec({ pathname: "/books/123" });
+ * console.log(match.pathname.groups.id); // 123
+ * ```
+ */
+ exec(input: URLPatternInput, baseURL?: string): URLPatternResult | null;
+
+ /** The pattern string for the `protocol`. */
+ readonly protocol: string;
+ /** The pattern string for the `username`. */
+ readonly username: string;
+ /** The pattern string for the `password`. */
+ readonly password: string;
+ /** The pattern string for the `hostname`. */
+ readonly hostname: string;
+ /** The pattern string for the `port`. */
+ readonly port: string;
+ /** The pattern string for the `pathname`. */
+ readonly pathname: string;
+ /** The pattern string for the `search`. */
+ readonly search: string;
+ /** The pattern string for the `hash`. */
+ readonly hash: string;
+}
+
+/**
+ * The URLPattern API provides a web platform primitive for matching URLs based
+ * on a convenient pattern syntax.
+ *
+ * The syntax is based on path-to-regexp. Wildcards, named capture groups,
+ * regular groups, and group modifiers are all supported.
+ *
+ * ```ts
+ * // Specify the pattern as structured data.
+ * const pattern = new URLPattern({ pathname: "/users/:user" });
+ * const match = pattern.exec("https://blog.example.com/users/joe");
+ * console.log(match.pathname.groups.user); // joe
+ * ```
+ *
+ * ```ts
+ * // Specify a fully qualified string pattern.
+ * const pattern = new URLPattern("https://example.com/books/:id");
+ * console.log(pattern.test("https://example.com/books/123")); // true
+ * console.log(pattern.test("https://deno.land/books/123")); // false
+ * ```
+ *
+ * ```ts
+ * // Specify a relative string pattern with a base URL.
+ * const pattern = new URLPattern("/article/:id", "https://blog.example.com");
+ * console.log(pattern.test("https://blog.example.com/article")); // false
+ * console.log(pattern.test("https://blog.example.com/article/123")); // true
+ * ```
+ *
+ * @category Web APIs
+ */
+declare var URLPattern: {
+ readonly prototype: URLPattern;
+ new (input: URLPatternInput, baseURL?: string): URLPattern;
+};
+
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore-file no-explicit-any no-var
+
+///
+///
+
+/** @category Web APIs */
+declare interface DOMException extends Error {
+ readonly name: string;
+ readonly message: string;
+ readonly code: number;
+ readonly INDEX_SIZE_ERR: 1;
+ readonly DOMSTRING_SIZE_ERR: 2;
+ readonly HIERARCHY_REQUEST_ERR: 3;
+ readonly WRONG_DOCUMENT_ERR: 4;
+ readonly INVALID_CHARACTER_ERR: 5;
+ readonly NO_DATA_ALLOWED_ERR: 6;
+ readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+ readonly NOT_FOUND_ERR: 8;
+ readonly NOT_SUPPORTED_ERR: 9;
+ readonly INUSE_ATTRIBUTE_ERR: 10;
+ readonly INVALID_STATE_ERR: 11;
+ readonly SYNTAX_ERR: 12;
+ readonly INVALID_MODIFICATION_ERR: 13;
+ readonly NAMESPACE_ERR: 14;
+ readonly INVALID_ACCESS_ERR: 15;
+ readonly VALIDATION_ERR: 16;
+ readonly TYPE_MISMATCH_ERR: 17;
+ readonly SECURITY_ERR: 18;
+ readonly NETWORK_ERR: 19;
+ readonly ABORT_ERR: 20;
+ readonly URL_MISMATCH_ERR: 21;
+ readonly QUOTA_EXCEEDED_ERR: 22;
+ readonly TIMEOUT_ERR: 23;
+ readonly INVALID_NODE_TYPE_ERR: 24;
+ readonly DATA_CLONE_ERR: 25;
+}
+
+/** @category Web APIs */
+declare var DOMException: {
+ readonly prototype: DOMException;
+ new (message?: string, name?: string): DOMException;
+ readonly INDEX_SIZE_ERR: 1;
+ readonly DOMSTRING_SIZE_ERR: 2;
+ readonly HIERARCHY_REQUEST_ERR: 3;
+ readonly WRONG_DOCUMENT_ERR: 4;
+ readonly INVALID_CHARACTER_ERR: 5;
+ readonly NO_DATA_ALLOWED_ERR: 6;
+ readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+ readonly NOT_FOUND_ERR: 8;
+ readonly NOT_SUPPORTED_ERR: 9;
+ readonly INUSE_ATTRIBUTE_ERR: 10;
+ readonly INVALID_STATE_ERR: 11;
+ readonly SYNTAX_ERR: 12;
+ readonly INVALID_MODIFICATION_ERR: 13;
+ readonly NAMESPACE_ERR: 14;
+ readonly INVALID_ACCESS_ERR: 15;
+ readonly VALIDATION_ERR: 16;
+ readonly TYPE_MISMATCH_ERR: 17;
+ readonly SECURITY_ERR: 18;
+ readonly NETWORK_ERR: 19;
+ readonly ABORT_ERR: 20;
+ readonly URL_MISMATCH_ERR: 21;
+ readonly QUOTA_EXCEEDED_ERR: 22;
+ readonly TIMEOUT_ERR: 23;
+ readonly INVALID_NODE_TYPE_ERR: 24;
+ readonly DATA_CLONE_ERR: 25;
+};
+
+/** @category DOM Events */
+declare interface EventInit {
+ bubbles?: boolean;
+ cancelable?: boolean;
+ composed?: boolean;
+}
+
+/** An event which takes place in the DOM.
+ *
+ * @category DOM Events
+ */
+declare interface Event {
+ /** 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;
+}
+
+/** An event which takes place in the DOM.
+ *
+ * @category DOM Events
+ */
+declare var Event: {
+ readonly prototype: Event;
+ new (type: string, eventInitDict?: EventInit): Event;
+ readonly AT_TARGET: number;
+ readonly BUBBLING_PHASE: number;
+ readonly CAPTURING_PHASE: number;
+ readonly NONE: number;
+};
+
+/**
+ * EventTarget is a DOM interface implemented by objects that can receive events
+ * and may have listeners for them.
+ *
+ * @category DOM Events
+ */
+declare interface 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 to event 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;
+}
+
+/**
+ * EventTarget is a DOM interface implemented by objects that can receive events
+ * and may have listeners for them.
+ *
+ * @category DOM Events
+ */
+declare var EventTarget: {
+ readonly prototype: EventTarget;
+ new (): EventTarget;
+};
+
+/** @category DOM Events */
+declare interface EventListener {
+ (evt: Event): void | Promise;
+}
+
+/** @category DOM Events */
+declare interface EventListenerObject {
+ handleEvent(evt: Event): void | Promise;
+}
+
+/** @category DOM Events */
+declare type EventListenerOrEventListenerObject =
+ | EventListener
+ | EventListenerObject;
+
+/** @category DOM Events */
+declare interface AddEventListenerOptions extends EventListenerOptions {
+ once?: boolean;
+ passive?: boolean;
+ signal?: AbortSignal;
+}
+
+/** @category DOM Events */
+declare interface EventListenerOptions {
+ capture?: boolean;
+}
+
+/** @category DOM Events */
+declare interface ProgressEventInit extends EventInit {
+ lengthComputable?: boolean;
+ loaded?: number;
+ total?: number;
+}
+
+/** Events measuring progress of an underlying process, like an HTTP request
+ * (for an XMLHttpRequest, or the loading of the underlying resource of an
+ * ,