porffor 0.60.22 → 0.60.24

package/compiler/codegen.js

@@ -3,6 +3,7 @@ import { number, ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector }
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
+import semantic from './semantic.js';
 import parse from './parse.js';
 import { log } from './log.js';
 import './prefs.js';
@@ -1198,6 +1199,22 @@ const nullish = (scope, wasm, type, nonbinary = true, intIn = false) => {
   ];
 };
 
+const eitherStringType = (leftType, rightType) => [
+  ...leftType,
+  number(TYPE_FLAGS.parity, Valtype.i32),
+  [ Opcodes.i32_or ],
+  number(TYPES.bytestring, Valtype.i32),
+  [ Opcodes.i32_eq ],
+
+  ...rightType,
+  number(TYPE_FLAGS.parity, Valtype.i32),
+  [ Opcodes.i32_or ],
+  number(TYPES.bytestring, Valtype.i32),
+  [ Opcodes.i32_eq ],
+
+  [ Opcodes.i32_or ]
+];
+
 const performOp = (scope, op, left, right, leftType, rightType) => {
   if (op === '||' || op === '&&' || op === '??') {
     return performLogicOp(scope, op, left, right, leftType, rightType);
@@ -1294,19 +1311,7 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
 
     ops.unshift(
       // if left or right are string or bytestring
-      ...leftType,
-      number(TYPE_FLAGS.parity, Valtype.i32),
-      [ Opcodes.i32_or ],
-      number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      ...rightType,
-      number(TYPE_FLAGS.parity, Valtype.i32),
-      [ Opcodes.i32_or ],
-      number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      [ Opcodes.i32_or ],
+      ...eitherStringType(leftType, rightType),
       [ Opcodes.if, Blocktype.void ],
       ...concatStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], leftType, rightType),
       [ Opcodes.br, 1 ],
@@ -1326,19 +1331,7 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
 
     ops.unshift(
       // if left or right are string or bytestring
-      ...leftType,
-      number(TYPE_FLAGS.parity, Valtype.i32),
-      [ Opcodes.i32_or ],
-      number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      ...rightType,
-      number(TYPE_FLAGS.parity, Valtype.i32),
-      [ Opcodes.i32_or ],
-      number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      [ Opcodes.i32_or ],
+      ...eitherStringType(leftType, rightType),
       [ Opcodes.if, Blocktype.void ],
       ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], leftType, rightType),
       ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
