@neocompose/cli 0.87.2 → 0.88.0

package/dist/test-worker.mjs

@@ -879,6 +879,55 @@ var require_ignore = __commonJS({
 // src/test-worker.ts
 import { parentPort } from "node:worker_threads";
 
+// src/workspace-lock.ts
+import { join } from "node:path";
+
+// src/ui.ts
+var colorEnabled = process.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+function paint(open, close) {
+  if (!colorEnabled) return (text) => text;
+  return (text) => `\x1B[${open}m${text}\x1B[${close}m`;
+}
+var color = {
+  bold: paint(1, 22),
+  dim: paint(2, 22),
+  red: paint(31, 39),
+  green: paint(32, 39),
+  yellow: paint(33, 39),
+  blue: paint(34, 39),
+  magenta: paint(35, 39),
+  cyan: paint(36, 39)
+};
+var sym = {
+  ok: color.green("\u2714"),
+  fail: color.red("\u2716"),
+  warn: color.yellow("\u25B2"),
+  info: color.cyan("\u25CF"),
+  arrow: color.dim("\u2192"),
+  branch: color.magenta("\u2387"),
+  tag: color.cyan("\u2301"),
+  pointer: color.cyan("\u276F")
+};
+var CHANGE_KIND_COLOR = {
+  create: color.green,
+  update: color.yellow,
+  delete: color.red
+};
+
+// src/workspace-lock.ts
+var LOCK_FILE = join(".neo", "workspace.lock");
+
+// src/export-state.ts
+import { join as join2 } from "node:path";
+
+// ../packages/manifest/src/value-comparison.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/export-state.ts
+var EXPORT_STATE_FILE = join2(".neo", "export.json");
+
 // ../node_modules/uuid/dist-node/regex.js
 var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
 
@@ -2627,6 +2676,86 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
         ["x"],
         "Returns the square root. Accepts int or float and returns float; does not accept decimal."
       ),
+      mathFunction(
+        "Pow",
+        ["x", "y"],
+        "Returns x raised to y. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Exp",
+        ["x"],
+        "Returns e raised to x. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Log",
+        ["x"],
+        "Returns the natural logarithm. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Log10",
+        ["x"],
+        "Returns the base-10 logarithm. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Sin",
+        ["x"],
+        "Returns the sine of an angle in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Cos",
+        ["x"],
+        "Returns the cosine of an angle in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Tan",
+        ["x"],
+        "Returns the tangent of an angle in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Asin",
+        ["x"],
+        "Returns the inverse sine in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Acos",
+        ["x"],
+        "Returns the inverse cosine in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Atan",
+        ["x"],
+        "Returns the inverse tangent in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Atan2",
+        ["y", "x"],
+        "Returns the signed angle of x,y in radians. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Lerp",
+        ["a", "b", "t"],
+        "Interpolates from a to b with t clamped to [0,1]. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "InverseLerp",
+        ["a", "b", "value"],
+        "Returns the clamped normalized position of value between a and b; equal endpoints return zero. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "MoveTowards",
+        ["current", "target", "maxDelta"],
+        "Moves toward target by maxDelta. A negative maxDelta moves away. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "Repeat",
+        ["t", "length"],
+        "Wraps t using a finite positive length. Negative t wraps with floor. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
+      mathFunction(
+        "PingPong",
+        ["t", "length"],
+        "Reflects t between zero and a finite positive length. Accepts int or float, rounds inputs to float32, and returns float."
+      ),
       {
         ...property(
           "Math",
@@ -3815,29 +3944,58 @@ function isNSFunctionDecimalOp(value) {
   const digits = info.digitsPointer;
   return digits === void 0 || isNSPointer(digits);
 }
-var NS_MATH_OPS = [
-  "min",
-  "max",
-  "clamp",
-  "round",
-  "floor",
-  "ceiling",
-  "truncate",
-  "abs",
-  "sign",
-  "sqrt"
-];
+var NS_MATH_OP_ARITIES = {
+  min: 2,
+  max: 2,
+  clamp: 3,
+  round: 1,
+  floor: 1,
+  ceiling: 1,
+  truncate: 1,
+  abs: 1,
+  sign: 1,
+  sqrt: 1,
+  pow: 2,
+  exp: 1,
+  log: 1,
+  log10: 1,
+  sin: 1,
+  cos: 1,
+  tan: 1,
+  asin: 1,
+  acos: 1,
+  atan: 1,
+  atan2: 2,
+  lerp: 3,
+  inverselerp: 3,
+  movetowards: 3,
+  repeat: 2,
+  pingpong: 2
+};
 function isNSFunctionMathOp(value) {
   const v = value;
   if (v?.type !== "mathOp" /* mathOp */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  if (!NS_MATH_OPS.includes(info.op)) return false;
+  if (!Object.hasOwn(NS_MATH_OP_ARITIES, info.op)) return false;
   const args = info.argPointers;
   if (!Array.isArray(args)) return false;
+  if (args.length !== NS_MATH_OP_ARITIES[info.op]) return false;
   if (!args.every(isNSPointer)) return false;
   const decimal = info.decimal;
-  return decimal === void 0 || decimal === true;
+  if (decimal === void 0) return true;
+  if (decimal !== true) return false;
+  return [
+    "min",
+    "max",
+    "clamp",
+    "round",
+    "floor",
+    "ceiling",
+    "truncate",
+    "abs",
+    "sign"
+  ].includes(info.op);
 }
 var NS_TEXT_STRING_OPS = [
   "length",
@@ -4177,7 +4335,8 @@ function isNSInstructionFor(value) {
   if (instruction?.type !== "for" /* for */) return false;
   if (!isNSVariable(instruction.initializer)) return false;
   if (!isNSBooleanExpression(instruction.condition)) return false;
-  if (!isNSInstructionAssign(instruction.iterator)) return false;
+  if (!isNSInstructionAssign(instruction.iterator) && !isNSInstructionFunctionCall(instruction.iterator))
+    return false;
   return isNSInstructions(instruction.instructions);
 }
 function isNSInstructionForEach(value) {
@@ -16495,11 +16654,6 @@ function referenceReadTypeInfo(reference) {
   };
 }
 
-// ../packages/manifest/src/value-comparison.ts
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // ../packages/neoscript-runtime/src/values/canonical-json.ts
 function canonicalJsonStringify(value) {
   return JSON.stringify(toCanonicalJsonValue(value));
@@ -17937,6 +18091,7 @@ var NSGetterRuntimeError = class _NSGetterRuntimeError extends Error {
       node: { writable: true, value: void 0 },
       callerNode: { writable: true, value: void 0 },
       initializerValueId: { writable: true, value: void 0 },
+      provisionalRandomFailure: { writable: true, value: void 0 },
       sourceOwnerId: { writable: true, value: void 0 },
       attachedValueId: { writable: true, value: void 0 }
     });
@@ -17961,6 +18116,1894 @@ var UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
   valueId;
 };
 
+// ../packages/neoscript-language/src/random-contract.ts
+var NEO_RANDOM_IDS = {
+  class: "system_75b4633d-65d0-5da1-ac09-e7c2de0cd102",
+  constructor: "system_62be2a68-1c61-5be7-ac2e-13fa8e77eb26",
+  Value: "system_135e16a9-1996-5e5b-9c2a-730b2896a2cd",
+  RangeInt: "system_60709cd5-8924-5a8c-93e5-482c1e678cdb",
+  RangeFloat: "system_5b15f87c-3ea4-57d8-9156-f12366b73b3b",
+  Seed: "system_e4f25ff7-8b23-5c07-8bcc-6e112fd75575",
+  GetSeed: "system_9d442bde-25e8-51af-baab-08e99947edcd",
+  SetSeed: "system_1eea1de7-5a9b-55e6-8d59-5d27f829d4db",
+  ValidateSeed: "system_a99e8b1e-c2c8-5a49-8497-a4ac9260702c"
+};
+var NEO_RANDOM_NATIVE_MEMBER_IDS = /* @__PURE__ */ new Set([
+  NEO_RANDOM_IDS.Value,
+  NEO_RANDOM_IDS.RangeInt,
+  NEO_RANDOM_IDS.RangeFloat,
+  NEO_RANDOM_IDS.GetSeed,
+  NEO_RANDOM_IDS.SetSeed,
+  NEO_RANDOM_IDS.ValidateSeed
+]);
+function isNeoRandomSharedMethod(classId, memberId) {
+  return classId === NEO_RANDOM_IDS.class && (memberId === NEO_RANDOM_IDS.Value || memberId === NEO_RANDOM_IDS.RangeInt || memberId === NEO_RANDOM_IDS.RangeFloat);
+}
+
+// ../packages/neoscript-runtime/src/neoscript/NeoRandom.ts
+function argumentError(message) {
+  throw new NSGetterRuntimeError(message, {
+    errorClassId: NEO_ERROR_CLASS_IDS.NeoArgumentError
+  });
+}
+function entropySeed() {
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    return globalThis.crypto.getRandomValues(new Uint32Array(1))[0];
+  }
+  return Math.floor(Math.random() * 4294967296);
+}
+function validateRandomSeed(seed) {
+  if (!Number.isSafeInteger(seed))
+    argumentError("NeoRandom seed must be a safe integer.");
+}
+var NeoRandom = class _NeoRandom {
+  constructor(seed = entropySeed(), onSeedWrite) {
+    this.onSeedWrite = onSeedWrite;
+    if (typeof seed === "string") {
+      this.identity = seed;
+      this.contentScope = true;
+    } else this.resetSeed(seed);
+  }
+  onSeedWrite;
+  x = 0;
+  y = 0;
+  z = 0;
+  w = 0;
+  identity;
+  assignedSeed = 0;
+  instances;
+  contentScope = false;
+  /** Monotonic draws, including isolated content evaluations; used by diagnostics. */
+  draws = 0;
+  get drawCount() {
+    return this.draws;
+  }
+  get seed() {
+    this.initializeIdentity();
+    return this.assignedSeed;
+  }
+  set seed(seed) {
+    this.resetSeed(seed);
+    this.noteSeedWrite(NEO_RANDOM_IDS.Seed);
+  }
+  resetSeed(seed) {
+    validateRandomSeed(seed);
+    this.assignedSeed = seed;
+    this.identity = void 0;
+    this.x = seed >>> 0;
+    this.y = Math.imul(1812433253, this.x ^ this.x >>> 30) + 1 >>> 0;
+    this.z = Math.imul(1812433253, this.y ^ this.y >>> 30) + 2 >>> 0;
+    this.w = Math.imul(1812433253, this.z ^ this.z >>> 30) + 3 >>> 0;
+  }
+  /** Install a lazy content seed, preserving even an uninitialized caller frame. */
+  withIdentity(identity2, evaluate) {
+    const pending = this.identity;
+    const seed = this.assignedSeed;
+    const instances = this.instances;
+    const contentScope = this.contentScope;
+    this.instances = void 0;
+    this.contentScope = true;
+    const x = this.x, y = this.y, z = this.z, w = this.w;
+    this.identity = identity2;
+    try {
+      return evaluate();
+    } finally {
+      this.identity = pending;
+      this.assignedSeed = seed;
+      this.instances = instances;
+      this.contentScope = contentScope;
+      this.x = x;
+      this.y = y;
+      this.z = z;
+      this.w = w;
+    }
+  }
+  /** Reuse idle content-replay storage without hashing until the first draw. */
+  deferIdentity(identity2) {
+    this.identity = identity2;
+    this.instances = void 0;
+    this.contentScope = true;
+  }
+  /** Instance lookup retains discarded transient objects only weakly. */
+  findInstance(value, storedId) {
+    const streams = this.instances;
+    if (streams === void 0) return void 0;
+    if (storedId !== void 0) {
+      const stored = streams.stored.get(storedId);
+      if (stored !== void 0) return stored;
+    }
+    const transient = streams.transient.get(value);
+    if (transient !== void 0 && storedId !== void 0) {
+      streams.stored.set(storedId, transient);
+      streams.transient.delete(value);
+    }
+    return transient;
+  }
+  addInstance(value, storedId, seed) {
+    const stream = new _NeoRandom(seed);
+    const streams = this.instances ??= {
+      transient: /* @__PURE__ */ new WeakMap(),
+      stored: /* @__PURE__ */ new Map()
+    };
+    if (storedId === void 0) streams.transient.set(value, stream);
+    else streams.stored.set(storedId, stream);
+    return stream;
+  }
+  clearInstances() {
+    this.instances = void 0;
+  }
+  forgetInstance(id) {
+    if (this.instances?.stored.delete(id))
+      this.noteSeedWrite(`${NEO_RANDOM_IDS.Seed}:${id}`);
+  }
+  get isContentScope() {
+    return this.contentScope;
+  }
+  noteSeedWrite(key) {
+    if (!this.contentScope) this.onSeedWrite?.(key);
+  }
+  initializeIdentity() {
+    if (this.identity !== void 0) {
+      let seed = 2166136261;
+      for (let i = 0; i < this.identity.length; i++) {
+        seed = Math.imul(seed ^ this.identity.charCodeAt(i), 16777619);
+      }
+      this.seed = seed >>> 0;
+    }
+  }
+  nextWord() {
+    this.initializeIdentity();
+    const t = this.x ^ this.x << 11;
+    this.x = this.y;
+    this.y = this.z;
+    this.z = this.w;
+    this.w = (this.w ^ this.w >>> 19 ^ t ^ t >>> 8) >>> 0;
+    this.draws++;
+    return this.w;
+  }
+  value() {
+    return Math.fround((this.nextWord() >>> 8) / 16777215);
+  }
+  rangeInt(min, max) {
+    if (!Number.isInteger(min))
+      argumentError("NeoRandom.Range int min must be an integer.");
+    if (min < -2147483648 || min > 2147483647)
+      argumentError("NeoRandom.Range int min must fit int32.");
+    if (!Number.isInteger(max))
+      argumentError("NeoRandom.Range int max must be an integer.");
+    if (max < -2147483648 || max > 2147483647)
+      argumentError("NeoRandom.Range int max must fit int32.");
+    if (min === max) return min;
+    const width = Math.abs(max - min);
+    const cutoff = Math.floor(4294967296 / width) * width;
+    let word;
+    do {
+      word = this.nextWord();
+    } while (word >= cutoff);
+    const offset = word % width;
+    return min < max ? min + offset : min - offset;
+  }
+  rangeFloat(min, max) {
+    min = Math.fround(min);
+    max = Math.fround(max);
+    if (!Number.isFinite(min))
+      argumentError("NeoRandom.Range float min must be finite.");
+    if (!Number.isFinite(max))
+      argumentError("NeoRandom.Range float max must be finite.");
+    if (min === max) return min;
+    if (min > max) {
+      const previous = min;
+      min = max;
+      max = previous;
+    }
+    const u = this.value();
+    if (u === 0) return min;
+    if (u === 1) return max;
+    const result = Math.fround((1 - u) * min + u * max);
+    if (result < min) return min;
+    if (result > max) return max;
+    return result;
+  }
+};
+var contentScratch = /* @__PURE__ */ new WeakMap();
+function withContentRandomSource(owner, identity2, evaluate) {
+  let random;
+  let idle;
+  const source = () => {
+    if (random !== void 0) return random;
+    idle = contentScratch.get(owner);
+    if (idle === void 0) contentScratch.set(owner, idle = []);
+    random = idle.pop();
+    if (random === void 0) random = new NeoRandom(identity2);
+    else random.deferIdentity(identity2);
+    return random;
+  };
+  try {
+    return evaluate(source);
+  } finally {
+    if (random !== void 0) {
+      random.clearInstances();
+      idle.push(random);
+    }
+  }
+}
+
+// ../packages/neoscript-runtime/src/neoscript/math/neo-math-kernel.ts
+var words = new DataView(new ArrayBuffer(8));
+function highWord(x) {
+  words.setFloat64(0, x, false);
+  return words.getInt32(0, false);
+}
+function lowWord(x) {
+  words.setFloat64(0, x, false);
+  return words.getInt32(4, false);
+}
+function withHighWord(x, w) {
+  words.setFloat64(0, x, false);
+  words.setInt32(0, w, false);
+  return words.getFloat64(0, false);
+}
+function withLowWord(x, w) {
+  words.setFloat64(0, x, false);
+  words.setInt32(4, w, false);
+  return words.getFloat64(0, false);
+}
+function copysign(x, y) {
+  return withHighWord(
+    x,
+    highWord(x) & 2147483647 | highWord(y) & 2147483648
+  );
+}
+var s_sin_y = new Array(2).fill(0);
+var s_cos_y = new Array(2).fill(0);
+var s_tan_y = new Array(2).fill(0);
+var e_rem_pio2_tx = new Array(3).fill(0);
+var k_rem_pio2_iq = new Array(20).fill(0);
+var k_rem_pio2_f = new Array(20).fill(0);
+var k_rem_pio2_fq = new Array(20).fill(0);
+var k_rem_pio2_q = new Array(20).fill(0);
+var e_pow_bp = [1, 1.5];
+var e_pow_dp_h = [0, 0.5849624872207642];
+var e_pow_dp_l = [0, 1350039202129749e-23];
+var e_pow_zero = 0;
+var e_pow_one = 1;
+var e_pow_two = 2;
+var e_pow_two53 = 9007199254740992;
+var e_pow_huge = 1e300;
+var e_pow_tiny = 1e-300;
+var e_pow_L1 = 0.5999999999999946;
+var e_pow_L2 = 0.4285714285785502;
+var e_pow_L3 = 0.33333332981837743;
+var e_pow_L4 = 0.272728123808534;
+var e_pow_L5 = 0.23066074577556175;
+var e_pow_L6 = 0.20697501780033842;
+var e_pow_P1 = 0.16666666666666602;
+var e_pow_P2 = -0.0027777777777015593;
+var e_pow_P3 = 6613756321437934e-20;
+var e_pow_P4 = -16533902205465252e-22;
+var e_pow_P5 = 41381367970572385e-24;
+var e_pow_lg2 = 0.6931471805599453;
+var e_pow_lg2_h = 0.6931471824645996;
+var e_pow_lg2_l = -1904654299957768e-24;
+var e_pow_ovt = 8008566259537294e-32;
+var e_pow_cp = 0.9617966939259756;
+var e_pow_cp_h = 0.9617967009544373;
+var e_pow_cp_l = -7028461650952758e-24;
+var e_pow_ivln2 = 1.4426950408889634;
+var e_pow_ivln2_h = 1.4426950216293335;
+var e_pow_ivln2_l = 19259629911266175e-24;
+function kernel___ieee754_pow(x, y) {
+  let z = 0;
+  let ax = 0;
+  let z_h = 0;
+  let z_l = 0;
+  let p_h = 0;
+  let p_l = 0;
+  let y1 = 0;
+  let t1 = 0;
+  let t2 = 0;
+  let r = 0;
+  let s = 0;
+  let t = 0;
+  let u = 0;
+  let v = 0;
+  let w = 0;
+  let i = 0;
+  let j = 0;
+  let k = 0;
+  let yisint = 0;
+  let n = 0;
+  let hx = 0;
+  let hy = 0;
+  let ix = 0;
+  let iy = 0;
+  let lx = 0;
+  let ly = 0;
+  hx = highWord(x) | 0;
+  lx = lowWord(x) >>> 0;
+  hy = highWord(y) | 0;
+  ly = lowWord(y) >>> 0;
+  ix = hx & 2147483647 | 0;
+  iy = hy & 2147483647 | 0;
+  if ((iy >>> 0 | ly >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+    return e_pow_one;
+  }
+  if (ix > 2146435072 || ix == 2146435072 && lx >>> 0 != 0 >>> 0 || iy > 2146435072 || iy == 2146435072 && ly >>> 0 != 0 >>> 0) {
+    return x + y;
+  }
+  yisint = 0 | 0;
+  if (hx < 0) {
+    if (iy >= 1128267776) {
+      yisint = 2 | 0;
+    } else {
+      if (iy >= 1072693248) {
+        k = (iy >> 20) - 1023 | 0;
+        if (k > 20) {
+          j = ly >>> 52 - k | 0;
+          if (j << 52 - k >>> 0 == ly >>> 0) {
+            yisint = 2 - (j & 1) | 0;
+          }
+        } else {
+          if (ly >>> 0 == 0 >>> 0) {
+            j = iy >> 20 - k | 0;
+            if (j << 20 - k == iy) {
+              yisint = 2 - (j & 1) | 0;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (ly >>> 0 == 0 >>> 0) {
+    if (iy == 2146435072) {
+      if ((ix - 1072693248 >>> 0 | lx >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+        return y - y;
+      } else {
+        if (ix >= 1072693248) {
+          return hy >= 0 ? y : e_pow_zero;
+        } else {
+          return hy < 0 ? -y : e_pow_zero;
+        }
+      }
+    }
+    if (iy == 1072693248) {
+      if (hy < 0) {
+        return e_pow_one / x;
+      } else {
+        return x;
+      }
+    }
+    if (hy == 1073741824) {
+      return x * x;
+    }
+    if (hy == 1071644672) {
+      if (hx >= 0) {
+        return Math.sqrt(x);
+      }
+    }
+  }
+  ax = Math.abs(x);
+  if (lx >>> 0 == 0 >>> 0) {
+    if (ix == 2146435072 || ix == 0 || ix == 1072693248) {
+      z = ax;
+      if (hy < 0) {
+        z = e_pow_one / z;
+      }
+      if (hx < 0) {
+        if ((ix - 1072693248 | yisint) == 0) {
+          z = (z - z) / (z - z);
+        } else {
+          if (yisint == 1) {
+            z = -z;
+          }
+        }
+      }
+      return z;
+    }
+  }
+  n = (hx >> 31) + 1 | 0;
+  if ((n | yisint) == 0) {
+    return (x - x) / (x - x);
+  }
+  s = e_pow_one;
+  if ((n | yisint - 1) == 0) {
+    s = -e_pow_one;
+  }
+  if (iy > 1105199104) {
+    if (iy > 1139802112) {
+      if (ix <= 1072693247) {
+        return hy < 0 ? e_pow_huge * e_pow_huge : e_pow_tiny * e_pow_tiny;
+      }
+      if (ix >= 1072693248) {
+        return hy > 0 ? e_pow_huge * e_pow_huge : e_pow_tiny * e_pow_tiny;
+      }
+    }
+    if (ix < 1072693247) {
+      return hy < 0 ? s * e_pow_huge * e_pow_huge : s * e_pow_tiny * e_pow_tiny;
+    }
+    if (ix > 1072693248) {
+      return hy > 0 ? s * e_pow_huge * e_pow_huge : s * e_pow_tiny * e_pow_tiny;
+    }
+    t = ax - e_pow_one;
+    w = t * t * (0.5 - t * (0.3333333333333333 - t * 0.25));
+    u = e_pow_ivln2_h * t;
+    v = t * e_pow_ivln2_l - w * e_pow_ivln2;
+    t1 = u + v;
+    t1 = withLowWord(t1, 0 | 0);
+    t2 = v - (t1 - u);
+  } else {
+    let ss = 0;
+    let s2 = 0;
+    let s_h = 0;
+    let s_l = 0;
+    let t_h = 0;
+    let t_l = 0;
+    n = 0 | 0;
+    if (ix < 1048576) {
+      ax = ax * e_pow_two53;
+      n = n - 53 | 0;
+      ix = highWord(ax) | 0;
+    }
+    n = n + ((ix >> 20) - 1023) | 0;
+    j = ix & 1048575 | 0;
+    ix = j | 1072693248 | 0;
+    if (j <= 235662) {
+      k = 0 | 0;
+    } else {
+      if (j < 767610) {
+        k = 1 | 0;
+      } else {
+        k = 0 | 0;
+        n = n + 1 | 0;
+        ix = ix - 1048576 | 0;
+      }
+    }
+    ax = withHighWord(ax, ix | 0);
+    u = ax - e_pow_bp[k];
+    v = e_pow_one / (ax + e_pow_bp[k]);
+    ss = u * v;
+    s_h = ss;
+    s_h = withLowWord(s_h, 0 | 0);
+    t_h = e_pow_zero;
+    t_h = withHighWord(
+      t_h,
+      (ix >> 1 | 536870912) + 524288 + (k << 18) | 0
+    );
+    t_l = ax - (t_h - e_pow_bp[k]);
+    s_l = v * (u - s_h * t_h - s_h * t_l);
+    s2 = ss * ss;
+    r = s2 * s2 * (e_pow_L1 + s2 * (e_pow_L2 + s2 * (e_pow_L3 + s2 * (e_pow_L4 + s2 * (e_pow_L5 + s2 * e_pow_L6)))));
+    r = r + s_l * (s_h + ss);
+    s2 = s_h * s_h;
+    t_h = 3 + s2 + r;
+    t_h = withLowWord(t_h, 0 | 0);
+    t_l = r - (t_h - 3 - s2);
+    u = s_h * t_h;
+    v = s_l * t_h + t_l * ss;
+    p_h = u + v;
+    p_h = withLowWord(p_h, 0 | 0);
+    p_l = v - (p_h - u);
+    z_h = e_pow_cp_h * p_h;
+    z_l = e_pow_cp_l * p_h + p_l * e_pow_cp + e_pow_dp_l[k];
+    t = n;
+    t1 = z_h + z_l + e_pow_dp_h[k] + t;
+    t1 = withLowWord(t1, 0 | 0);
+    t2 = z_l - (t1 - t - e_pow_dp_h[k] - z_h);
+  }
+  y1 = y;
+  y1 = withLowWord(y1, 0 | 0);
+  p_l = (y - y1) * t1 + y * t2;
+  p_h = y1 * t1;
+  z = p_l + p_h;
+  j = highWord(z) | 0;
+  i = lowWord(z) | 0;
+  if (j >= 1083179008) {
+    if ((j - 1083179008 | i) != 0) {
+      return s * e_pow_huge * e_pow_huge;
+    } else {
+      if (p_l + e_pow_ovt > z - p_h) {
+        return s * e_pow_huge * e_pow_huge;
+      }
+    }
+  } else {
+    if ((j & 2147483647) >= 1083231232) {
+      if (((j >>> 0) - (3230714880 >>> 0) >>> 0 | i >>> 0) >>> 0 >>> 0 != 0 >>> 0) {
+        return s * e_pow_tiny * e_pow_tiny;
+      } else {
+        if (p_l <= z - p_h) {
+          return s * e_pow_tiny * e_pow_tiny;
+        }
+      }
+    }
+  }
+  i = j & 2147483647 | 0;
+  k = (i >> 20) - 1023 | 0;
+  n = 0 | 0;
+  if (i > 1071644672) {
+    n = j + (1048576 >> k + 1) | 0;
+    k = ((n & 2147483647) >> 20) - 1023 | 0;
+    t = e_pow_zero;
+    t = withHighWord(t, n & ~(1048575 >> k) | 0);
+    n = (n & 1048575 | 1048576) >> 20 - k | 0;
+    if (j < 0) {
+      n = -n | 0;
+    }
+    p_h = p_h - t;
+  }
+  t = p_l + p_h;
+  t = withLowWord(t, 0 | 0);
+  u = t * e_pow_lg2_h;
+  v = (p_l - (t - p_h)) * e_pow_lg2 + t * e_pow_lg2_l;
+  z = u + v;
+  w = v - (z - u);
+  t = z * z;
+  t1 = z - t * (e_pow_P1 + t * (e_pow_P2 + t * (e_pow_P3 + t * (e_pow_P4 + t * e_pow_P5))));
+  r = z * t1 / (t1 - e_pow_two) - (w + z * w);
+  z = e_pow_one - (r - z);
+  j = highWord(z) | 0;
+  j = j + (n << 20) | 0;
+  if (j >> 20 <= 0) {
+    z = kernel_scalbn(z, n);
+  } else {
+    z = withHighWord(z, highWord(z) + (n << 20) | 0);
+  }
+  return s * z;
+}
+var e_exp_one = 1;
+var e_exp_halF = [0.5, -0.5];
+var e_exp_huge = 1e300;
+var e_exp_twom1000 = 9332636185032189e-317;
+var e_exp_o_threshold = 709.782712893384;
+var e_exp_u_threshold = -745.1332191019411;
+var e_exp_ln2HI = [0.6931471803691238, -0.6931471803691238];
+var e_exp_ln2LO = [19082149292705877e-26, -19082149292705877e-26];
+var e_exp_invln2 = 1.4426950408889634;
+var e_exp_P1 = 0.16666666666666602;
+var e_exp_P2 = -0.0027777777777015593;
+var e_exp_P3 = 6613756321437934e-20;
+var e_exp_P4 = -16533902205465252e-22;
+var e_exp_P5 = 41381367970572385e-24;
+function kernel___ieee754_exp(x) {
+  let y = 0;
+  let hi = 0;
+  let lo = 0;
+  let c = 0;
+  let t = 0;
+  let k = 0;
+  let xsb = 0;
+  let hx = 0;
+  hx = highWord(x) >>> 0;
+  xsb = (hx >>> 31 >>> 0 & 1 >>> 0) >>> 0 | 0;
+  hx = (hx & 2147483647) >>> 0;
+  if (hx >>> 0 >= 1082535490 >>> 0) {
+    if (hx >>> 0 >= 2146435072 >>> 0) {
+      if (((hx >>> 0 & 1048575 >>> 0) >>> 0 >>> 0 | lowWord(x) >>> 0) >>> 0 >>> 0 != 0 >>> 0) {
+        return x + x;
+      } else {
+        return xsb == 0 ? x : 0;
+      }
+    }
+    if (x > e_exp_o_threshold) {
+      return e_exp_huge * e_exp_huge;
+    }
+    if (x < e_exp_u_threshold) {
+      return e_exp_twom1000 * e_exp_twom1000;
+    }
+  }
+  if (hx >>> 0 > 1071001154 >>> 0) {
+    if (hx >>> 0 < 1072734898 >>> 0) {
+      hi = x - e_exp_ln2HI[xsb];
+      lo = e_exp_ln2LO[xsb];
+      k = 1 - xsb - xsb | 0;
+    } else {
+      k = e_exp_invln2 * x + e_exp_halF[xsb] | 0 | 0;
+      t = k;
+      hi = x - t * e_exp_ln2HI[0];
+      lo = t * e_exp_ln2LO[0];
+    }
+    x = hi - lo;
+  } else {
+    if (hx >>> 0 < 1043333120 >>> 0) {
+      if (e_exp_huge + x > e_exp_one) {
+        return e_exp_one + x;
+      }
+    } else {
+      k = 0 | 0;
+    }
+  }
+  t = x * x;
+  c = x - t * (e_exp_P1 + t * (e_exp_P2 + t * (e_exp_P3 + t * (e_exp_P4 + t * e_exp_P5))));
+  if (k == 0) {
+    return e_exp_one - (x * c / (c - 2) - x);
+  } else {
+    y = e_exp_one - (lo - x * c / (2 - c) - hi);
+  }
+  if (k >= -1021) {
+    y = withHighWord(y, highWord(y) + (k << 20) | 0);
+    return y;
+  } else {
+    y = withHighWord(y, highWord(y) + (k + 1e3 << 20) | 0);
+    return y * e_exp_twom1000;
+  }
+}
+var e_log_ln2_hi = 0.6931471803691238;
+var e_log_ln2_lo = 19082149292705877e-26;
+var e_log_two54 = 18014398509481984;
+var e_log_Lg1 = 0.6666666666666735;
+var e_log_Lg2 = 0.3999999999940942;
+var e_log_Lg3 = 0.2857142874366239;
+var e_log_Lg4 = 0.22222198432149784;
+var e_log_Lg5 = 0.1818357216161805;
+var e_log_Lg6 = 0.15313837699209373;
+var e_log_Lg7 = 0.14798198605116586;
+var e_log_zero = 0;
+function kernel___ieee754_log(x) {
+  let hfsq = 0;
+  let f = 0;
+  let s = 0;
+  let z = 0;
+  let R = 0;
+  let w = 0;
+  let t1 = 0;
+  let t2 = 0;
+  let dk = 0;
+  let k = 0;
+  let hx = 0;
+  let i = 0;
+  let j = 0;
+  let lx = 0;
+  hx = highWord(x) | 0;
+  lx = lowWord(x) >>> 0;
+  k = 0 | 0;
+  if (hx < 1048576) {
+    if (((hx & 2147483647) >>> 0 | lx >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+      return -e_log_two54 / e_log_zero;
+    }
+    if (hx < 0) {
+      return (x - x) / e_log_zero;
+    }
+    k = k - 54 | 0;
+    x = x * e_log_two54;
+    hx = highWord(x) | 0;
+  }
+  if (hx >= 2146435072) {
+    return x + x;
+  }
+  k = k + ((hx >> 20) - 1023) | 0;
+  hx = hx & 1048575 | 0;
+  i = hx + 614244 & 1048576 | 0;
+  x = withHighWord(x, hx | i ^ 1072693248 | 0);
+  k = k + (i >> 20) | 0;
+  f = x - 1;
+  if ((1048575 & 2 + hx) < 3) {
+    if (f == e_log_zero) {
+      if (k == 0) {
+        return e_log_zero;
+      } else {
+        dk = k;
+        return dk * e_log_ln2_hi + dk * e_log_ln2_lo;
+      }
+    }
+    R = f * f * (0.5 - 0.3333333333333333 * f);
+    if (k == 0) {
+      return f - R;
+    } else {
+      dk = k;
+      return dk * e_log_ln2_hi - (R - dk * e_log_ln2_lo - f);
+    }
+  }
+  s = f / (2 + f);
+  dk = k;
+  z = s * s;
+  i = hx - 398458 | 0;
+  w = z * z;
+  j = 440401 - hx | 0;
+  t1 = w * (e_log_Lg2 + w * (e_log_Lg4 + w * e_log_Lg6));
+  t2 = z * (e_log_Lg1 + w * (e_log_Lg3 + w * (e_log_Lg5 + w * e_log_Lg7)));
+  i = i | j | 0;
+  R = t2 + t1;
+  if (i > 0) {
+    hfsq = 0.5 * f * f;
+    if (k == 0) {
+      return f - (hfsq - s * (hfsq + R));
+    } else {
+      return dk * e_log_ln2_hi - (hfsq - (s * (hfsq + R) + dk * e_log_ln2_lo) - f);
+    }
+  } else {
+    if (k == 0) {
+      return f - s * (f - R);
+    } else {
+      return dk * e_log_ln2_hi - (s * (f - R) - dk * e_log_ln2_lo - f);
+    }
+  }
+}
+var e_log10_two54 = 18014398509481984;
+var e_log10_ivln10 = 0.4342944819032518;
+var e_log10_log10_2hi = 0.30102999566361177;
+var e_log10_log10_2lo = 3694239077158931e-28;
+var e_log10_zero = 0;
+function kernel___ieee754_log10(x) {
+  let y = 0;
+  let z = 0;
+  let i = 0;
+  let k = 0;
+  let hx = 0;
+  let lx = 0;
+  hx = highWord(x) | 0;
+  lx = lowWord(x) >>> 0;
+  k = 0 | 0;
+  if (hx < 1048576) {
+    if (((hx & 2147483647) >>> 0 | lx >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+      return -e_log10_two54 / e_log10_zero;
+    }
+    if (hx < 0) {
+      return (x - x) / e_log10_zero;
+    }
+    k = k - 54 | 0;
+    x = x * e_log10_two54;
+    hx = highWord(x) | 0;
+  }
+  if (hx >= 2146435072) {
+    return x + x;
+  }
+  k = k + ((hx >> 20) - 1023) | 0;
+  i = (k >>> 0 >>> 0 & 2147483648 >>> 0) >>> 0 >>> 31 | 0;
+  hx = hx & 1048575 | 1023 - i << 20 | 0;
+  y = k + i;
+  x = withHighWord(x, hx | 0);
+  z = y * e_log10_log10_2lo + e_log10_ivln10 * kernel___ieee754_log(x);
+  return z + y * e_log10_log10_2hi;
+}
+function kernel_sin(x) {
+  const y = s_sin_y;
+  const z = 0;
+  let n = 0;
+  let ix = 0;
+  ix = highWord(x) | 0;
+  ix = ix & 2147483647 | 0;
+  if (ix <= 1072243195) {
+    return kernel___kernel_sin(x, z, 0);
+  } else {
+    if (ix >= 2146435072) {
+      return x - x;
+    } else {
+      n = kernel___ieee754_rem_pio2(x, y) | 0;
+      switch (n & 3) {
+        case 0:
+          return kernel___kernel_sin(y[0], y[1], 1);
+        case 1:
+          return kernel___kernel_cos(y[0], y[1]);
+        case 2:
+          return -kernel___kernel_sin(y[0], y[1], 1);
+        default:
+          return -kernel___kernel_cos(y[0], y[1]);
+      }
+    }
+  }
+}
+function kernel_cos(x) {
+  const y = s_cos_y;
+  const z = 0;
+  let n = 0;
+  let ix = 0;
+  ix = highWord(x) | 0;
+  ix = ix & 2147483647 | 0;
+  if (ix <= 1072243195) {
+    return kernel___kernel_cos(x, z);
+  } else {
+    if (ix >= 2146435072) {
+      return x - x;
+    } else {
+      n = kernel___ieee754_rem_pio2(x, y) | 0;
+      switch (n & 3) {
+        case 0:
+          return kernel___kernel_cos(y[0], y[1]);
+        case 1:
+          return -kernel___kernel_sin(y[0], y[1], 1);
+        case 2:
+          return -kernel___kernel_cos(y[0], y[1]);
+        default:
+          return kernel___kernel_sin(y[0], y[1], 1);
+      }
+    }
+  }
+}
+function kernel_tan(x) {
+  const y = s_tan_y;
+  const z = 0;
+  let n = 0;
+  let ix = 0;
+  ix = highWord(x) | 0;
+  ix = ix & 2147483647 | 0;
+  if (ix <= 1072243195) {
+    return kernel___kernel_tan(x, z, 1);
+  } else {
+    if (ix >= 2146435072) {
+      return x - x;
+    } else {
+      n = kernel___ieee754_rem_pio2(x, y) | 0;
+      return kernel___kernel_tan(y[0], y[1], 1 - ((n & 1) << 1));
+    }
+  }
+}
+var e_asin_one = 1;
+var e_asin_huge = 1e300;
+var e_asin_pio2_hi = 1.5707963267948966;
+var e_asin_pio2_lo = 6123233995736766e-32;
+var e_asin_pio4_hi = 0.7853981633974483;
+var e_asin_pS0 = 0.16666666666666666;
+var e_asin_pS1 = -0.3255658186224009;
+var e_asin_pS2 = 0.20121253213486293;
+var e_asin_pS3 = -0.04005553450067941;
+var e_asin_pS4 = 7915349942898145e-19;
+var e_asin_pS5 = 3479331075960212e-20;
+var e_asin_qS1 = -2.403394911734414;
+var e_asin_qS2 = 2.0209457602335057;
+var e_asin_qS3 = -0.6882839716054533;
+var e_asin_qS4 = 0.07703815055590194;
+function kernel___ieee754_asin(x) {
+  let t = 0;
+  let w = 0;
+  let p = 0;
+  let q = 0;
+  let c = 0;
+  let r = 0;
+  let s = 0;
+  let hx = 0;
+  let ix = 0;
+  hx = highWord(x) | 0;
+  ix = hx & 2147483647 | 0;
+  if (ix >= 1072693248) {
+    if ((ix - 1072693248 | lowWord(x)) == 0) {
+      return x * e_asin_pio2_hi + x * e_asin_pio2_lo;
+    }
+    return (x - x) / (x - x);
+  } else {
+    if (ix < 1071644672) {
+      if (ix < 1044381696) {
+        if (e_asin_huge + x > e_asin_one) {
+          return x;
+        }
+      } else {
+        t = x * x;
+      }
+      p = t * (e_asin_pS0 + t * (e_asin_pS1 + t * (e_asin_pS2 + t * (e_asin_pS3 + t * (e_asin_pS4 + t * e_asin_pS5)))));
+      q = e_asin_one + t * (e_asin_qS1 + t * (e_asin_qS2 + t * (e_asin_qS3 + t * e_asin_qS4)));
+      w = p / q;
+      return x + x * w;
+    }
+  }
+  w = e_asin_one - Math.abs(x);
+  t = w * 0.5;
+  p = t * (e_asin_pS0 + t * (e_asin_pS1 + t * (e_asin_pS2 + t * (e_asin_pS3 + t * (e_asin_pS4 + t * e_asin_pS5)))));
+  q = e_asin_one + t * (e_asin_qS1 + t * (e_asin_qS2 + t * (e_asin_qS3 + t * e_asin_qS4)));
+  s = Math.sqrt(t);
+  if (ix >= 1072640819) {
+    w = p / q;
+    t = e_asin_pio2_hi - (2 * (s + s * w) - e_asin_pio2_lo);
+  } else {
+    w = s;
+    w = withLowWord(w, 0 | 0);
+    c = (t - w * w) / (s + w);
+    r = p / q;
+    p = 2 * s * r - (e_asin_pio2_lo - 2 * c);
+    q = e_asin_pio4_hi - 2 * w;
+    t = e_asin_pio4_hi - (p - q);
+  }
+  if (hx > 0) {
+    return t;
+  } else {
+    return -t;
+  }
+}
+var e_acos_one = 1;
+var e_acos_pi = 3.141592653589793;
+var e_acos_pio2_hi = 1.5707963267948966;
+var e_acos_pio2_lo = 6123233995736766e-32;
+var e_acos_pS0 = 0.16666666666666666;
+var e_acos_pS1 = -0.3255658186224009;
+var e_acos_pS2 = 0.20121253213486293;
+var e_acos_pS3 = -0.04005553450067941;
+var e_acos_pS4 = 7915349942898145e-19;
+var e_acos_pS5 = 3479331075960212e-20;
+var e_acos_qS1 = -2.403394911734414;
+var e_acos_qS2 = 2.0209457602335057;
+var e_acos_qS3 = -0.6882839716054533;
+var e_acos_qS4 = 0.07703815055590194;
+function kernel___ieee754_acos(x) {
+  let z = 0;
+  let p = 0;
+  let q = 0;
+  let r = 0;
+  let w = 0;
+  let s = 0;
+  let c = 0;
+  let df = 0;
+  let hx = 0;
+  let ix = 0;
+  hx = highWord(x) | 0;
+  ix = hx & 2147483647 | 0;
+  if (ix >= 1072693248) {
+    if ((ix - 1072693248 | lowWord(x)) == 0) {
+      if (hx > 0) {
+        return 0;
+      } else {
+        return e_acos_pi + 2 * e_acos_pio2_lo;
+      }
+    }
+    return (x - x) / (x - x);
+  }
+  if (ix < 1071644672) {
+    if (ix <= 1012924416) {
+      return e_acos_pio2_hi + e_acos_pio2_lo;
+    }
+    z = x * x;
+    p = z * (e_acos_pS0 + z * (e_acos_pS1 + z * (e_acos_pS2 + z * (e_acos_pS3 + z * (e_acos_pS4 + z * e_acos_pS5)))));
+    q = e_acos_one + z * (e_acos_qS1 + z * (e_acos_qS2 + z * (e_acos_qS3 + z * e_acos_qS4)));
+    r = p / q;
+    return e_acos_pio2_hi - (x - (e_acos_pio2_lo - x * r));
+  } else {
+    if (hx < 0) {
+      z = (e_acos_one + x) * 0.5;
+      p = z * (e_acos_pS0 + z * (e_acos_pS1 + z * (e_acos_pS2 + z * (e_acos_pS3 + z * (e_acos_pS4 + z * e_acos_pS5)))));
+      q = e_acos_one + z * (e_acos_qS1 + z * (e_acos_qS2 + z * (e_acos_qS3 + z * e_acos_qS4)));
+      s = Math.sqrt(z);
+      r = p / q;
+      w = r * s - e_acos_pio2_lo;
+      return e_acos_pi - 2 * (s + w);
+    } else {
+      z = (e_acos_one - x) * 0.5;
+      s = Math.sqrt(z);
+      df = s;
+      df = withLowWord(df, 0 | 0);
+      c = (z - df * df) / (s + df);
+      p = z * (e_acos_pS0 + z * (e_acos_pS1 + z * (e_acos_pS2 + z * (e_acos_pS3 + z * (e_acos_pS4 + z * e_acos_pS5)))));
+      q = e_acos_one + z * (e_acos_qS1 + z * (e_acos_qS2 + z * (e_acos_qS3 + z * e_acos_qS4)));
+      r = p / q;
+      w = r * s + c;
+      return 2 * (df + w);
+    }
+  }
+}
+var s_atan_atanhi = [
+  0.4636476090008061,
+  0.7853981633974483,
+  0.982793723247329,
+  1.5707963267948966
+];
+var s_atan_atanlo = [
+  22698777452961687e-33,
+  3061616997868383e-32,
+  13903311031230998e-33,
+  6123233995736766e-32
+];
+var s_atan_aT = [
+  0.3333333333333293,
+  -0.19999999999876483,
+  0.14285714272503466,
+  -0.11111110405462356,
+  0.09090887133436507,
+  -0.0769187620504483,
+  0.06661073137387531,
+  -0.058335701337905735,
+  0.049768779946159324,
+  -0.036531572744216916,
+  0.016285820115365782
+];
+var s_atan_one = 1;
+var s_atan_huge = 1e300;
+function kernel_atan(x) {
+  let w = 0;
+  let s1 = 0;
+  let s2 = 0;
+  let z = 0;
+  let ix = 0;
+  let hx = 0;
+  let id = 0;
+  hx = highWord(x) | 0;
+  ix = hx & 2147483647 | 0;
+  if (ix >= 1141899264) {
+    if (ix > 2146435072 || ix == 2146435072 && lowWord(x) != 0) {
+      return x + x;
+    }
+    if (hx > 0) {
+      return s_atan_atanhi[3] + s_atan_atanlo[3];
+    } else {
+      return -s_atan_atanhi[3] - s_atan_atanlo[3];
+    }
+  }
+  if (ix < 1071382528) {
+    if (ix < 1042284544) {
+      if (s_atan_huge + x > s_atan_one) {
+        return x;
+      }
+    }
+    id = -1 | 0;
+  } else {
+    x = Math.abs(x);
+    if (ix < 1072889856) {
+      if (ix < 1072037888) {
+        id = 0 | 0;
+        x = (2 * x - s_atan_one) / (2 + x);
+      } else {
+        id = 1 | 0;
+        x = (x - s_atan_one) / (x + s_atan_one);
+      }
+    } else {
+      if (ix < 1073971200) {
+        id = 2 | 0;
+        x = (x - 1.5) / (s_atan_one + 1.5 * x);
+      } else {
+        id = 3 | 0;
+        x = -1 / x;
+      }
+    }
+  }
+  z = x * x;
+  w = z * z;
+  s1 = z * (s_atan_aT[0] + w * (s_atan_aT[2] + w * (s_atan_aT[4] + w * (s_atan_aT[6] + w * (s_atan_aT[8] + w * s_atan_aT[10])))));
+  s2 = w * (s_atan_aT[1] + w * (s_atan_aT[3] + w * (s_atan_aT[5] + w * (s_atan_aT[7] + w * s_atan_aT[9]))));
+  if (id < 0) {
+    return x - x * (s1 + s2);
+  } else {
+    z = s_atan_atanhi[id] - (x * (s1 + s2) - s_atan_atanlo[id] - x);
+    return hx < 0 ? -z : z;
+  }
+}
+var e_atan2_tiny = 1e-300;
+var e_atan2_zero = 0;
+var e_atan2_pi_o_4 = 0.7853981633974483;
+var e_atan2_pi_o_2 = 1.5707963267948966;
+var e_atan2_pi = 3.141592653589793;
+var e_atan2_pi_lo = 12246467991473532e-32;
+function kernel___ieee754_atan2(y, x) {
+  let z = 0;
+  let k = 0;
+  let m = 0;
+  let hx = 0;
+  let hy = 0;
+  let ix = 0;
+  let iy = 0;
+  let lx = 0;
+  let ly = 0;
+  hx = highWord(x) | 0;
+  ix = hx & 2147483647 | 0;
+  lx = lowWord(x) >>> 0;
+  hy = highWord(y) | 0;
+  iy = hy & 2147483647 | 0;
+  ly = lowWord(y) >>> 0;
+  if ((ix >>> 0 | (lx >>> 0 | -lx >>> 0) >>> 0 >>> 31 >>> 0) >>> 0 >>> 0 > 2146435072 >>> 0 || (iy >>> 0 | (ly >>> 0 | -ly >>> 0) >>> 0 >>> 31 >>> 0) >>> 0 >>> 0 > 2146435072 >>> 0) {
+    return x + y;
+  }
+  if ((hx - 1072693248 >>> 0 | lx >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+    return kernel_atan(y);
+  }
+  m = hy >> 31 & 1 | hx >> 30 & 2 | 0;
+  if ((iy >>> 0 | ly >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+    switch (m) {
+      case 0:
+      case 1:
+        return y;
+      case 2:
+        return e_atan2_pi + e_atan2_tiny;
+      case 3:
+        return -e_atan2_pi - e_atan2_tiny;
+    }
+  }
+  if ((ix >>> 0 | lx >>> 0) >>> 0 >>> 0 == 0 >>> 0) {
+    return hy < 0 ? -e_atan2_pi_o_2 - e_atan2_tiny : e_atan2_pi_o_2 + e_atan2_tiny;
+  }
+  if (ix == 2146435072) {
+    if (iy == 2146435072) {
+      switch (m) {
+        case 0:
+          return e_atan2_pi_o_4 + e_atan2_tiny;
+        case 1:
+          return -e_atan2_pi_o_4 - e_atan2_tiny;
+        case 2:
+          return 3 * e_atan2_pi_o_4 + e_atan2_tiny;
+        case 3:
+          return -3 * e_atan2_pi_o_4 - e_atan2_tiny;
+      }
+    } else {
+      switch (m) {
+        case 0:
+          return e_atan2_zero;
+        case 1:
+          return -e_atan2_zero;
+        case 2:
+          return e_atan2_pi + e_atan2_tiny;
+        case 3:
+          return -e_atan2_pi - e_atan2_tiny;
+      }
+    }
+  }
+  if (iy == 2146435072) {
+    return hy < 0 ? -e_atan2_pi_o_2 - e_atan2_tiny : e_atan2_pi_o_2 + e_atan2_tiny;
+  }
+  k = iy - ix >> 20 | 0;
+  if (k > 60) {
+    z = e_atan2_pi_o_2 + 0.5 * e_atan2_pi_lo;
+  } else {
+    if (hx < 0 && k < -60) {
+      z = 0;
+    } else {
+      z = kernel_atan(Math.abs(y / x));
+    }
+  }
+  switch (m) {
+    case 0:
+      return z;
+    case 1:
+      z = withHighWord(z, highWord(z) ^ 2147483648 | 0);
+      return z;
+    case 2:
+      return e_atan2_pi - (z - e_atan2_pi_lo);
+    default:
+      return z - e_atan2_pi_lo - e_atan2_pi;
+  }
+}
+var e_rem_pio2_two_over_pi = [
+  10680707,
+  7228996,
+  1387004,
+  2578385,
+  16069853,
+  12639074,
+  9804092,
+  4427841,
+  16666979,
+  11263675,
+  12935607,
+  2387514,
+  4345298,
+  14681673,
+  3074569,
+  13734428,
+  16653803,
+  1880361,
+  10960616,
+  8533493,
+  3062596,
+  8710556,
+  7349940,
+  6258241,
+  3772886,
+  3769171,
+  3798172,
+  8675211,
+  12450088,
+  3874808,
+  9961438,
+  366607,
+  15675153,
+  9132554,
+  7151469,
+  3571407,
+  2607881,
+  12013382,
+  4155038,
+  6285869,
+  7677882,
+  13102053,
+  15825725,
+  473591,
+  9065106,
+  15363067,
+  6271263,
+  9264392,
+  5636912,
+  4652155,
+  7056368,
+  13614112,
+  10155062,
+  1944035,
+  9527646,
+  15080200,
+  6658437,
+  6231200,
+  6832269,
+  16767104,
+  5075751,
+  3212806,
+  1398474,
+  7579849,
+  6349435,
+  12618859
+];
+var e_rem_pio2_npio2_hw = [
+  1073291771,
+  1074340347,
+  1074977148,
+  1075388923,
+  1075800698,
+  1076025724,
+  1076231611,
+  1076437499,
+  1076643386,
+  1076849274,
+  1076971356,
+  1077074300,
+  1077177244,
+  1077280187,
+  1077383131,
+  1077486075,
+  1077589019,
+  1077691962,
+  1077794906,
+  1077897850,
+  1077968460,
+  1078019932,
+  1078071404,
+  1078122876,
+  1078174348,
+  1078225820,
+  1078277292,
+  1078328763,
+  1078380235,
+  1078431707,
+  1078483179,
+  1078534651
+];
+var e_rem_pio2_zero = 0;
+var e_rem_pio2_half = 0.5;
+var e_rem_pio2_two24 = 16777216;
+var e_rem_pio2_invpio2 = 0.6366197723675814;
+var e_rem_pio2_pio2_1 = 1.5707963267341256;
+var e_rem_pio2_pio2_1t = 6077100506506192e-26;
+var e_rem_pio2_pio2_2 = 6077100506303966e-26;
+var e_rem_pio2_pio2_2t = 20222662487959506e-37;
+var e_rem_pio2_pio2_3 = 20222662487111665e-37;
+var e_rem_pio2_pio2_3t = 84784276603689e-45;
+function kernel___ieee754_rem_pio2(x, y) {
+  let z = 0;
+  let w = 0;
+  let t = 0;
+  let r = 0;
+  let fn = 0;
+  const tx = e_rem_pio2_tx;
+  let e0 = 0;
+  let i = 0;
+  let j = 0;
+  let nx = 0;
+  let n = 0;
+  let ix = 0;
+  let hx = 0;
+  hx = highWord(x) | 0;
+  ix = hx & 2147483647 | 0;
+  if (ix <= 1072243195) {
+    y[0] = x;
+    y[1] = 0;
+    return 0 | 0;
+  }
+  if (ix < 1073928572) {
+    if (hx > 0) {
+      z = x - e_rem_pio2_pio2_1;
+      if (ix != 1073291771) {
+        y[0] = z - e_rem_pio2_pio2_1t;
+        y[1] = z - y[0] - e_rem_pio2_pio2_1t;
+      } else {
+        z = z - e_rem_pio2_pio2_2;
+        y[0] = z - e_rem_pio2_pio2_2t;
+        y[1] = z - y[0] - e_rem_pio2_pio2_2t;
+      }
+      return 1 | 0;
+    } else {
+      z = x + e_rem_pio2_pio2_1;
+      if (ix != 1073291771) {
+        y[0] = z + e_rem_pio2_pio2_1t;
+        y[1] = z - y[0] + e_rem_pio2_pio2_1t;
+      } else {
+        z = z + e_rem_pio2_pio2_2;
+        y[0] = z + e_rem_pio2_pio2_2t;
+        y[1] = z - y[0] + e_rem_pio2_pio2_2t;
+      }
+      return -1 | 0;
+    }
+  }
+  if (ix <= 1094263291) {
+    t = Math.abs(x);
+    n = t * e_rem_pio2_invpio2 + e_rem_pio2_half | 0 | 0;
+    fn = n;
+    r = t - fn * e_rem_pio2_pio2_1;
+    w = fn * e_rem_pio2_pio2_1t;
+    if (n < 32 && ix != e_rem_pio2_npio2_hw[n - 1]) {
+      y[0] = r - w;
+    } else {
+      j = ix >> 20 | 0;
+      y[0] = r - w;
+      i = j - (highWord(y[0]) >> 20 & 2047) | 0;
+      if (i > 16) {
+        t = r;
+        w = fn * e_rem_pio2_pio2_2;
+        r = t - w;
+        w = fn * e_rem_pio2_pio2_2t - (t - r - w);
+        y[0] = r - w;
+        i = j - (highWord(y[0]) >> 20 & 2047) | 0;
+        if (i > 49) {
+          t = r;
+          w = fn * e_rem_pio2_pio2_3;
+          r = t - w;
+          w = fn * e_rem_pio2_pio2_3t - (t - r - w);
+          y[0] = r - w;
+        }
+      }
+    }
+    y[1] = r - y[0] - w;
+    if (hx < 0) {
+      y[0] = -y[0];
+      y[1] = -y[1];
+      return -n | 0;
+    } else {
+      return n | 0;
+    }
+  }
+  if (ix >= 2146435072) {
+    y[0] = y[1] = x - x;
+    return 0 | 0;
+  }
+  z = withLowWord(z, lowWord(x) | 0);
+  e0 = (ix >> 20) - 1046 | 0;
+  z = withHighWord(z, ix - (e0 << 20) | 0);
+  for (i = 0 | 0; i < 2; i++) {
+    tx[i] = z | 0;
+    z = (z - tx[i]) * e_rem_pio2_two24;
+  }
+  tx[2] = z;
+  nx = 3 | 0;
+  while (tx[nx - 1] == e_rem_pio2_zero) {
+    nx--;
+  }
+  n = kernel___kernel_rem_pio2(tx, y, e0, nx, 2, e_rem_pio2_two_over_pi) | 0;
+  if (hx < 0) {
+    y[0] = -y[0];
+    y[1] = -y[1];
+    return -n | 0;
+  }
+  return n | 0;
+}
+var k_rem_pio2_init_jk = [2, 3, 4, 6];
+var k_rem_pio2_PIo2 = [
+  1.570796251296997,
+  7549789415861596e-23,
+  5390302529957765e-30,
+  3282003415807913e-37,
+  1270655753080676e-44,
+  12293330898111133e-52,
+  27337005381646456e-60,
+  21674168387780482e-67
+];
+var k_rem_pio2_zero = 0;
+var k_rem_pio2_one = 1;
+var k_rem_pio2_two24 = 16777216;
+var k_rem_pio2_twon24 = 5960464477539063e-23;
+function kernel___kernel_rem_pio2(x, y, e0, nx, prec, ipio2) {
+  let jz = 0;
+  let jx = 0;
+  let jv = 0;
+  let jp = 0;
+  let jk = 0;
+  let carry = 0;
+  let n = 0;
+  const iq = k_rem_pio2_iq;
+  let i = 0;
+  let j = 0;
+  let k = 0;
+  let m = 0;
+  let q0 = 0;
+  let ih = 0;
+  let z = 0;
+  let fw = 0;
+  const f = k_rem_pio2_f;
+  const fq = k_rem_pio2_fq;
+  const q = k_rem_pio2_q;
+  jk = k_rem_pio2_init_jk[prec] | 0;
+  jp = jk | 0;
+  jx = nx - 1 | 0;
+  jv = (e0 - 3) / 24 | 0 | 0;
+  if (jv < 0) {
+    jv = 0 | 0;
+  }
+  q0 = e0 - 24 * (jv + 1) | 0;
+  j = jv - jx | 0;
+  m = jx + jk | 0;
+  for (i = 0 | 0; i <= m; i++, j++) {
+    f[i] = j < 0 ? k_rem_pio2_zero : ipio2[j];
+  }
+  for (i = 0 | 0; i <= jk; i++) {
+    for (j = 0 | 0, fw = 0; j <= jx; j++) {
+      fw = fw + x[j] * f[jx + i - j];
+    }
+    q[i] = fw;
+  }
+  jz = jk | 0;
+  while (true) {
+    for (i = 0 | 0, j = jz | 0, z = q[jz]; j > 0; i++, j--) {
+      fw = k_rem_pio2_twon24 * z | 0;
+      iq[i] = z - k_rem_pio2_two24 * fw | 0 | 0;
+      z = q[j - 1] + fw;
+    }
+    z = kernel_scalbn(z, q0);
+    z = z - 8 * Math.floor(z * 0.125);
+    n = z | 0 | 0;
+    z = z - n;
+    ih = 0 | 0;
+    if (q0 > 0) {
+      i = iq[jz - 1] >> 24 - q0 | 0;
+      n = n + i | 0;
+      iq[jz - 1] = iq[jz - 1] - (i << 24 - q0) | 0;
+      ih = iq[jz - 1] >> 23 - q0 | 0;
+    } else {
+      if (q0 == 0) {
+        ih = iq[jz - 1] >> 23 | 0;
+      } else {
+        if (z >= 0.5) {
+          ih = 2 | 0;
+        }
+      }
+    }
+    if (ih > 0) {
+      n = n + 1 | 0;
+      carry = 0 | 0;
+      for (i = 0 | 0; i < jz; i++) {
+        j = iq[i] | 0;
+        if (carry == 0) {
+          if (j != 0) {
+            carry = 1 | 0;
+            iq[i] = 16777216 - j | 0;
+          }
+        } else {
+          iq[i] = 16777215 - j | 0;
+        }
+      }
+      if (q0 > 0) {
+        switch (q0) {
+          case 1:
+            iq[jz - 1] = iq[jz - 1] & 8388607 | 0;
+            break;
+          case 2:
+            iq[jz - 1] = iq[jz - 1] & 4194303 | 0;
+            break;
+        }
+      }
+      if (ih == 2) {
+        z = k_rem_pio2_one - z;
+        if (carry != 0) {
+          z = z - kernel_scalbn(k_rem_pio2_one, q0);
+        }
+      }
+    }
+    if (z == k_rem_pio2_zero) {
+      j = 0 | 0;
+      for (i = jz - 1 | 0; i >= jk; i--) {
+        j = j | iq[i] | 0;
+      }
+      if (j == 0) {
+        for (k = 1 | 0; iq[jk - k] == 0; k++) {
+        }
+        for (i = jz + 1 | 0; i <= jz + k; i++) {
+          f[jx + i] = ipio2[jv + i];
+          for (j = 0 | 0, fw = 0; j <= jx; j++) {
+            fw = fw + x[j] * f[jx + i - j];
+          }
+          q[i] = fw;
+        }
+        jz = jz + k | 0;
+        continue;
+      }
+    }
+    break;
+  }
+  if (z == 0) {
+    jz = jz - 1 | 0;
+    q0 = q0 - 24 | 0;
+    while (iq[jz] == 0) {
+      jz--;
+      q0 = q0 - 24 | 0;
+    }
+  } else {
+    z = kernel_scalbn(z, -q0);
+    if (z >= k_rem_pio2_two24) {
+      fw = k_rem_pio2_twon24 * z | 0;
+      iq[jz] = z - k_rem_pio2_two24 * fw | 0 | 0;
+      jz = jz + 1 | 0;
+      q0 = q0 + 24 | 0;
+      iq[jz] = fw | 0 | 0;
+    } else {
+      iq[jz] = z | 0 | 0;
+    }
+  }
+  fw = kernel_scalbn(k_rem_pio2_one, q0);
+  for (i = jz | 0; i >= 0; i--) {
+    q[i] = fw * iq[i];
+    fw = fw * k_rem_pio2_twon24;
+  }
+  for (i = jz | 0; i >= 0; i--) {
+    for (fw = 0, k = 0 | 0; k <= jp && k <= jz - i; k++) {
+      fw = fw + k_rem_pio2_PIo2[k] * q[i + k];
+    }
+    fq[jz - i] = fw;
+  }
+  switch (prec) {
+    case 0:
+      fw = 0;
+      for (i = jz | 0; i >= 0; i--) {
+        fw = fw + fq[i];
+      }
+      y[0] = ih == 0 ? fw : -fw;
+      break;
+    case 1:
+    case 2:
+      fw = 0;
+      for (i = jz | 0; i >= 0; i--) {
+        fw = fw + fq[i];
+      }
+      y[0] = ih == 0 ? fw : -fw;
+      fw = fq[0] - fw;
+      for (i = 1 | 0; i <= jz; i++) {
+        fw = fw + fq[i];
+      }
+      y[1] = ih == 0 ? fw : -fw;
+      break;
+    case 3:
+      for (i = jz | 0; i > 0; i--) {
+        fw = fq[i - 1] + fq[i];
+        fq[i] = fq[i] + (fq[i - 1] - fw);
+        fq[i - 1] = fw;
+      }
+      for (i = jz | 0; i > 1; i--) {
+        fw = fq[i - 1] + fq[i];
+        fq[i] = fq[i] + (fq[i - 1] - fw);
+        fq[i - 1] = fw;
+      }
+      for (fw = 0, i = jz | 0; i >= 2; i--) {
+        fw = fw + fq[i];
+      }
+      if (ih == 0) {
+        y[0] = fq[0];
+        y[1] = fq[1];
+        y[2] = fw;
+      } else {
+        y[0] = -fq[0];
+        y[1] = -fq[1];
+        y[2] = -fw;
+      }
+      break;
+  }
+  return n & 7 | 0;
+}
+var k_sin_half = 0.5;
+var k_sin_S1 = -0.16666666666666632;
+var k_sin_S2 = 0.00833333333332249;
+var k_sin_S3 = -1984126982985795e-19;
+var k_sin_S4 = 27557313707070068e-22;
+var k_sin_S5 = -25050760253406863e-24;
+var k_sin_S6 = 158969099521155e-24;
+function kernel___kernel_sin(x, y, iy) {
+  let z = 0;
+  let r = 0;
+  let v = 0;
+  let ix = 0;
+  ix = highWord(x) & 2147483647 | 0;
+  if (ix < 1044381696) {
+    if ((x | 0) == 0) {
+      return x;
+    }
+  }
+  z = x * x;
+  v = z * x;
+  r = k_sin_S2 + z * (k_sin_S3 + z * (k_sin_S4 + z * (k_sin_S5 + z * k_sin_S6)));
+  if (iy == 0) {
+    return x + v * (k_sin_S1 + z * r);
+  } else {
+    return x - (z * (k_sin_half * y - v * r) - y - v * k_sin_S1);
+  }
+}
+var k_cos_one = 1;
+var k_cos_C1 = 0.0416666666666666;
+var k_cos_C2 = -0.001388888888887411;
+var k_cos_C3 = 2480158728947673e-20;
+var k_cos_C4 = -27557314351390663e-23;
+var k_cos_C5 = 2087572321298175e-24;
+var k_cos_C6 = -11359647557788195e-27;
+function kernel___kernel_cos(x, y) {
+  let a = 0;
+  let hz = 0;
+  let z = 0;
+  let r = 0;
+  let qx = 0;
+  let ix = 0;
+  ix = highWord(x) & 2147483647 | 0;
+  if (ix < 1044381696) {
+    if ((x | 0) == 0) {
+      return k_cos_one;
+    }
+  }
+  z = x * x;
+  r = z * (k_cos_C1 + z * (k_cos_C2 + z * (k_cos_C3 + z * (k_cos_C4 + z * (k_cos_C5 + z * k_cos_C6)))));
+  if (ix < 1070805811) {
+    return k_cos_one - (0.5 * z - (z * r - x * y));
+  } else {
+    if (ix > 1072234496) {
+      qx = 0.28125;
+    } else {
+      qx = withHighWord(qx, ix - 2097152 | 0);
+      qx = withLowWord(qx, 0 | 0);
+    }
+    hz = 0.5 * z - qx;
+    a = k_cos_one - qx;
+    return a - (hz - (z * r - x * y));
+  }
+}
+var k_tan_xxx = [
+  0.3333333333333341,
+  0.13333333333320124,
+  0.05396825397622605,
+  0.021869488294859542,
+  0.0088632398235993,
+  0.0035920791075913124,
+  0.0014562094543252903,
+  5880412408202641e-19,
+  2464631348184699e-19,
+  7817944429395571e-20,
+  7140724913826082e-20,
+  -18558637485527546e-21,
+  2590730518636337e-20,
+  1,
+  0.7853981633974483,
+  3061616997868383e-32
+];
+function kernel___kernel_tan(x, y, iy) {
+  let z = 0;
+  let r = 0;
+  let v = 0;
+  let w = 0;
+  let s = 0;
+  let ix = 0;
+  let hx = 0;
+  hx = highWord(x) | 0;
+  ix = hx & 2147483647 | 0;
+  if (ix < 1043333120) {
+    if ((x | 0) == 0) {
+      if ((ix | lowWord(x) | iy + 1) == 0) {
+        return k_tan_xxx[13] / Math.abs(x);
+      } else {
+        if (iy == 1) {
+          return x;
+        } else {
+          let a = 0;
+          let t = 0;
+          z = w = x + y;
+          z = withLowWord(z, 0 | 0);
+          v = y - (z - x);
+          t = a = -k_tan_xxx[13] / w;
+          t = withLowWord(t, 0 | 0);
+          s = k_tan_xxx[13] + t * z;
+          return t + a * (s + t * v);
+        }
+      }
+    }
+  }
+  if (ix >= 1072010280) {
+    if (hx < 0) {
+      x = -x;
+      y = -y;
+    }
+    z = k_tan_xxx[14] - x;
+    w = k_tan_xxx[15] - y;
+    x = z + w;
+    y = 0;
+  }
+  z = x * x;
+  w = z * z;
+  r = k_tan_xxx[1] + w * (k_tan_xxx[3] + w * (k_tan_xxx[5] + w * (k_tan_xxx[7] + w * (k_tan_xxx[9] + w * k_tan_xxx[11]))));
+  v = z * (k_tan_xxx[2] + w * (k_tan_xxx[4] + w * (k_tan_xxx[6] + w * (k_tan_xxx[8] + w * (k_tan_xxx[10] + w * k_tan_xxx[12])))));
+  s = z * x;
+  r = y + z * (s * (r + v) + y);
+  r = r + k_tan_xxx[0] * s;
+  w = x + r;
+  if (ix >= 1072010280) {
+    v = iy;
+    return (1 - (hx >> 30 & 2)) * (v - 2 * (x - (w * w / (w + v) - r)));
+  }
+  if (iy == 1) {
+    return w;
+  } else {
+    let a = 0;
+    let t = 0;
+    z = w;
+    z = withLowWord(z, 0 | 0);
+    v = r - (z - x);
+    t = a = -1 / w;
+    t = withLowWord(t, 0 | 0);
+    s = 1 + t * z;
+    return t + a * (s + t * v);
+  }
+}
+var s_scalbn_two54 = 18014398509481984;
+var s_scalbn_twom54 = 5551115123125783e-32;
+var s_scalbn_huge = 1e300;
+var s_scalbn_tiny = 1e-300;
+function kernel_scalbn(x, n) {
+  let k = 0;
+  let hx = 0;
+  let lx = 0;
+  hx = highWord(x) | 0;
+  lx = lowWord(x) | 0;
+  k = (hx & 2146435072) >> 20 | 0;
+  if (k == 0) {
+    if ((lx | hx & 2147483647) == 0) {
+      return x;
+    }
+    x = x * s_scalbn_two54;
+    hx = highWord(x) | 0;
+    k = ((hx & 2146435072) >> 20) - 54 | 0;
+    if (n < -5e4) {
+      return s_scalbn_tiny * x;
+    }
+  }
+  if (k == 2047) {
+    return x + x;
+  }
+  k = k + n | 0;
+  if (k > 2046) {
+    return s_scalbn_huge * copysign(s_scalbn_huge, x);
+  }
+  if (k > 0) {
+    x = withHighWord(
+      x,
+      ((hx >>> 0 & 2148532223 >>> 0) >>> 0 >>> 0 | k << 20 >>> 0) >>> 0 | 0
+    );
+    return x;
+  }
+  if (k <= -54) {
+    if (n > 5e4) {
+      return s_scalbn_huge * copysign(s_scalbn_huge, x);
+    } else {
+      return s_scalbn_tiny * copysign(s_scalbn_tiny, x);
+    }
+  }
+  k = k + 54 | 0;
+  x = withHighWord(
+    x,
+    ((hx >>> 0 & 2148532223 >>> 0) >>> 0 >>> 0 | k << 20 >>> 0) >>> 0 | 0
+  );
+  return x * s_scalbn_twom54;
+}
+function pow(x, y) {
+  return Math.fround(
+    x == 1 || x == -1 && !Number.isFinite(y) && !Number.isNaN(y) ? 1 : kernel___ieee754_pow(x, y)
+  );
+}
+function exp(x) {
+  return Math.fround(kernel___ieee754_exp(x));
+}
+function log(x) {
+  return Math.fround(kernel___ieee754_log(x));
+}
+function log10(x) {
+  return Math.fround(kernel___ieee754_log10(x));
+}
+function sin(x) {
+  return Math.fround(kernel_sin(x));
+}
+function cos(x) {
+  return Math.fround(kernel_cos(x));
+}
+function tan(x) {
+  return Math.fround(kernel_tan(x));
+}
+function asin(x) {
+  return Math.fround(kernel___ieee754_asin(x));
+}
+function acos(x) {
+  return Math.fround(kernel___ieee754_acos(x));
+}
+function atan(x) {
+  return Math.fround(kernel_atan(x));
+}
+function atan2(x, y) {
+  return Math.fround(kernel___ieee754_atan2(x, y));
+}
+
+// ../packages/neoscript-runtime/src/neoscript/math/extended-math.ts
+function clamp(value, min, max) {
+  if (value < min) return min;
+  if (value > max) return max;
+  return value;
+}
+function repeat(t, length) {
+  const quotient = Math.fround(t / length);
+  if (!Number.isFinite(quotient)) return NaN;
+  const multiple = Math.fround(Math.floor(quotient) * length);
+  if (!Number.isFinite(multiple)) return NaN;
+  return clamp(Math.fround(t - multiple), 0, length);
+}
+function requireRepeatDomain(name, t, length) {
+  if (!Number.isFinite(t)) {
+    throw new NSGetterRuntimeError(`Math.${name} requires finite t.`, {
+      errorClassId: NEO_ERROR_CLASS_IDS.NeoArgumentError
+    });
+  }
+  if (!Number.isFinite(length)) {
+    throw new NSGetterRuntimeError(`Math.${name} requires finite length.`, {
+      errorClassId: NEO_ERROR_CLASS_IDS.NeoArgumentError
+    });
+  }
+  if (length <= 0) {
+    throw new NSGetterRuntimeError(`Math.${name} requires length > 0.`, {
+      errorClassId: NEO_ERROR_CLASS_IDS.NeoArgumentError
+    });
+  }
+}
+function evaluateExtendedMath(op, a, b = 0, c = 0) {
+  switch (op) {
+    case "pow":
+      return pow(a, b);
+    case "exp":
+      return exp(a);
+    case "log":
+      return log(a);
+    case "log10":
+      return log10(a);
+    case "sin":
+      return sin(a);
+    case "cos":
+      return cos(a);
+    case "tan":
+      return tan(a);
+    case "asin":
+      return asin(a);
+    case "acos":
+      return acos(a);
+    case "atan":
+      return atan(a);
+    case "atan2":
+      return atan2(a, b);
+    case "lerp":
+      return Math.fround(a + Math.fround(Math.fround(b - a) * clamp(c, 0, 1)));
+    case "inverselerp":
+      return a === b ? 0 : clamp(Math.fround(Math.fround(c - a) / Math.fround(b - a)), 0, 1);
+    case "movetowards": {
+      const delta = Math.fround(b - a);
+      if (Math.abs(delta) <= c) return b;
+      const sign = delta >= 0 ? 1 : -1;
+      return Math.fround(a + Math.fround(sign * c));
+    }
+    case "repeat":
+      requireRepeatDomain("Repeat", a, b);
+      return repeat(a, b);
+    case "pingpong": {
+      requireRepeatDomain("PingPong", a, b);
+      const period = Math.fround(2 * b);
+      if (!Number.isFinite(period)) return NaN;
+      return Math.fround(b - Math.abs(Math.fround(repeat(a, period) - b)));
+    }
+    default:
+      throw new NSGetterRuntimeError(`Unknown extended math op '${op}'.`);
+  }
+}
+
 // ../packages/neoscript-runtime/src/neoscript/tuple-handle-identity.ts
 var TupleHandleIdentity = class {
   objects = /* @__PURE__ */ new WeakMap();
@@ -23244,6 +25287,7 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
   const requestedWrites = [];
   const runtimeCtx = withEvaluationRuntime(ctx, requestedWrites);
   checkDeadline(runtimeCtx);
+  const randomDrawCheckpoint = runtimeCtx.__executionState?.randomDraws ?? 0;
   const writes = runtimeCtx.__executionState?.writes ?? requestedWrites;
   const writeCheckpoint = writes.length;
   const creationCheckpoint = sessionCreationCheckpoint(runtimeCtx);
@@ -23368,6 +25412,8 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
     }
     rejectEscapedLoopTransfer(result, "NeoScript getter");
   } catch (error) {
+    if (error instanceof NSGetterRuntimeError && runtimeCtx.randomIdentity !== void 0 && isPendingId(runtimeCtx.randomIdentity) && (runtimeCtx.__executionState?.randomDraws ?? 0) > randomDrawCheckpoint)
+      error.provisionalRandomFailure = true;
     finalizeConstructorAllocations(
       runtimeCtx,
       void 0,
@@ -23525,6 +25571,10 @@ function withEvaluationRuntime(ctx, writes) {
     __dirtyRuntimeSets: ctx.__dirtyRuntimeSets ?? /* @__PURE__ */ new Set(),
     __runtimeReferenceRemap: referenceRemap,
     __executionState: ctx.__executionState ?? {
+      randomDraws: 0,
+      random: ctx.random,
+      randomIdentity: ctx.randomIdentity,
+      randomSource: ctx.randomSource,
       exceptionHandlers: [],
       activeScopes: [],
       caughtErrors: [],
@@ -25903,6 +27953,9 @@ function keepAssignedCollectionValues(value, targetTypeInfo, ctx) {
   }
 }
 function replaceRowValue(row, value, receiver, ctx) {
+  if (row.value !== value) {
+    (ctx.__executionState?.random ?? ctx.random ?? ctx.vm.databaseVM?.random)?.forgetInstance(row.id);
+  }
   const indexes4 = ctx.__indexes;
   if (indexes4 === void 0 || ctx.__runtimeSessionValues?.get(row.id) !== row || !indexes4.indexedRowIds.has(row.id)) {
     row.value = value;
@@ -28081,7 +30134,12 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       if (member.kind === 13 /* Function */) {
         const systemResult = evaluateSystemNative(
           member.id,
-          { receiver: innerThis, args, typeArguments },
+          {
+            receiverKind: pointer.receiver.kind,
+            receiver: innerThis,
+            args,
+            typeArguments
+          },
           ctx
         );
         if (systemResult.handled) return systemResult.value;
@@ -28452,6 +30510,7 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
         const systemResult = evaluateSystemNative(
           member.id,
           {
+            receiverKind: isStaticMember(member) ? "static" : "instance",
             receiver,
             args,
             typeArguments: calleeTypeArguments(void 0, member, ctx)
@@ -29965,27 +32024,31 @@ function readDeclarationDefault(member, ctx) {
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
     try {
-      const root = buildDefaultMemberValue({
-        document: document2,
-        projectId: ctx.vm.project.id,
-        member,
-        createdValues: created,
-        initEvaluator: (child, init, sourceValueId, genericEnv = /* @__PURE__ */ new Map()) => withConstructionGenericSlots(
-          child,
-          ctx,
-          genericEnv,
-          () => evaluateInitializerInContext(
-            init,
+      const root = withContentRandom(
+        ctx,
+        member.id,
+        () => buildDefaultMemberValue({
+          document: document2,
+          projectId: ctx.vm.project.id,
+          member,
+          createdValues: created,
+          initEvaluator: (child, init, sourceValueId, genericEnv = /* @__PURE__ */ new Map()) => withConstructionGenericSlots(
             child,
             ctx,
-            created,
-            [],
-            sourceValueId,
-            void 0,
-            genericEnv
+            genericEnv,
+            () => evaluateInitializerInContext(
+              init,
+              child,
+              ctx,
+              created,
+              [],
+              sourceValueId,
+              void 0,
+              genericEnv
+            )
           )
-        )
-      });
+        })
+      );
       stageConstructedRows([root, ...created], ctx);
       if (known?.constant === true) known.root = root.id;
       return {
@@ -30819,6 +32882,72 @@ var getAreaNative = (call, ctx) => {
   }
   return null;
 };
+function randomNative(memberId) {
+  return (call, ctx) => {
+    if (memberId === NEO_RANDOM_IDS.ValidateSeed) {
+      validateRandomSeed(randomNumberArg(call.args[0], "seed"));
+      return null;
+    }
+    let row = null;
+    if (call.receiverKind === "instance") {
+      if (call.receiver === null || call.receiver === void 0)
+        throw new NSGetterRuntimeError("NeoRandom instance receiver is null.", {
+          errorClassId: NEO_ERROR_CLASS_IDS.NeoNullReferenceError
+        });
+      row = trackedRowForValueReference(call.receiver, ctx);
+      if (row === null || classIdForValueRow(row, ctx) !== NEO_RANDOM_IDS.class)
+        throw new NSGetterRuntimeError(
+          "NeoRandom requires a NeoRandom instance receiver."
+        );
+    }
+    const owner = randomForContext(ctx);
+    let random = owner;
+    if (row !== null) {
+      if (typeof row.value !== "object" || row.value === null)
+        throw new NSGetterRuntimeError(
+          "NeoRandom instance has no object value."
+        );
+      const id = ctx.__runtimeSessionValues?.has(row.id) === true ? void 0 : row.id;
+      const existing = owner.findInstance(row.value, id);
+      if (existing !== void 0) random = existing;
+      else {
+        const seed = dispatchSchemaMember(row.value, "_constructorSeed", ctx);
+        if (seed.kind !== "ok")
+          throw new NSGetterRuntimeError(
+            "NeoRandom constructor seed is missing."
+          );
+        random = owner.addInstance(
+          row.value,
+          id,
+          randomNumberArg(seed.value, "seed")
+        );
+      }
+    }
+    if (memberId === NEO_RANDOM_IDS.GetSeed || memberId === NEO_RANDOM_IDS.SetSeed) {
+      const key = row === null ? NEO_RANDOM_IDS.Seed : `${NEO_RANDOM_IDS.Seed}:${row.id}`;
+      if (memberId === NEO_RANDOM_IDS.GetSeed) {
+        if (!owner.isContentScope) {
+          ctx.__getterReads?.add(key);
+          ctx.valueDependencies?.add(key);
+        }
+        return random.seed;
+      }
+      random.seed = randomNumberArg(call.args[0], "seed");
+      if (!owner.isContentScope) ctx.__getterSubscriptions?.noteValueWrite(key);
+      if (random !== owner) owner.noteSeedWrite(key);
+      return null;
+    }
+    const before = random.drawCount;
+    try {
+      if (memberId === NEO_RANDOM_IDS.Value) return random.value();
+      const min = randomNumberArg(call.args[0], "Range min");
+      const max = randomNumberArg(call.args[1], "Range max");
+      return memberId === NEO_RANDOM_IDS.RangeInt ? random.rangeInt(min, max) : random.rangeFloat(min, max);
+    } finally {
+      ctx.__executionState.randomDraws += random.drawCount - before;
+    }
+  };
+}
 var SYSTEM_NATIVE_HANDLERS = new Map([
   [
     NEO_OBJECT_GRID_MEMBER_IDS.GetCell,
@@ -30889,6 +33018,9 @@ var SYSTEM_NATIVE_HANDLERS = new Map([
   ],
   [NEO_GET_AREA_MEMBER_IDS.NeoObjectBase, getAreaNative],
   [NEO_GET_AREA_MEMBER_IDS.NeoTile, getAreaNative],
+  ...[...NEO_RANDOM_NATIVE_MEMBER_IDS].map(
+    (id) => [id, randomNative(id)]
+  ),
   ...[...NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS].map(
     (id) => [id, cellPatternNative(id)]
   )
@@ -31145,7 +33277,23 @@ var NS_MATH_OP_NAMES = {
   truncate: "Truncate",
   abs: "Abs",
   sign: "Sign",
-  sqrt: "Sqrt"
+  sqrt: "Sqrt",
+  pow: "Pow",
+  exp: "Exp",
+  log: "Log",
+  log10: "Log10",
+  sin: "Sin",
+  cos: "Cos",
+  tan: "Tan",
+  asin: "Asin",
+  acos: "Acos",
+  atan: "Atan",
+  atan2: "Atan2",
+  lerp: "Lerp",
+  inverselerp: "InverseLerp",
+  movetowards: "MoveTowards",
+  repeat: "Repeat",
+  pingpong: "PingPong"
 };
 var DOUBLE_INTEGRAL_MAGNITUDE = 2 ** 53;
 function mathArgPointer(info, index, fn) {
@@ -31157,6 +33305,53 @@ function mathArgPointer(info, index, fn) {
   }
   return pointer;
 }
+function randomForContext(ctx) {
+  const state = ctx.__executionState;
+  if (state === void 0)
+    throw new NSGetterRuntimeError(
+      "NeoRandom requires an initialized evaluation runtime."
+    );
+  if (state.random !== void 0) return state.random;
+  if (state.randomSource !== void 0)
+    return state.random = state.randomSource();
+  if (state.randomIdentity !== void 0)
+    return state.random = new NeoRandom(state.randomIdentity);
+  return state.random = ctx.random ?? ctx.vm.databaseVM?.random ?? new NeoRandom();
+}
+function withContentRandom(ctx, identity2, evaluate) {
+  const state = ctx.__executionState;
+  if (state === void 0)
+    throw new NSGetterRuntimeError(
+      "NeoRandom requires an initialized evaluation runtime."
+    );
+  const draws = state.randomDraws;
+  try {
+    if (state.random !== void 0)
+      return state.random.withIdentity(identity2, evaluate);
+    const previous = state.randomIdentity;
+    const source = state.randomSource;
+    return withContentRandomSource(state, identity2, (randomSource) => {
+      state.randomSource = randomSource;
+      state.randomIdentity = identity2;
+      try {
+        return evaluate();
+      } finally {
+        state.randomIdentity = previous;
+        state.randomSource = source;
+        state.random = void 0;
+      }
+    });
+  } finally {
+    state.randomDraws = draws;
+  }
+}
+function randomNumberArg(value, label) {
+  if (typeof value !== "number")
+    throw new NSGetterRuntimeError(`NeoRandom.${label} must be numeric.`, {
+      errorClassId: NEO_ERROR_CLASS_IDS.NeoArgumentError
+    });
+  return value;
+}
 function mathNumberArg(value, fn) {
   if (value === null || value === void 0) {
     throw new NSGetterRuntimeError(`Math.${fn} argument is null.`, {
@@ -31257,6 +33452,49 @@ function evalMathOp(info, scope, ctx) {
       if (value > 0) return 1;
       if (value < 0) return -1;
       return 0;
+    case "exp":
+    case "log":
+    case "log10":
+    case "sin":
+    case "cos":
+    case "tan":
+    case "asin":
+    case "acos":
+    case "atan":
+      return evaluateExtendedMath(info.op, Math.fround(value));
+    case "pow":
+    case "atan2":
+    case "repeat":
+    case "pingpong":
+      return evaluateExtendedMath(
+        info.op,
+        Math.fround(value),
+        Math.fround(
+          mathNumberArg(
+            evalPointer(mathArgPointer(info, 1, fn), scope, ctx),
+            fn
+          )
+        )
+      );
+    case "lerp":
+    case "inverselerp":
+    case "movetowards":
+      return evaluateExtendedMath(
+        info.op,
+        Math.fround(value),
+        Math.fround(
+          mathNumberArg(
+            evalPointer(mathArgPointer(info, 1, fn), scope, ctx),
+            fn
+          )
+        ),
+        Math.fround(
+          mathNumberArg(
+            evalPointer(mathArgPointer(info, 2, fn), scope, ctx),
+            fn
+          )
+        )
+      );
     case "sqrt":
       return Math.fround(Math.sqrt(value));
   }
@@ -31268,6 +33506,25 @@ function evalDecimalMathOp(info, fn, scope, ctx) {
   );
   try {
     switch (info.op) {
+      case "pow":
+      case "exp":
+      case "log":
+      case "log10":
+      case "sin":
+      case "cos":
+      case "tan":
+      case "asin":
+      case "acos":
+      case "atan":
+      case "atan2":
+      case "lerp":
+      case "inverselerp":
+      case "movetowards":
+      case "repeat":
+      case "pingpong":
+        throw new NSGetterRuntimeError(
+          `Math.${fn} does not accept decimal arguments.`
+        );
       case "min":
         return minDecimalStrings(
           value,
@@ -35389,6 +37646,8 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
   const preparedArgumentScopes = prepareConstructorArgumentScopes(
     record4,
     argumentValues,
+    // Base arguments run before a receiver exists, but still belong to the
+    // constructed class's generic scope rather than the caller's.
     {
       ...bindThisValue(ctx, null),
       __initializerGenericEnv: descriptor.instanceEnv
@@ -37234,7 +39493,7 @@ var SourceText = class {
     return this.lineStarts.length;
   }
   positionAt(rawOffset) {
-    const offset = clamp(rawOffset, 0, this.text.length);
+    const offset = clamp2(rawOffset, 0, this.text.length);
     const previousLine = this.#lastPositionLine;
     const previousStart = this.lineStarts[previousLine];
     const nextStart = this.lineStarts[previousLine + 1];
@@ -37256,11 +39515,11 @@ var SourceText = class {
     };
   }
   offsetAt(position) {
-    const line = clamp(position.line, 0, this.lineStarts.length - 1);
+    const line = clamp2(position.line, 0, this.lineStarts.length - 1);
     const start = this.lineStarts[line] ?? 0;
     const next = this.lineStarts[line + 1] ?? this.text.length;
     const rawEnd = next > start && this.text.charCodeAt(next - 1) === 10 ? next - 1 : next;
-    return clamp(start + position.character, start, rawEnd);
+    return clamp2(start + position.character, start, rawEnd);
   }
   range(start, end) {
     return {
@@ -37280,7 +39539,7 @@ var SourceText = class {
     return this.text.slice(start, withoutCarriageReturn);
   }
 };
-function clamp(value, minimum, maximum) {
+function clamp2(value, minimum, maximum) {
   return Math.max(minimum, Math.min(maximum, value));
 }
 
@@ -39577,6 +41836,7 @@ function evaluateInitializerMaterialization(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   const evaluated = args.evaluateInitializer({
+    randomSource: args.randomSource,
     genericEnv: args.genericEnv,
     init: args.init,
     member: args.member,
@@ -39656,6 +41916,7 @@ function finalizeMaterializedRoot(args) {
 }
 function materializeInitializerValue(args) {
   const { evaluated, createdValues, storageKeyDeclarations } = evaluateInitializerMaterialization({
+    randomSource: args.randomSource,
     evaluateInitializer: args.evaluateInitializer,
     init: args.row.init,
     member: args.member,
@@ -39706,11 +41967,19 @@ function materializeInitializerValue(args) {
   return {
     root,
     createdValues,
+    snapshot: evaluated.snapshot,
     pinnedRootSchemaKeys: evaluated.pinnedRootSchemaKeys ?? /* @__PURE__ */ new Set(),
     pinnedSchemaKeysByValueId: evaluated.pinnedSchemaKeysByValueId ?? /* @__PURE__ */ new Map()
   };
 }
 function materializeMemberDefaultValue(args) {
+  if (args.randomSource === void 0)
+    return withContentRandomSource(
+      args.document,
+      args.randomIdentity ?? args.envelope.id,
+      (randomSource2) => materializeMemberDefaultValue({ ...args, randomSource: randomSource2 })
+    );
+  const randomSource = args.randomSource;
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   const declarationArguments = (member, init, sourceValueId) => {
@@ -39792,6 +42061,8 @@ function materializeMemberDefaultValue(args) {
     // A declaration default may itself be init-backed one level down (P43 §2),
     // and those nested initializers must evaluate against the same document.
     initEvaluator: (member, init, sourceValueId, genericEnv) => args.evaluateInitializer({
+      randomSource,
+      randomIdentity: args.randomIdentity ?? args.envelope.id,
       genericEnv,
       storageKeyDeclarations,
       init,
@@ -41202,6 +43473,12 @@ function materializationReadTracking(recorder) {
   return { readTracking, trackMaterialization };
 }
 function expandStoredInstance(args) {
+  if (args.randomSource === void 0)
+    return withContentRandomSource(
+      args.document,
+      args.instanceRoot.id,
+      (randomSource2) => expandStoredInstance({ ...args, randomSource: randomSource2 })
+    );
   const { readTracking, trackMaterialization } = materializationReadTracking(
     args.readRecorder
   );
@@ -41213,6 +43490,7 @@ function expandStoredInstance(args) {
     );
   }
   const instanceRoot = literalRow(args.instanceRoot);
+  const randomSource = args.randomSource;
   const classId = rowClassId(rootMember, instanceRoot);
   const schemaIndex = projectSchemaIndexFor(args.document);
   const schemaClass2 = schemaIndex.class(classId);
@@ -41307,6 +43585,7 @@ function expandStoredInstance(args) {
     return trackMaterialization(
       () => args.materializeInitializerValue({
         evaluateInitializer: args.evaluateInitializer,
+        randomSource,
         document: args.document,
         member: replayMember,
         row: { ...envelope, init },
@@ -41323,6 +43602,7 @@ function expandStoredInstance(args) {
     const built = trackMaterialization(
       () => args.materializeMemberDefaultValue({
         evaluateInitializer: args.evaluateInitializer,
+        randomSource,
         document: args.document,
         member: replayMember,
         envelope,
@@ -41351,6 +43631,7 @@ function expandStoredInstance(args) {
   const materialized = typeof appliedVariantId !== "string" ? constructed : trackMaterialization(
     () => replayAppliedVariant({
       evaluateInitializer: args.evaluateInitializer,
+      randomSource,
       document: args.document,
       member: replayMember,
       constructed,
@@ -41384,6 +43665,7 @@ function replayAppliedVariant(args) {
     classId: args.classId
   };
   args.evaluateInitializer({
+    randomSource: args.randomSource,
     init: {
       code: `virtual-applied-variant:${rootId}`,
       compiled: {
@@ -45082,6 +47364,7 @@ function initializerEvaluatorLookups(document2, readTracking) {
   if (document2.databaseVM !== void 0) {
     const databaseVM = document2.databaseVM;
     const lookups2 = {
+      random: databaseVM.random,
       ...databaseVM.changeListenerDefaultsForOwner === void 0 ? {} : {
         changeListenerDefaultsForOwner: (id) => databaseVM.changeListenerDefaultsForOwner(id)
       },
@@ -45333,12 +47616,25 @@ function compileMemberInitializer(args, databaseVM = initializerEvaluatorLookups
   });
 }
 function evaluateMemberInitializer(args) {
+  const randomIdentity = args.randomIdentity ?? args.sourceValueId ?? Reflect.get(args.member, "id");
+  if (typeof randomIdentity !== "string")
+    throw new Error(
+      "Stored initializer evaluation requires its content identity."
+    );
+  if (args.randomSource === void 0)
+    return withContentRandomSource(
+      args.document,
+      randomIdentity,
+      (randomSource) => evaluateMemberInitializer({ ...args, randomIdentity, randomSource })
+    );
   const databaseVM = initializerEvaluatorLookups(
     args.document,
     args.readTracking
   );
   const compiled = compileMemberInitializer(args, databaseVM);
   const ctx = {
+    randomSource: args.randomSource,
+    randomIdentity,
     ...args.sessionValues === void 0 ? {} : { __runtimeSessionValues: args.sessionValues },
     debugSink: args.document.debugSink,
     beforeValueAllocation: args.document.beforeValueAllocation,
@@ -45458,6 +47754,7 @@ function evaluateMemberInitializer(args) {
   const provenance = pickInstanceProvenance({ ...rootRow, constructorArgs });
   return {
     value: result.value,
+    snapshot: (evaluatedContext.__executionState?.randomDraws ?? 0) > 0,
     classId: rootRow.classId ?? null,
     ...rootRow.genericBindings === void 0 ? {} : { genericBindings: { ...rootRow.genericBindings } },
     ...pinnedRootSchemaKeys === void 0 ? {} : { pinnedRootSchemaKeys },
@@ -48176,7 +50473,23 @@ var MATH_FUNCTIONS = /* @__PURE__ */ new Map([
   ["Truncate", { op: "truncate", arity: 1, result: "integral" }],
   ["Abs", { op: "abs", arity: 1, result: "join" }],
   ["Sign", { op: "sign", arity: 1, result: "int" }],
-  ["Sqrt", { op: "sqrt", arity: 1, result: "float" }]
+  ["Sqrt", { op: "sqrt", arity: 1, result: "float" }],
+  ["Pow", { op: "pow", arity: 2, result: "float" }],
+  ["Exp", { op: "exp", arity: 1, result: "float" }],
+  ["Log", { op: "log", arity: 1, result: "float" }],
+  ["Log10", { op: "log10", arity: 1, result: "float" }],
+  ["Sin", { op: "sin", arity: 1, result: "float" }],
+  ["Cos", { op: "cos", arity: 1, result: "float" }],
+  ["Tan", { op: "tan", arity: 1, result: "float" }],
+  ["Asin", { op: "asin", arity: 1, result: "float" }],
+  ["Acos", { op: "acos", arity: 1, result: "float" }],
+  ["Atan", { op: "atan", arity: 1, result: "float" }],
+  ["Atan2", { op: "atan2", arity: 2, result: "float" }],
+  ["Lerp", { op: "lerp", arity: 3, result: "float" }],
+  ["InverseLerp", { op: "inverselerp", arity: 3, result: "float" }],
+  ["MoveTowards", { op: "movetowards", arity: 3, result: "float" }],
+  ["Repeat", { op: "repeat", arity: 2, result: "float" }],
+  ["PingPong", { op: "pingpong", arity: 2, result: "float" }]
 ]);
 var MATH_CONSTANTS = /* @__PURE__ */ new Map([
   ["PI", 3.141592653589793],
@@ -49439,7 +51752,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           statement.iterator,
           iteratorScope
         );
-        if (iterator.type !== "assign" /* Assign */) {
+        if (iterator.type !== "assign" /* Assign */ && iterator.type !== "functionCall" /* FunctionCall */) {
           throw new CompileError(
             "A for-loop iterator must be an assignment; an NSAction subscription is not a valid iterator.",
             statement.iterator.pos
@@ -50143,7 +52456,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   assertLocalNameAvailable(name, scope, pos) {
     if (name === MATH_NAMESPACE_NAME) {
       throw new CompileError(
-        `Cannot declare a local named '${MATH_NAMESPACE_NAME}' because it is a builtin namespace.`,
+        `Cannot declare a local named '${name}' because it is a builtin namespace.`,
         pos
       );
     }
@@ -50358,6 +52671,31 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       statement.target,
       scope
     );
+    if (placeTarget.symbol?.id === NEO_RANDOM_IDS.Seed && placeTarget.pointer.type === "callFunction" /* CallFunction */ && placeTarget.pointer.receiver.kind === "static") {
+      const value2 = statement.op === "=" && statement.value ? this.resolveExpression(statement.value, scope, placeTarget.type) : this.resolveCompoundAssignment(
+        statement.op,
+        statement.value,
+        placeTarget,
+        scope,
+        statement.pos
+      );
+      this.requireAssignable(
+        value2.type,
+        placeTarget.type,
+        statement.pos,
+        "assign"
+      );
+      return {
+        type: "functionCall" /* FunctionCall */,
+        call: {
+          type: "callFunction" /* CallFunction */,
+          memberId: NEO_RANDOM_IDS.SetSeed,
+          receiver: { kind: "static", memberId: NEO_RANDOM_IDS.SetSeed },
+          args: [value2.pointer],
+          callSiteId: this.nextCallSite(statement.pos)
+        }
+      };
+    }
     if (placeTarget.pointer.type === "function" /* Function */ && placeTarget.pointer.function.type === "tupleElement" /* TupleElement */) {
       throw new CompileError(
         "Tuple elements are immutable. Assign a new tuple to the whole value.",
@@ -50432,13 +52770,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    this.validateConstructorWriteTarget(
-      target.pointer,
-      "assign to",
-      statement.pos,
-      scope,
-      false
-    );
+    if (target.symbol?.id !== NEO_RANDOM_IDS.Seed) {
+      this.validateConstructorWriteTarget(
+        target.pointer,
+        "assign to",
+        statement.pos,
+        scope,
+        false
+      );
+    }
     if (target.type.kind === "action") {
       return this.resolveActionSubscription(
         statement,
@@ -52873,7 +55213,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     if (name === MATH_NAMESPACE_NAME) {
       throw new CompileError(
-        `'${MATH_NAMESPACE_NAME}' is a builtin namespace, not a value.`,
+        `'${name}' is a builtin namespace, not a value.`,
         pos
       );
     }
@@ -53419,6 +55759,20 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   resolveStaticMemberValue(staticType, member, pos) {
     this.assertMemberAccessible(staticType, member, pos);
+    if (staticType.id === NEO_RANDOM_IDS.class && member.id === NEO_RANDOM_IDS.Seed) {
+      return {
+        pointer: {
+          type: "callFunction" /* CallFunction */,
+          memberId: NEO_RANDOM_IDS.GetSeed,
+          receiver: { kind: "static", memberId: NEO_RANDOM_IDS.GetSeed },
+          args: [],
+          callSiteId: this.nextCallSite(pos)
+        },
+        type: member.type,
+        symbol: member,
+        writability: "setter" /* Setter */
+      };
+    }
     if (member.static !== true) {
       throw new CompileError(
         `Member '${staticType.name}.${member.name}' requires an instance receiver.`,
@@ -54567,7 +56921,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         argPointers: joined.arguments.map((argument2) => argument2.pointer),
         ...isPrimitive(joined.type, "decimal") ? { decimal: true } : {}
       },
-      mathResultType(fn.result, joined.type, pos)
+      mathResultType(fn.result, joined.type, pos, name)
     );
   }
   /**
@@ -54905,7 +57259,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const candidates2 = this.overloadCandidates(
           staticType,
           callee.name,
-          "static"
+          staticType.id === NEO_RANDOM_IDS.class ? "instance" : "static"
         );
         const member2 = candidates2[0] ?? staticType.members.find(
           (candidate) => candidate.name === callee.name
@@ -54917,7 +57271,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           );
         }
         this.assertMemberAccessible(staticType, member2, pos);
-        if (member2.static !== true) {
+        if (member2.static !== true && !isNeoRandomSharedMethod(staticType.id, member2.id)) {
           throw new CompileError(
             `Member '${staticType.name}.${callee.name}' requires an instance receiver.`,
             pos
@@ -55613,7 +57967,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveConstructorOverload(className, declared, named, expression, scope, pos) {
-    if (named.length === 0) {
+    if (named.length === 0 && neoScriptRequiredConstructor(
+      this.project.typeByName.get(className) ?? { declaredConstructors: [] }
+    ) === null) {
       return neoScriptParameterlessConstructor(
         this.project.typeByName.get(className) ?? { declaredConstructors: [] }
       );
@@ -58421,14 +60777,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const candidates2 = this.overloadCandidates(
           staticType,
           memberName,
-          "static"
+          staticType.id === NEO_RANDOM_IDS.class ? "instance" : "static"
         );
         const found2 = candidates2[0] ?? staticType.members.find(
           (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
         );
         if (!found2) return null;
         this.assertMemberAccessible(staticType, found2, expression.pos);
-        if (found2.static !== true) {
+        if (found2.static !== true && !isNeoRandomSharedMethod(staticType.id, found2.id)) {
           throw new CompileError(
             `Member '${staticType.name}.${memberName}' requires an instance receiver.`,
             expression.pos
@@ -59599,7 +61955,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return this.expressionWriteRoot(initial, scope);
   }
   validateCallableInContext(symbol, pos) {
-    if (symbol.native === true && !NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS.has(symbol.id) && isNeoScriptConstructionDocumentKind(this.context.kind)) {
+    if (symbol.native === true && !NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS.has(symbol.id) && !NEO_RANDOM_NATIVE_MEMBER_IDS.has(symbol.id) && isNeoScriptConstructionDocumentKind(this.context.kind)) {
       throw new CompileError(
         `Native Function '${symbol.name}' is implemented by the game, so a ${this.context.kind} body cannot call it; neither push nor the web can evaluate it.`,
         pos
@@ -61386,7 +63742,7 @@ function isContextualNumericLiteral(expression) {
   }
   return expression.kind === "unary" && expression.op === "-" && (expression.operand.kind === "litInt" || expression.operand.kind === "litFloat");
 }
-function mathResultType(rule, joined, pos) {
+function mathResultType(rule, joined, pos, name) {
   switch (rule) {
     case "join":
       return joined;
@@ -61397,7 +63753,7 @@ function mathResultType(rule, joined, pos) {
     case "float":
       if (isPrimitive(joined, "decimal")) {
         throw new CompileError(
-          "Math.Sqrt does not accept decimal; convert explicitly with value.ToFloat().",
+          `Math.${name} does not accept decimal; convert explicitly with value.ToFloat().`,
           pos
         );
       }
@@ -64738,8 +67094,8 @@ function compareCodePoints(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function pascalIdentifier(value) {
-  const words = value.normalize("NFKD").replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
-  let identifier = words.map((word) => `${word[0].toUpperCase()}${word.slice(1)}`).join("");
+  const words2 = value.normalize("NFKD").replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  let identifier = words2.map((word) => `${word[0].toUpperCase()}${word.slice(1)}`).join("");
   if (identifier.length === 0) identifier = "File";
   if (/^[0-9]/.test(identifier)) identifier = `File${identifier}`;
   return identifier;
@@ -73247,7 +75603,7 @@ function collectAssignedOwnershipVariableIds(instructions, assigned = /* @__PURE
       continue;
     }
     if (instruction.type === "for" /* for */) {
-      if (instruction.iterator.target.pointer.type === "variable" /* variable */) {
+      if (instruction.iterator.type === "assign" /* assign */ && instruction.iterator.target.pointer.type === "variable" /* variable */) {
         assigned.add(instruction.iterator.target.pointer.variableId);
       }
       collectAssignedOwnershipVariableIds(instruction.instructions, assigned);
@@ -79696,38 +82052,6 @@ import { ConvexError as ConvexError4 } from "convex/values";
 // ../src/common/client-commit-transport.ts
 var INLINE_COMMIT_MAX_PAYLOAD_BYTES = 512 * 1024;
 
-// src/ui.ts
-var colorEnabled = process.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
-function paint(open, close) {
-  if (!colorEnabled) return (text) => text;
-  return (text) => `\x1B[${open}m${text}\x1B[${close}m`;
-}
-var color = {
-  bold: paint(1, 22),
-  dim: paint(2, 22),
-  red: paint(31, 39),
-  green: paint(32, 39),
-  yellow: paint(33, 39),
-  blue: paint(34, 39),
-  magenta: paint(35, 39),
-  cyan: paint(36, 39)
-};
-var sym = {
-  ok: color.green("\u2714"),
-  fail: color.red("\u2716"),
-  warn: color.yellow("\u25B2"),
-  info: color.cyan("\u25CF"),
-  arrow: color.dim("\u2192"),
-  branch: color.magenta("\u2387"),
-  tag: color.cyan("\u2301"),
-  pointer: color.cyan("\u276F")
-};
-var CHANGE_KIND_COLOR = {
-  create: color.green,
-  update: color.yellow,
-  delete: color.red
-};
-
 // src/project-source/project-file-push.ts
 var UPLOAD_CONCURRENCY = 6;
 var PRESIGN_BATCH_SIZE = Math.min(
@@ -79892,10 +82216,6 @@ var SCRIPT_COLLECTION_READERS = {
   [5 /* Dictionary */]: "ReadScriptDictionary"
 };
 
-// src/export-state.ts
-import { join } from "node:path";
-var EXPORT_STATE_FILE = join(".neo", "export.json");
-
 // src/export-cache.ts
 var MAX_CACHE_BYTES = 256 * 1024 * 1024;
 
@@ -80185,10 +82505,11 @@ function sharedEvaluatorBase(rawDocument) {
   SHARED_EVALUATOR_BASES.set(rawDocument, created);
   return created;
 }
-function makeEvaluatorContext(rawDocument, interceptor) {
+function makeEvaluatorContext(rawDocument, interceptor, seed) {
   const base = sharedEvaluatorBase(rawDocument);
   return createNeoScriptEvaluationRuntime({
     vm: base.vm,
+    random: new NeoRandom(seed),
     debugSink: stderrNeoScriptDebugSink,
     thisValue: null,
     rootValue: base.rootValue,
@@ -80327,7 +82648,7 @@ function validateRegistrationAction(action, allowRegistration) {
     }
   }
 }
-function registerSpec(spec, document2) {
+function registerSpec(spec, document2, seed) {
   document2 = withCompiledConstructionTypes(document2, spec.action);
   validateRegistrationAction(spec.action, true);
   const root = {
@@ -80406,10 +82727,10 @@ function registerSpec(spec, document2) {
   };
   evaluateNSFunction(
     spec.action,
-    makeEvaluatorContext(document2, interceptor),
+    makeEvaluatorContext(document2, interceptor, seed),
     []
   );
-  return { spec, root, tests, document: document2 };
+  return { spec, root, tests, document: document2, seed };
 }
 function mockResponse(environment, mock, selected, call) {
   if (selected === null) {
@@ -80725,8 +83046,9 @@ function interceptTestCall(environment, call) {
     throw error;
   }
 }
-function createTestEnvironment(document2) {
+function createTestEnvironment(document2, seed) {
   const environment = {
+    seed,
     baseDocument: document2,
     context: void 0,
     mocks: /* @__PURE__ */ new Map(),
@@ -80736,7 +83058,8 @@ function createTestEnvironment(document2) {
   };
   environment.context = makeEvaluatorContext(
     document2,
-    (call) => interceptTestCall(environment, call)
+    (call) => interceptTestCall(environment, call),
+    seed
   );
   return environment;
 }
@@ -80798,7 +83121,10 @@ function copyMocks(source, target) {
   }
 }
 function cloneTestEnvironment(source) {
-  const cloned = createTestEnvironment(snapshotEnvironmentDocument(source));
+  const cloned = createTestEnvironment(
+    snapshotEnvironmentDocument(source),
+    source.seed
+  );
   copyMocks(source, cloned);
   cloned.context.__getterSubscriptions = source.context.__getterSubscriptions?.clone();
   return cloned;
@@ -80859,9 +83185,9 @@ function suiteHasSelectedTests(suite, selected) {
 function prepareTestEvaluator(document2) {
   sharedEvaluatorBase(document2);
 }
-async function executeTestFile(spec, document2, selected, timeoutMs, interrupted2 = () => false) {
+async function executeTestFile(spec, document2, selected, timeoutMs, interrupted2 = () => false, seed = 0) {
   return executeRegisteredSpec(
-    registerSpec(spec, document2),
+    registerSpec(spec, document2, seed),
     selected,
     timeoutMs,
     interrupted2
@@ -80976,7 +83302,11 @@ async function executeRegisteredSpec(registered, selected, timeoutMs, interrupte
       }
     }
   };
-  await executeSuite(registered.root, createTestEnvironment(document2), []);
+  await executeSuite(
+    registered.root,
+    createTestEnvironment(document2, registered.seed),
+    []
+  );
   const registrationOrder = new Map(
     registered.tests.map((test, index) => [test.id, index])
   );
@@ -81011,7 +83341,8 @@ parentPort?.on("message", async (request) => {
       document,
       new Set(request.selectedIds),
       request.timeoutMs,
-      () => interrupted
+      () => interrupted,
+      request.seed
     );
     respond({ kind: "result", result });
   } catch (error) {