@nimbus-sh/worker 0.12.0 → 0.13.0

package/public/_assets/runtime/js-interpreter-ops-2f4dfec6798e70fc.js

@@ -0,0 +1,290 @@
+
+const operators = (function () {
+  "use strict";
+  return (ownKeys) => ({
+    add: (a, b) => a + b,
+    sub: (a, b) => a - b,
+    mul: (a, b) => a * b,
+    div: (a, b) => a / b,
+    mod: (a, b) => a % b,
+    exp: (a, b) => a ** b,
+    shl: (a, b) => a << b,
+    shr: (a, b) => a >> b,
+    ushr: (a, b) => a >>> b,
+    and: (a, b) => a & b,
+    or: (a, b) => a | b,
+    xor: (a, b) => a ^ b,
+    lt: (a, b) => a < b,
+    gt: (a, b) => a > b,
+    le: (a, b) => a <= b,
+    ge: (a, b) => a >= b,
+    has: (k, o) => k in o,
+    instanceOf: (v, c) => v instanceof c,
+    neg: (a) => -a,
+    plus: (a) => +a,
+    bitNot: (a) => ~a,
+    numeric: (v) => { let x = v; return x++; },
+    increment: (n) => { let x = n; return ++x; },
+    decrement: (n) => { let x = n; return --x; },
+    propertyKey: (v) => ownKeys({ [v]: 0 })[0],
+    get: (o, k) => o[k],
+    set: (o, k, v) => { o[k] = v; },
+    remove: (o, k) => delete o[k],
+  });
+})();
+function hostOperators(rt) {
+  const g = rt.global, hasOwn = rt.hasOwn;
+  const globals = { __proto__: null, "Object": () => g.Object, "Function": () => g.Function, "Array": () => g.Array, "Number": () => g.Number, "String": () => g.String, "Boolean": () => g.Boolean, "Symbol": () => g.Symbol, "BigInt": () => g.BigInt, "Math": () => g.Math, "JSON": () => g.JSON, "Date": () => g.Date, "RegExp": () => g.RegExp, "Error": () => g.Error, "TypeError": () => g.TypeError, "RangeError": () => g.RangeError, "SyntaxError": () => g.SyntaxError, "ReferenceError": () => g.ReferenceError, "EvalError": () => g.EvalError, "URIError": () => g.URIError, "AggregateError": () => g.AggregateError, "Promise": () => g.Promise, "Proxy": () => g.Proxy, "Reflect": () => g.Reflect, "Map": () => g.Map, "Set": () => g.Set, "WeakMap": () => g.WeakMap, "WeakSet": () => g.WeakSet, "WeakRef": () => g.WeakRef, "FinalizationRegistry": () => g.FinalizationRegistry, "ArrayBuffer": () => g.ArrayBuffer, "SharedArrayBuffer": () => g.SharedArrayBuffer, "DataView": () => g.DataView, "Uint8Array": () => g.Uint8Array, "Int8Array": () => g.Int8Array, "Uint16Array": () => g.Uint16Array, "Int16Array": () => g.Int16Array, "Uint32Array": () => g.Uint32Array, "Int32Array": () => g.Int32Array, "Float32Array": () => g.Float32Array, "Float64Array": () => g.Float64Array, "BigInt64Array": () => g.BigInt64Array, "BigUint64Array": () => g.BigUint64Array, "Uint8ClampedArray": () => g.Uint8ClampedArray, "Intl": () => g.Intl, "Atomics": () => g.Atomics, "globalThis": () => g.globalThis, "undefined": () => g.undefined, "NaN": () => g.NaN, "Infinity": () => g.Infinity, "isNaN": () => g.isNaN, "isFinite": () => g.isFinite, "parseInt": () => g.parseInt, "parseFloat": () => g.parseFloat, "encodeURIComponent": () => g.encodeURIComponent, "decodeURIComponent": () => g.decodeURIComponent, "encodeURI": () => g.encodeURI, "decodeURI": () => g.decodeURI, "escape": () => g.escape, "unescape": () => g.unescape, "console": () => g.console, "process": () => g.process, "Buffer": () => g.Buffer, "setTimeout": () => g.setTimeout, "clearTimeout": () => g.clearTimeout, "setInterval": () => g.setInterval, "clearInterval": () => g.clearInterval, "setImmediate": () => g.setImmediate, "clearImmediate": () => g.clearImmediate, "queueMicrotask": () => g.queueMicrotask, "structuredClone": () => g.structuredClone, "fetch": () => g.fetch, "Request": () => g.Request, "Response": () => g.Response, "Headers": () => g.Headers, "URL": () => g.URL, "URLSearchParams": () => g.URLSearchParams, "TextEncoder": () => g.TextEncoder, "TextDecoder": () => g.TextDecoder, "AbortController": () => g.AbortController, "AbortSignal": () => g.AbortSignal, "Event": () => g.Event, "EventTarget": () => g.EventTarget, "crypto": () => g.crypto, "performance": () => g.performance, "atob": () => g.atob, "btoa": () => g.btoa, "Blob": () => g.Blob, "FormData": () => g.FormData, "ReadableStream": () => g.ReadableStream, "WritableStream": () => g.WritableStream, "TransformStream": () => g.TransformStream, "WebAssembly": () => g.WebAssembly, "navigator": () => g.navigator, "require": () => g.require, "module": () => g.module, "exports": () => g.exports, "__filename": () => g.__filename, "__dirname": () => g.__dirname };
+  const delegate = function* (iterable) { return yield* iterable; };
+  delegate.prototype = rt.SafeGeneratorPrototype;
+  // Every field in the literal: one set afterwards would run a setter a program put on Object.prototype.
+  return {
+    ...operators(rt.ownKeys),
+    globalReader: (name) => (hasOwn(globals, name) ? globals[name] : undefined),
+    setSloppy: function (o, k, v) { o[k] = v; },
+    removeSloppy: function (o, k) { return delete o[k]; },
+    delegate,
+  };
+}
+function sloppy(rt) {
+const { call, arrow: callArrow, enter, enterGenerator, takeFrame, finish, construct, constructDerived, operand, AWAIT, YIELD, MARK } = rt;
+// Drives an async generator body from a state the consumer's return()
+// request left suspended (a finally block that awaits or yields). Returns
+// the body's final completion: MARK when it let the return proceed.
+async function* drain(it, r) {
+  for (;;) {
+    if (r.done) return r.value;
+    const mark = r.value, x = operand();
+    let value, ok = true;
+    if (mark === AWAIT) {
+      try { value = await x; } catch (e) { ok = false; value = e; }
+    } else {
+      let resumed = false;
+      try { value = mark === YIELD ? yield x : yield* x; resumed = true; }
+      catch (e) { ok = false; value = e; resumed = true; }
+      finally {
+        if (!resumed) {
+          const end = it.return(MARK);
+          const result = end.done ? end.value : yield* drain(it, end);
+          if (result !== MARK) return result;
+        }
+      }
+    }
+    r = ok ? it.next(value) : it.throw(value);
+  }
+}
+drain.prototype = rt.SafeAsyncGeneratorPrototype;
+return {
+  plain(fi, scope) {
+    const f = (0, function () { return call(fi, scope, f, this, arguments, new.target, undefined); });
+    return f;
+  },
+  method(fi, scope, home) {
+    const f = { m() { return call(fi, scope, f, this, arguments, undefined, home); } }.m;
+    return f;
+  },
+  arrow(fi, scope) {
+    return (...args) => callArrow(fi, scope, args);
+  },
+  generator(fi, scope, home) {
+    const f = (0, function* (...{ [enterGenerator(fi, scope, f, this, arguments, home)]: length }) {
+      const env = takeFrame(arguments);
+      return finish(fi, fi.body ? fi.body(env) : yield* fi.gen(env));
+    });
+    return f;
+  },
+  async(fi, scope, home) {
+    const f = (0, async function () {
+      const env = enter(fi, scope, f, this, arguments, undefined, home);
+      if (fi.body) return finish(fi, fi.body(env));
+      const it = fi.gen(env);
+      let r = it.next();
+      while (!r.done) {
+        let value, ok = true;
+        try { value = await r.value; } catch (e) { ok = false; value = e; }
+        r = ok ? it.next(value) : it.throw(value);
+      }
+      return finish(fi, r.value);
+    });
+    return f;
+  },
+  asyncArrow(fi, scope) {
+    return async (...args) => {
+      const env = enter(fi, scope, undefined, undefined, args, undefined, undefined);
+      if (fi.body) return finish(fi, fi.body(env));
+      const it = fi.gen(env);
+      let r = it.next();
+      while (!r.done) {
+        let value, ok = true;
+        try { value = await r.value; } catch (e) { ok = false; value = e; }
+        r = ok ? it.next(value) : it.throw(value);
+      }
+      return finish(fi, r.value);
+    };
+  },
+  // The body yields AWAIT, YIELD or DELEGATE with its operand beside it. A
+  // return() request at a yield is a return completion this frame cannot
+  // read the value of, so the body is returned with MARK: if its finally
+  // blocks leave MARK alone, the native return proceeds with its own value.
+  asyncGenerator(fi, scope, home) {
+    const f = (0, async function* (...{ [enterGenerator(fi, scope, f, this, arguments, home)]: length }) {
+      const env = takeFrame(arguments);
+      if (fi.body) return finish(fi, fi.body(env));
+      const it = fi.gen(env);
+      let r = it.next();
+      for (;;) {
+        if (r.done) return finish(fi, r.value);
+        const mark = r.value, x = operand();
+        let value, ok = true;
+        if (mark === AWAIT) {
+          try { value = await x; } catch (e) { ok = false; value = e; }
+        } else {
+          let resumed = false;
+          try { value = mark === YIELD ? yield x : yield* x; resumed = true; }
+          catch (e) { ok = false; value = e; resumed = true; }
+          finally {
+            if (!resumed) {
+              const end = it.return(MARK);
+              const result = end.done ? end.value : yield* drain(it, end);
+              if (result !== MARK) return finish(fi, result);
+            }
+          }
+        }
+        r = ok ? it.next(value) : it.throw(value);
+      }
+    });
+    return f;
+  },
+  classBase(fi, scope, record) {
+    const C = (0, class { constructor() { return construct(fi, scope, C, record, this, arguments, new.target); } });
+    return C;
+  },
+  classDerived(fi, scope, parent, record) {
+    const C = (0, class extends parent { constructor() { return constructDerived(fi, scope, C, record, arguments, new.target); } });
+    return C;
+  },
+};
+}
+const strict = (function () {
+  "use strict";
+  return function (rt) {
+const { call, arrow: callArrow, enter, enterGenerator, takeFrame, finish, construct, constructDerived, operand, AWAIT, YIELD, MARK } = rt;
+// Drives an async generator body from a state the consumer's return()
+// request left suspended (a finally block that awaits or yields). Returns
+// the body's final completion: MARK when it let the return proceed.
+async function* drain(it, r) {
+  for (;;) {
+    if (r.done) return r.value;
+    const mark = r.value, x = operand();
+    let value, ok = true;
+    if (mark === AWAIT) {
+      try { value = await x; } catch (e) { ok = false; value = e; }
+    } else {
+      let resumed = false;
+      try { value = mark === YIELD ? yield x : yield* x; resumed = true; }
+      catch (e) { ok = false; value = e; resumed = true; }
+      finally {
+        if (!resumed) {
+          const end = it.return(MARK);
+          const result = end.done ? end.value : yield* drain(it, end);
+          if (result !== MARK) return result;
+        }
+      }
+    }
+    r = ok ? it.next(value) : it.throw(value);
+  }
+}
+drain.prototype = rt.SafeAsyncGeneratorPrototype;
+return {
+  plain(fi, scope) {
+    const f = (0, function () { return call(fi, scope, f, this, arguments, new.target, undefined); });
+    return f;
+  },
+  method(fi, scope, home) {
+    const f = { m() { return call(fi, scope, f, this, arguments, undefined, home); } }.m;
+    return f;
+  },
+  arrow(fi, scope) {
+    return (...args) => callArrow(fi, scope, args);
+  },
+  generator(fi, scope, home) {
+    const f = (0, function* (...{ [enterGenerator(fi, scope, f, this, arguments, home)]: length }) {
+      const env = takeFrame(arguments);
+      return finish(fi, fi.body ? fi.body(env) : yield* fi.gen(env));
+    });
+    return f;
+  },
+  async(fi, scope, home) {
+    const f = (0, async function () {
+      const env = enter(fi, scope, f, this, arguments, undefined, home);
+      if (fi.body) return finish(fi, fi.body(env));
+      const it = fi.gen(env);
+      let r = it.next();
+      while (!r.done) {
+        let value, ok = true;
+        try { value = await r.value; } catch (e) { ok = false; value = e; }
+        r = ok ? it.next(value) : it.throw(value);
+      }
+      return finish(fi, r.value);
+    });
+    return f;
+  },
+  asyncArrow(fi, scope) {
+    return async (...args) => {
+      const env = enter(fi, scope, undefined, undefined, args, undefined, undefined);
+      if (fi.body) return finish(fi, fi.body(env));
+      const it = fi.gen(env);
+      let r = it.next();
+      while (!r.done) {
+        let value, ok = true;
+        try { value = await r.value; } catch (e) { ok = false; value = e; }
+        r = ok ? it.next(value) : it.throw(value);
+      }
+      return finish(fi, r.value);
+    };
+  },
+  // The body yields AWAIT, YIELD or DELEGATE with its operand beside it. A
+  // return() request at a yield is a return completion this frame cannot
+  // read the value of, so the body is returned with MARK: if its finally
+  // blocks leave MARK alone, the native return proceeds with its own value.
+  asyncGenerator(fi, scope, home) {
+    const f = (0, async function* (...{ [enterGenerator(fi, scope, f, this, arguments, home)]: length }) {
+      const env = takeFrame(arguments);
+      if (fi.body) return finish(fi, fi.body(env));
+      const it = fi.gen(env);
+      let r = it.next();
+      for (;;) {
+        if (r.done) return finish(fi, r.value);
+        const mark = r.value, x = operand();
+        let value, ok = true;
+        if (mark === AWAIT) {
+          try { value = await x; } catch (e) { ok = false; value = e; }
+        } else {
+          let resumed = false;
+          try { value = mark === YIELD ? yield x : yield* x; resumed = true; }
+          catch (e) { ok = false; value = e; resumed = true; }
+          finally {
+            if (!resumed) {
+              const end = it.return(MARK);
+              const result = end.done ? end.value : yield* drain(it, end);
+              if (result !== MARK) return finish(fi, result);
+            }
+          }
+        }
+        r = ok ? it.next(value) : it.throw(value);
+      }
+    });
+    return f;
+  },
+  classBase(fi, scope, record) {
+    const C = (0, class { constructor() { return construct(fi, scope, C, record, this, arguments, new.target); } });
+    return C;
+  },
+  classDerived(fi, scope, parent, record) {
+    const C = (0, class extends parent { constructor() { return constructDerived(fi, scope, C, record, arguments, new.target); } });
+    return C;
+  },
+};
+};
+})();
+module.exports = { bind: (rt) => ({ ops: hostOperators(rt), strict: strict(rt), sloppy: sloppy(rt) }) };