@@ -1599,11 +1592,11 @@ const generateLogicExp = (scope, decl) =>
 const getInferred = (scope, name, global = false) => {
   const isConst = getVarMetadata(scope, name, global)?.kind === 'const';
   if (global) {
-    if (globalInfer.has(name) && (isConst || inferLoopPrev.length === 0)) return globalInfer.get(name);
+    if (name in globalInfer && (isConst || inferLoopPrev.length === 0)) return globalInfer[name];
   } else if (scope.inferTree) {
     for (let i = scope.inferTree.length - 1; i >= 0; i--) {
       const x = scope.inferTree[i];
-      if (x._infer?.has(name)) return x._infer.get(name);
+      if (name in x) return x[name];
     }
   }
 
@@ -1612,21 +1605,20 @@ const getInferred = (scope, name, global = false) => {
 
 const setInferred = (scope, name, type, global = false) => {
   const isConst = getVarMetadata(scope, name, global)?.kind === 'const';
-  scope.inferTree ??= [];
+  scope.inferTree ??= [ Object.create(null) ];
 
   if (global) {
     // set inferred type in global if not already and not in a loop, else make it null
-    globalInfer.set(name, globalInfer.has(name) || (!isConst && inferLoopPrev.length > 0) ? null : type);
+    globalInfer[name] = name in globalInfer || (!isConst && inferLoopPrev.length > 0) ? null : type;
   } else {
     // set inferred type in top
     const top = scope.inferTree.at(-1);
-    top._infer ??= new Map();
-    top._infer.set(name, type);
+    top[name] = type;
 
     // invalidate inferred type above if mismatched
     for (let i = scope.inferTree.length - 2; i >= 0; i--) {
       const x = scope.inferTree[i];
-      if (x._infer && x._infer.get(name) !== type) x._infer.set(name, null);
+      if (name in x && x[name] !== type) x[name] = null;
     }
   }
 };
@@ -2051,31 +2043,6 @@ const generateChain = (scope, decl) => {
   return out;
 };
 
-const ArrayUtil = {
-  getLengthI32: pointer => [
-    ...pointer,
-    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ]
-  ],
-
-  getLength: pointer => [
-    ...pointer,
-    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-    Opcodes.i32_from_u
-  ],
-
-  setLengthI32: (pointer, value) => [
-    ...pointer,
-    ...value,
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
-  ],
-
-  setLength: (pointer, value) => [
-    ...pointer,
-    ...value,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
-  ]
-};
 
 const createNewTarget = (scope, decl, idx = 0, force = false) => {
   if (decl._new || force) {
@@ -2264,7 +2231,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       try {
         parsed = {
           type: 'BlockStatement',
-          body: parse(code).body.map(objectHack)
+          body: semantic(objectHack(parse(code)), decl._semanticScopes).body
         };
       } catch (e) {
         if (e.name === 'SyntaxError') {
@@ -2309,7 +2276,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       let parsed;
       try {
-        parsed = objectHack(parse(`(function(${args.join(',')}){${code}})`));
+        parsed = semantic(objectHack(parse(`(function(${args.join(',')}){${code}})`)), decl._semanticScopes);
       } catch (e) {
         if (e.name === 'SyntaxError') {
           // throw syntax errors of evals at runtime instead
@@ -2824,16 +2791,6 @@ const DEFAULT_VALUE = () => ({
   name: 'undefined'
 });
 
-const codeToSanitizedStr = code => {
-  let out = '';
-  while (code > 0) {
-    out += String.fromCharCode(97 + code % 26);
-    code -= 26;
-  }
-  return out;
-};
-const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => codeToSanitizedStr(_.charCodeAt(0)));
-
 const unhackName = name => {
   if (!name) return name;
 
@@ -3284,6 +3241,7 @@ const setDefaultFuncName = (decl, name) => {
     }
   }
 
+  name = name.split('#')[0];
   decl.id = { name };
 };
 
@@ -3299,8 +3257,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
     try {
       let usedNames = [];
       for (const x of pattern.properties) {
-        const name = x.key.name;
-        usedNames.push(name);
+        usedNames.push(x.key.name);
       }
 
       let path = init.arguments[0].value;
@@ -3327,11 +3284,11 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
 
         // mock ffi function
         asmFunc(name, {
-          wasm: [],
+          wasm: () => [],
           params: parameters.map(x => Valtype.i32),
           returns: result ? [ Valtype.i32 ] : [],
           returnType: TYPES.number
-        })
+        });
       }
 
       return [ [ null, 'dlopen', path, symbols ] ];
@@ -4523,27 +4480,26 @@ const generateUpdate = (scope, decl, _global, _name, valueUnused = false) => {
   ];
 };
 
-const inferBranchStart = (scope, decl) => {
-  scope.inferTree ??= [];
-  scope.inferTree.push(decl);
+const inferBranchStart = scope => {
+  scope.inferTree ??= [ Object.create(null) ];
+  scope.inferTree.push(Object.create(null));
 };
 
 const inferBranchEnd = scope => {
   scope.inferTree.pop();
 };
 
-const inferBranchElse = (scope, decl) => {
+const inferBranchElse = scope => {
+  // todo/opt: at end of else, find inferences in common and keep them?
   inferBranchEnd(scope);
-  inferBranchStart(scope, decl);
+  inferBranchStart(scope);
 };
 
 const inferLoopPrev = [];
-const inferLoopStart = (scope, decl) => {
-  scope.inferTree ??= [];
-
+const inferLoopStart = scope => {
   // todo/opt: do not just wipe the infer tree for loops
-  inferLoopPrev.push(scope.inferTree);
-  scope.inferTree = [ decl ];
+  inferLoopPrev.push(scope.inferTree ?? [ Object.create(null) ]);
+  scope.inferTree = [ Object.create(null) ];
 };
 
 const inferLoopEnd = scope => {
@@ -4562,23 +4518,23 @@ const generateIf = (scope, decl) => {
   const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test));
   out.push([ Opcodes.if, Blocktype.void ]);
   depth.push('if');
-  inferBranchStart(scope, decl.consequent);
+  inferBranchStart(scope);
 
   out.push(
     ...generate(scope, decl.consequent),
     [ Opcodes.drop ]
   );
 
-  inferBranchEnd(scope);
+
   if (decl.alternate) {
-    inferBranchStart(scope, decl.alternate);
+    inferBranchElse(scope);
     out.push(
       [ Opcodes.else ],
       ...generate(scope, decl.alternate),
       [ Opcodes.drop ]
     );
     inferBranchEnd(scope);
-  }
+  } else inferBranchEnd(scope);
 
   out.push(
     [ Opcodes.end ],
@@ -4594,7 +4550,7 @@ const generateConditional = (scope, decl) => {
 
   out.push([ Opcodes.if, valtypeBinary ]);
   depth.push('if');
-  inferBranchStart(scope, decl.consequent);
+  inferBranchStart(scope);
 
   out.push(
     ...generate(scope, decl.consequent),
@@ -4602,7 +4558,7 @@ const generateConditional = (scope, decl) => {
   );
 
   out.push([ Opcodes.else ]);
-  inferBranchElse(scope, decl.alternate);
+  inferBranchElse(scope);
 
   out.push(
     ...generate(scope, decl.alternate),
@@ -4624,7 +4580,7 @@ const generateFor = (scope, decl) => {
     [ Opcodes.drop ]
   );
 
-  inferLoopStart(scope, decl);
+  inferLoopStart(scope);
   out.push([ Opcodes.loop, Blocktype.void ]);
   depth.push('for');
 
@@ -4663,7 +4619,7 @@ const generateFor = (scope, decl) => {
 
 const generateWhile = (scope, decl) => {
   const out = [];
-  inferLoopStart(scope, decl);
+  inferLoopStart(scope);
 
   out.push([ Opcodes.loop, Blocktype.void ]);
   depth.push('while');
@@ -4691,7 +4647,7 @@ const generateWhile = (scope, decl) => {
 
 const generateDoWhile = (scope, decl) => {
   const out = [];
-  inferLoopStart(scope, decl);
+  inferLoopStart(scope);
 
   out.push([ Opcodes.loop, Blocktype.void ]);
 
@@ -4764,7 +4720,7 @@ const generateForOf = (scope, decl) => {
     [ Opcodes.local_set, length ]
   );
 
-  inferLoopStart(scope, decl);
+  inferLoopStart(scope);
   depth.push('forof');
   depth.push('block');
 
@@ -5104,7 +5060,7 @@ const generateForIn = (scope, decl) => {
     [ Opcodes.if, Blocktype.void ]
   );
 
-  inferLoopStart(scope, decl);
+  inferLoopStart(scope);
   depth.push('if');
   depth.push('forin');
   depth.push('block');
@@ -6769,9 +6725,13 @@ const objectHack = node => {
   }
 
   for (const x in node) {
-    if (node[x] != null && typeof node[x] === 'object') {
+    if (node[x] != null && typeof node[x] === 'object' && x[0] !== '_') {
       if (node[x].type) node[x] = objectHack(node[x]);
-      if (Array.isArray(node[x])) node[x] = node[x].map(objectHack);
+      if (Array.isArray(node[x])) {
+        for (let i = 0; i < node[x].length; i++) {
+          node[x][i] = objectHack(node[x][i]);
+        }
+      }
     }
   }
 
@@ -6829,7 +6789,6 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
     async: decl.async,
     subclass: decl._subclass, _onlyConstr: decl._onlyConstr, _onlyThisMethod: decl._onlyThisMethod,
     strict: scope.strict || decl.strict,
-    inferTree: [ decl ],
 
     generate() {
       if (func.wasm) return func.wasm;
@@ -6837,7 +6796,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
       // generating, stub _wasm
       let wasm = func.wasm = [];
 
-      let body = objectHack(decl.body);
+      let body = decl.body;
       if (decl.type === 'ArrowFunctionExpression' && decl.expression) {
         // hack: () => 0 -> () => return 0
         body = {
@@ -7185,8 +7144,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
 const generateBlock = (scope, decl) => {
   let out = [];
 
-  scope.inferTree ??= [];
-  scope.inferTree.push(decl);
+  inferBranchStart(scope);
 
   let len = decl.body.length, j = 0;
   for (let i = 0; i < len; i++) {
@@ -7197,7 +7155,7 @@ const generateBlock = (scope, decl) => {
     out = out.concat(generate(scope, x));
   }
 
-  scope.inferTree.pop();
+  inferBranchEnd(scope);
 
   if (out.length === 0) out.push(number(UNDEFINED));
   return out;
@@ -7403,7 +7361,7 @@ export default program => {
   typeswitchDepth = 0;
   usedTypes = new Set([ TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ]);
   coctc = new Map();
-  globalInfer = new Map();
+  globalInfer = Object.create(null);
 
   // set generic opcodes for current valtype
   Opcodes.const = valtypeBinary === Valtype.i32 ? Opcodes.i32_const : Opcodes.f64_const;
@@ -7429,7 +7387,11 @@ export default program => {
     objectHackers = ['assert', 'compareArray', 'Test262Error', ...new Set(Object.keys(builtinFuncs).map(getObjectName).concat(Object.keys(builtinVars).map(getObjectName)).filter(x => x))];
   }
 
-  const [ main ] = generateFunc({}, {
+  // todo/perf: make this lazy per func (again)
+  program = objectHack(program);
+  if (Prefs.closures) program = semantic(program);
+
+  generateFunc({}, {
     type: 'Program',
     id: { name: '#main' },
     body: {
@@ -7438,9 +7400,6 @@ export default program => {
     }
   });
 
-  // if wanted and blank main func and other exports, remove it
-  if (Prefs.rmBlankMain && main.wasm.length === 0 && funcs.some(x => x.export)) funcs.splice(main.index - importedFuncs.length, 1);
-
   for (let i = 0; i < funcs.length; i++) {
     const f = funcs[i];
 

package/compiler/parse.js

@@ -17,7 +17,7 @@ globalThis.parser = '';
 let parse;
 const loadParser = async (fallbackParser = 'acorn', forceParser) => {
   parser = forceParser ?? Prefs.parser ?? fallbackParser;
-  const mod = (await import((globalThis.document || globalThis.Deno ? 'https://esm.sh/' : '') + parser));
+  const mod = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
   if (mod.parseSync) parse = mod.parseSync;
     else parse = mod.parse;
 };

package/compiler/precompile.js

@@ -57,7 +57,7 @@ const compile = async (file, _funcs) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--module', '--truthy=no_nan_negative', '--no-rm-unused-types', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
+  let args = ['--module', '--truthy=no_nan_negative', '--no-rm-unused-types', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc', '--no-closures'];
   if (first.startsWith('// @porf')) {
     args = first.slice('// @porf '.length).split(' ').concat(args);
   }

package/compiler/prefs.js

@@ -1,4 +1,4 @@
-const onByDefault = [ 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused', 'data', 'passiveData', 'rmUnusedTypes', 'optTypes', 'coctc', 'ctHash' ];
+const onByDefault = [ 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused', 'data', 'passiveData', 'rmUnusedTypes', 'optTypes', 'coctc', 'ctHash', 'closures' ];
 
 const nameToKey = x => x.replace(/[a-z]\-[a-z]/g, y => `${y[0]}${y[2].toUpperCase()}`);
 

package/compiler/semantic.js

@@ -0,0 +1,184 @@
+// todo: sloppy vs strict mode
+// todo: function/class decls ?
+// todo: function params
+
+const varId = name => {
+  const lastFunc = scopes[scopes.lastFuncs.at(-1)];
+  lastFunc._variableIds ??= Object.create(null);
+  lastFunc._variableIds[name] ??= 0;
+  return lastFunc._variableIds[name]++;
+
+  // scopes._varId ??= Object.create(null);
+  // scopes._varId[name] ??= 0;
+  // return scopes._varId[name]++;
+};
+
+const declVar = (name, kind, node) => {
+  const parent = kind === 'var' ? scopes[scopes.lastFuncs.at(-1)] : scopes.at(-1);
+  parent._variables ??= Object.create(null);
+  parent._variables[name] = { node, id: varId(name) };
+};
+
+const analyzePattern = (kind, node) => {
+  if (!node) return;
+  switch (node.type) {
+    case 'Identifier':
+      declVar(node.name, kind, node);
+      break;
+
+    case 'RestElement':
+      analyzePattern(kind, node.argument);
+      break;
+
+    case 'AssignmentPattern':
+      analyzePattern(kind, node.left);
+      break;
+
+    case 'Property':
+      analyzePattern(kind, node.value);
+      break;
+
+    case 'ObjectPattern':
+      for (const x of node.properties) {
+        analyzePattern(kind, x.value);
+      }
+      break;
+
+    case 'ArrayPattern':
+      for (const x of node.elements) {
+        analyzePattern(kind, x);
+      }
+      break;
+  }
+};
+
+let scopes;
+const analyze = node => {
+  if (!node) return;
+
+  let openedScope = false;
+  switch (node.type) {
+    case 'ForStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'SwitchStatement':
+    case 'BlockStatement':
+      scopes.push(node);
+      openedScope = true;
+      break;
+
+    case 'CatchClause':
+      scopes.push(node);
+      if (node.param) analyzePattern('let', node.param);
+      openedScope = true;
+      break;
+
+    case 'VariableDeclaration':
+      for (const x of node.declarations) analyzePattern(node.kind, x.id);
+      break;
+
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ArrowFunctionExpression':
+      scopes.lastFuncs.push(scopes.length);
+      break;
+  }
+
+  for (const x in node) {
+    if (node[x] != null && typeof node[x] === 'object') {
+      if (node[x].type) analyze(node[x]);
+      if (Array.isArray(node[x])) {
+        for (const y of node[x]) analyze(y);
+      }
+    }
+  }
+
+  if (openedScope) {
+    scopes.pop();
+  }
+
+  if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+    scopes.lastFuncs.pop();
+  }
+};
+
+const objectHackers = ["assert","compareArray","Test262Error","Number","Math","Porffor","performance","String","ByteString","Array","ArrayBuffer","SharedArrayBuffer","Atomics","ecma262","BigInt","Boolean","console","crypto","DataView","Date","Error","AggregateError","TypeError","ReferenceError","SyntaxError","RangeError","EvalError","URIError","Test262Error","Function","JSON","Map","Object","Promise","Reflect","RegExp","Set","Symbol","Uint8Array","Int8Array","Uint8ClampedArray","Uint16Array","Int16Array","Uint32Array","Int32Array","Float32Array","Float64Array","BigInt64Array","BigUint64Array","WeakMap","WeakRef","WeakSet","navigator"];
+const annotate = node => {
+  if (!node) return;
+
+  let openedScope = false;
+  if (node._variables) {
+    scopes.push(node);
+    openedScope = true;
+  }
+
+  switch (node.type) {
+    case 'Identifier':
+      if (objectHackers.includes(node.name)) break;
+      for (let i = scopes.length - 1; i >= 0; i--) {
+        if (scopes[i]._variables?.[node.name]) {
+          const variable = scopes[i]._variables[node.name];
+          if (variable.id > 0) node.name = node.name + '#' + variable.id;
+          break;
+        }
+      }
+      break;
+
+    case 'MemberExpression':
+      if (node.computed) annotate(node.property);
+      annotate(node.object);
+      return;
+
+    case 'PropertyDefinition':
+    case 'Property':
+      if (node.computed) annotate(node.key);
+      annotate(node.value);
+      return;
+
+    case 'CallExpression':
+      if (node.callee.name === 'eval' || (node.callee.type === 'SequenceExpression' && node.callee.expressions.at(-1)?.name === 'eval')) {
+        if (node.callee.type === 'SequenceExpression' || node.optional) {
+          // indirect eval, no scopes
+          node._semanticScopes = [ node ];
+          node._semanticScopes.lastFuncs = [ 0 ];
+        } else {
+          // direct eval, use existing scope
+          node._semanticScopes = Object.assign([], scopes);
+        }
+      }
+
+    case 'NewExpression':
+      if (node.callee.name === 'Function') {
+        // todo: this is probably wrong and needs to add own new scope
+        node._semanticScopes = Object.assign([], scopes);
+      }
+      break;
+  }
+
+  for (const x in node) {
+    if (node[x] != null && typeof node[x] === 'object' && x[0] !== '_') {
+      if (node[x].type) annotate(node[x]);
+      if (Array.isArray(node[x])) {
+        for (const y of node[x]) annotate(y);
+      }
+    }
+  }
+
+  if (openedScope) {
+    scopes.pop();
+  }
+};
+
+export default (node, _scopes = null) => {
+  if (!_scopes) {
+    _scopes = [ node ];
+    _scopes.lastFuncs = [ 0 ];
+  }
+  scopes = _scopes;
+
+  analyze(node);
+  if (scopes.length !== _scopes.length) throw new Error('Scope mismatch');
+
+  annotate(node);
+  return node;
+};

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@honk/porffor",
-  "version": "0.60.22",
+  "version": "0.60.24",
   "exports": "./compiler/wrap.js",
   "publish": {
     "exclude": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.60.22",
+  "version": "0.60.24",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.60.22';
+globalThis.version = '0.60.24';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/foo.js

@@ -1 +0,0 @@
-(typeof console === 'undefined' ? print : console.log)('lol');