package/public/_assets/runtime/js-interpreter-primordials-e620a61b7e9800fa.js

@@ -0,0 +1 @@
+"use strict";var b=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var E=Object.getOwnPropertyNames;var I=Object.prototype.hasOwnProperty;var C=(t,e)=>{for(var o in e)b(t,o,{get:e[o],enumerable:!0})},k=(t,e,o,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of E(e))!I.call(t,n)&&n!==o&&b(t,n,{get:()=>e[n],enumerable:!(r=w(e,n))||r.enumerable});return t};var T=t=>k(b({},"__esModule",{value:!0}),t);var zt={};C(zt,{ArrayConstructor:()=>$,ArrayFrom:()=>tt,ArrayIteratorNext:()=>ot,ArrayIteratorPrototype:()=>R,ArrayPrototypeIndexOf:()=>gt,ArrayPrototypeLastIndexOf:()=>bt,ArrayPrototypePop:()=>ft,ArrayPrototypeToSpliced:()=>nt,ArrayPrototypeWith:()=>rt,ArrayValues:()=>et,BigInt:()=>Ct,BigIntPrototypeToString:()=>Ot,Error:()=>kt,GeneratorPrototypeNext:()=>Ft,GeneratorPrototypeReturn:()=>Nt,GeneratorPrototypeThrow:()=>Bt,LAUNCH_PRIMORDIALS:()=>Wt,NumberPrototypeToString:()=>St,ObjectOf:()=>q,ObjectPrototype:()=>mt,ObjectPrototypeHasOwnProperty:()=>dt,ObjectPrototypePropertyIsEnumerable:()=>Z,ObjectPrototypeToString:()=>jt,PromiseConstructor:()=>J,PromisePrototypeThen:()=>Y,PromiseReject:()=>X,PromiseResolve:()=>Q,RangeError:()=>Tt,ReferenceError:()=>Dt,RegExp:()=>Kt,RegExpPrototypeAccessors:()=>Pt,RegExpPrototypeExec:()=>ut,SafeAsyncGeneratorPrototype:()=>u,SafeGeneratorPrototype:()=>c,SafeList:()=>f,SafeMap:()=>l,SafeRegExpPrototype:()=>h,SafeSet:()=>i,SafeWeakMap:()=>a,SafeWeakSet:()=>x,StringFromCharCode:()=>xt,StringPrototypeCharAt:()=>at,StringPrototypeCharCodeAt:()=>ct,StringPrototypeIndexOf:()=>lt,StringPrototypeLastIndexOf:()=>st,StringPrototypeSlice:()=>pt,StringPrototypeSubstr:()=>it,SymbolConstructor:()=>wt,SymbolPrototypeDescription:()=>Et,SymbolPrototypeToString:()=>yt,SyntaxError:()=>Gt,TypeError:()=>vt,arrayIsArray:()=>z,dataDescriptor:()=>A,globalObject:()=>It,objectAssign:()=>B,objectCreate:()=>s,objectDefineProperties:()=>Rt,objectFreeze:()=>j,objectGetOwnPropertyNames:()=>W,objectHasOwn:()=>V,objectKeys:()=>N,parseFloatOf:()=>ht,parseIntOf:()=>At,reflectApply:()=>O,reflectConstruct:()=>D,reflectDefineProperty:()=>S,reflectDeleteProperty:()=>F,reflectGet:()=>g,reflectGetOwnPropertyDescriptor:()=>m,reflectGetPrototypeOf:()=>y,reflectHas:()=>G,reflectOwnKeys:()=>v,reflectSet:()=>K,reflectSetPrototypeOf:()=>d,registerSource:()=>Vt,stringOf:()=>_,symbolAsyncIterator:()=>M,symbolFor:()=>H,symbolIterator:()=>L,symbolUnscopables:()=>U});module.exports=T(zt);var O=Reflect.apply,D=Reflect.construct,g=Reflect.get,K=Reflect.set,G=Reflect.has,v=Reflect.ownKeys,S=Reflect.defineProperty,F=Reflect.deleteProperty,m=Reflect.getOwnPropertyDescriptor,y=Reflect.getPrototypeOf,d=Reflect.setPrototypeOf,s=Object.create,N=Object.keys,j=Object.freeze,B=Object.assign,V=Object.hasOwn,W=Object.getOwnPropertyNames,z=Array.isArray,H=Symbol.for,L=Symbol.iterator,M=Symbol.asyncIterator,U=Symbol.unscopables,_=String,q=Object,J=Promise,Q=Promise.resolve,X=Promise.reject,Y=Promise.prototype.then,Z=Object.prototype.propertyIsEnumerable,$=Array,tt=Array.from,et=Array.prototype[Symbol.iterator],R=Reflect.getPrototypeOf([][Symbol.iterator]())??{},ot=Reflect.get(R,"next"),rt=Reflect.get(Array.prototype,"with"),nt=Reflect.get(Array.prototype,"toSpliced"),pt=String.prototype.slice,st=String.prototype.lastIndexOf,ct=String.prototype.charCodeAt,yt=Symbol.prototype.toString,at=String.prototype.charAt,lt=String.prototype.indexOf,it=String.prototype.substr,xt=String.fromCharCode,ft=Array.prototype.pop,gt=Array.prototype.indexOf,bt=Array.prototype.lastIndexOf,ut=RegExp.prototype.exec,Pt=(()=>{let t=s(null),e=Object.getOwnPropertyNames(RegExp.prototype);for(let o=0;o<e.length;o++){let r=Reflect.getOwnPropertyDescriptor(RegExp.prototype,e[o])?.get;r!==void 0&&(t[e[o]]=r)}return t})(),St=Number.prototype.toString,Ot=BigInt.prototype.toString,mt=Object.prototype,dt=Object.prototype.hasOwnProperty,jt=Object.prototype.toString,Rt=Object.defineProperties,At=parseInt,ht=parseFloat,wt=Symbol,Et=Reflect.getOwnPropertyDescriptor(Symbol.prototype,"description")?.get,It=globalThis,Ct=BigInt,kt=Error,Tt=RangeError,Dt=ReferenceError,Kt=RegExp,Gt=SyntaxError,vt=TypeError;function A(t,e,o,r){let n=s(null);return n.value=t,n.writable=e,n.enumerable=o,n.configurable=r,n}function p(t,e,o){for(let r=0;r<o.length;r++){let n=m(e,o[r]);n&&S(t,o[r],n)}}var l=class extends Map{};p(l.prototype,Map.prototype,["get","set","has","delete","clear","forEach","size"]);var i=class extends Set{};p(i.prototype,Set.prototype,["add","has","delete","clear","forEach","size"]);var a=class extends WeakMap{};p(a.prototype,WeakMap.prototype,["get","set","has","delete"]);var x=class extends WeakSet{};p(x.prototype,WeakSet.prototype,["add","has","delete"]);var f=class extends Array{};d(f.prototype,null);var c=s(null),u=s(null);{let t=y(function*(){}.prototype)??{},e=y(async function*(){}.prototype)??{};p(c,t,["next","return","throw"]),p(c,y(t)??{},[Symbol.iterator]),p(u,e,["next","return","throw"]),p(u,y(e)??{},[Symbol.asyncIterator])}var h=s(null);{let t=Reflect.ownKeys(RegExp.prototype),e=[];for(let o=0;o<t.length;o++){let r=t[o];r!=="constructor"&&r!==Symbol.split&&r!==Symbol.matchAll&&(e[e.length]=r)}p(h,RegExp.prototype,e)}var Ft=g(c,"next"),Nt=g(c,"return"),Bt=g(c,"throw"),P=new a;function Vt(t,e){P.set(t,e)}{let t=Function.prototype.toString,e={toString(){if(typeof this=="function"){let o=P.get(this);if(o!==void 0)return o}return O(t,this,[])}}.toString;P.set(e,"function toString() { [native code] }"),S(Function.prototype,"toString",A(e,!0,!1,!0))}var Wt=j(s(null));