keystonemc 1.0.0 → 1.1.0

package/dist/index.js

@@ -0,0 +1,988 @@
+import { world, system } from "@minecraft/server";
+class Keystone {
+  constructor() {
+  }
+}
+const keystone = new Keystone();
+class Vector3 {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  /**
+   * ゼロベクトルで生成
+   * @return {Vector3}
+   */
+  static zero() {
+    return new Vector3(0, 0, 0);
+  }
+  /**
+   * {x, y, z} オブジェクトから生成
+   * @param pos 
+   * @returns {Vector3}
+   */
+  static fromBDS(pos) {
+    return new Vector3(pos.x, pos.y, pos.z);
+  }
+  /**
+   * x
+   * @returns {number}
+   */
+  getX() {
+    return this.x;
+  }
+  /**
+   * y
+   * @returns {number}
+   */
+  getY() {
+    return this.y;
+  }
+  /**
+   * z
+   * @returns {number}
+   */
+  getZ() {
+    return this.z;
+  }
+  /**
+   * x (整数値)
+   * @returns {number}
+   */
+  getFloorX() {
+    return Math.floor(this.x);
+  }
+  /**
+   * y (整数値)
+   * @returns {number}
+   */
+  getFloorY() {
+    return Math.floor(this.y);
+  }
+  /**
+   * z (整数値)
+   * @returns {number}
+   */
+  getFloorZ() {
+    return Math.floor(this.z);
+  }
+  /**
+   * 加算
+   * @param x 
+   * @param y 
+   * @param z 
+   * @return {Vector3}
+   */
+  add(x, y, z) {
+    return new Vector3(
+      this.x + x,
+      this.y + y,
+      this.z + z
+    );
+  }
+  /**
+   * ベクトル単位での加算
+   * @param v 
+   * @returns {Vector3}
+   */
+  addVector(v) {
+    return this.add(v.x, v.y, v.z);
+  }
+  /**
+   * 減算
+   * @param x
+   * @param y
+   * @param z
+   * @return {Vector3}
+   */
+  subtract(x, y, z) {
+    return this.add(-x, -y, -z);
+  }
+  /**
+   * ベクトル単位での減算
+   * @param v
+   * @return {Vector3}
+   */
+  subtractVector(v) {
+    return this.add(-v.x, -v.y, -v.z);
+  }
+  /**
+   * 乗算
+   * @param value
+   * @return {Vector3}
+   */
+  multiply(value) {
+    return new Vector3(
+      this.x * value,
+      this.y * value,
+      this.z * value
+    );
+  }
+  /**
+   * 除算
+   * @param value
+   * @return {Vector3}
+   */
+  divide(value) {
+    return new Vector3(
+      this.x / value,
+      this.y / value,
+      this.z / value
+    );
+  }
+  /**
+   * ベクトルの内部数値小数点切り上げ
+   * @return {Vector3}
+   */
+  ceil() {
+    return new Vector3(
+      Math.ceil(this.x),
+      Math.ceil(this.y),
+      Math.ceil(this.z)
+    );
+  }
+  /**
+   * ベクトルの内部数値小数点切り捨て
+   * @return {Vector3}
+   */
+  floor() {
+    return new Vector3(
+      Math.floor(this.x),
+      Math.floor(this.y),
+      Math.floor(this.z)
+    );
+  }
+  /**
+   * ベクトルの内部数値小数点四捨五入
+   * @param precision
+   * @return {Vector3}
+   */
+  round(precision = 0) {
+    const factor = Math.pow(10, precision);
+    return new Vector3(
+      Math.round(this.x * factor) / factor,
+      Math.round(this.y * factor) / factor,
+      Math.round(this.z * factor) / factor
+    );
+  }
+  /**
+   * ベクトルの内部数値の絶対値
+   * @return {Vector3}
+   */
+  abs() {
+    return new Vector3(
+      Math.abs(this.x),
+      Math.abs(this.y),
+      Math.abs(this.z)
+    );
+  }
+  /**
+   * 指定した2点間のユークリッド距離
+   * @param pos 
+   * @return {number}
+   */
+  distance(pos) {
+    return Math.sqrt(this.distanceSquared(pos));
+  }
+  /**
+   * 指定した2点間のユークリッド距離の2乗
+   * @param pos 
+   * @return {number}
+   */
+  distanceSquared(pos) {
+    const dx = this.x - pos.x;
+    const dy = this.y - pos.y;
+    const dz = this.z - pos.z;
+    return dx * dx + dy * dy + dz * dz;
+  }
+  /**
+   * 内積
+   * @param pos 
+   * @return {number}
+   */
+  dot(pos) {
+    return this.x * pos.x + this.y * pos.y + this.z * pos.z;
+  }
+  /**
+   * 外積
+   * @param pos 
+   * @return {Vector3}
+   */
+  cross(pos) {
+    return new Vector3(
+      this.y * pos.z - this.z * pos.y,
+      this.z * pos.x - this.x * pos.z,
+      this.x * pos.y - this.y * pos.x
+    );
+  }
+  /**
+   * ベクトルの比較
+   * @param pos 
+   * @return {boolean}
+   */
+  equals(pos) {
+    return this.x === pos.x && this.y === pos.y && this.z === pos.z;
+  }
+  /**
+   * ベクトルの長さ
+   * @return {number}
+   */
+  length() {
+    return Math.sqrt(this.lengthSquared());
+  }
+  /**
+   * ベクトルの長さの2乗
+   * @return {number}
+   */
+  lengthSquared() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  /**
+   * 正規化
+   * @return {Vector3}
+   */
+  normalize() {
+    const len = this.length();
+    if (len > 0) {
+      return this.divide(len);
+    }
+    return new Vector3(0, 0, 0);
+  }
+  /**
+   * オブジェクトの数値指定再生成
+   * @param x 
+   * @param y 
+   * @param z 
+   * @return {Vector3}
+   */
+  withComponents(x, y, z) {
+    return new Vector3(
+      x !== void 0 ? x : this.x,
+      y !== void 0 ? y : this.y,
+      z !== void 0 ? z : this.z
+    );
+  }
+  /**
+  * X座標をxValueにしたとき線分上に存在する点を返す
+  * @param end 終点
+  * @param xValue 途中点のX値
+  * @returns {Vector3|undefined}
+  */
+  getIntermediateWithXValue(end, xValue) {
+    const dx = end.x - this.x;
+    if (dx === 0) return;
+    const t = (xValue - this.x) / dx;
+    if (t < 0 || t > 1) return;
+    return new Vector3(
+      this.x + dx * t,
+      this.y + (end.y - this.y) * t,
+      this.z + (end.z - this.z) * t
+    );
+  }
+  /**
+   * Y座標をyValueにしたとき線分上に存在する点を返す
+   * @param end 終点
+   * @param yValue 途中点のY値
+   * @returns {Vector3|undefined}
+   */
+  getIntermediateWithYValue(end, yValue) {
+    const dy = end.y - this.y;
+    if (dy === 0) return;
+    const t = (yValue - this.y) / dy;
+    if (t < 0 || t > 1) return;
+    return new Vector3(
+      this.x + (end.x - this.x) * t,
+      this.y + dy * t,
+      this.z + (end.z - this.z) * t
+    );
+  }
+  /**
+   * Z座標をzValueにしたとき線分上に存在する点を返す
+   * @param end 終点
+   * @param zValue 途中点のZ値
+   * @returns {Vector3|undefined}
+   */
+  getIntermediateWithZValue(end, zValue) {
+    const dz = end.z - this.z;
+    if (dz === 0) return;
+    const t = (zValue - this.z) / dz;
+    if (t < 0 || t > 1) return;
+    return new Vector3(
+      this.x + (end.x - this.x) * t,
+      this.y + (end.y - this.y) * t,
+      this.z + dz * t
+    );
+  }
+  /**
+   * BDS ScriptAPIで使える {x, y, z} 形式に変換
+   * @returns {_Vector3}
+   */
+  toBDS() {
+    return { x: this.x, y: this.y, z: this.z };
+  }
+  /** 
+   * オブジェクトに変換
+   */
+  toObject() {
+    return { x: this.x, y: this.y, z: this.z };
+  }
+  /**
+   * toString
+   * @returns {string}
+   */
+  toString() {
+    return `_Vector3(x=${this.x}, y=${this.y}, z=${this.z})`;
+  }
+  /**
+   * 最大点
+   * @param vector
+   * @param vectors 
+   * @returns {Vector3}
+   */
+  static maxComponents(vector, ...vectors) {
+    let x = vector.x;
+    let y = vector.y;
+    let z = vector.z;
+    for (const pos of vectors) {
+      x = Math.max(x, pos.x);
+      y = Math.max(y, pos.y);
+      z = Math.max(z, pos.z);
+    }
+    return new Vector3(x, y, z);
+  }
+  /**
+   * 最小点
+   * @param vector
+   * @param vectors 
+   * @returns {Vector3}
+   */
+  static minComponents(vector, ...vectors) {
+    let x = vector.x;
+    let y = vector.y;
+    let z = vector.z;
+    for (const pos of vectors) {
+      x = Math.min(x, pos.x);
+      y = Math.min(y, pos.y);
+      z = Math.min(z, pos.z);
+    }
+    return new Vector3(x, y, z);
+  }
+  /**
+   * 合計
+   * @param vectors
+   * @returns {Vector3}
+   */
+  static sum(...vectors) {
+    let x = 0, y = 0, z = 0;
+    for (const v of vectors) {
+      x += v.x;
+      y += v.y;
+      z += v.z;
+    }
+    return new Vector3(x, y, z);
+  }
+}
+class AxisAlignedBB {
+  constructor(center, extent) {
+    this.center = center;
+    this.extent = extent;
+  }
+  /**
+   * 最小点最大点からオブジェクト化
+   * @param min 
+   * @param max 
+   * @returns {AxisAlignedBB}
+   */
+  static fromMinMax(min, max) {
+    return new AxisAlignedBB(
+      {
+        x: (min.x + max.x) / 2,
+        y: (min.y + max.y) / 2,
+        z: (min.z + max.z) / 2
+      },
+      {
+        x: (max.x - min.x) / 2,
+        y: (max.y - min.y) / 2,
+        z: (max.z - min.z) / 2
+      }
+    );
+  }
+  /**
+   * 大きさ1のAABB生成
+   * @returns {AxisAlignedBB}
+   */
+  static one() {
+    return AxisAlignedBB.fromMinMax(
+      { x: 0, y: 0, z: 0 },
+      { x: 1, y: 1, z: 1 }
+    );
+  }
+  /**
+   * {center, extent} オブジェクトから生成
+   * @param aabb 
+   * @returns {AxisAlignedBB}
+   */
+  static fromBDS(aabb) {
+    return new AxisAlignedBB(aabb.center, aabb.extent);
+  }
+  /**
+   * 最小点
+   * @returns {Vector3}
+   */
+  get min() {
+    return {
+      x: this.center.x - this.extent.x,
+      y: this.center.y - this.extent.y,
+      z: this.center.z - this.extent.z
+    };
+  }
+  /**
+   * 最大点
+   * @returns {Vector3}
+   */
+  get max() {
+    return {
+      x: this.center.x + this.extent.x,
+      y: this.center.y + this.extent.y,
+      z: this.center.z + this.extent.z
+    };
+  }
+  /**
+   * オフセット
+   * @param dx 
+   * @param dy 
+   * @param dz 
+   * @returns {AxisAlignedBB}
+   */
+  offset(dx, dy, dz) {
+    return new AxisAlignedBB(
+      { x: this.center.x + dx, y: this.center.y + dy, z: this.center.z + dz },
+      this.extent
+    );
+  }
+  /**
+   * 拡大
+   * @param dx 
+   * @param dy 
+   * @param dz 
+   * @returns {AxisAlignedBB} 
+   */
+  expand(dx, dy, dz) {
+    return new AxisAlignedBB(
+      this.center,
+      {
+        x: this.extent.x + dx,
+        y: this.extent.y + dy,
+        z: this.extent.z + dz
+      }
+    );
+  }
+  /**
+   * 縮小
+   * @param dx 
+   * @param dy 
+   * @param dz 
+   * @returns {AxisAlignedBB}
+   */
+  contract(dx, dy, dz) {
+    return this.expand(-dx, -dy, -dz);
+  }
+  /**
+   * 接触判定
+   * @param other 
+   * @param epsilon 
+   * @returns {boolean}
+   */
+  intersects(other, epsilon = 1e-6) {
+    const aMin = this.min;
+    const aMax = this.max;
+    const bMin = other.min;
+    const bMax = other.max;
+    return bMax.x - aMin.x > epsilon && aMax.x - bMin.x > epsilon && bMax.y - aMin.y > epsilon && aMax.y - bMin.y > epsilon && bMax.z - aMin.z > epsilon && aMax.z - bMin.z > epsilon;
+  }
+  /**
+   * 対象座標が内包されているか
+   * @param v 
+   * @returns {boolean}
+   */
+  contains(v) {
+    const min = this.min;
+    const max = this.max;
+    return v.x > min.x && v.x < max.x && v.y > min.y && v.y < max.y && v.z > min.z && v.z < max.z;
+  }
+  /**
+   * Xの長さ
+   * @returns {number} 
+   */
+  getXLength() {
+    return this.extent.x * 2;
+  }
+  /**
+   * Yの長さ
+   * @returns {number} 
+   */
+  getYLength() {
+    return this.extent.y * 2;
+  }
+  /**
+   * Zの長さ
+   * @returns {number} 
+   */
+  getZLength() {
+    return this.extent.z * 2;
+  }
+  /**
+   * 体積
+   * @returns {number} 
+   */
+  getVolume() {
+    return this.getXLength() * this.getYLength() * this.getZLength();
+  }
+  /**
+   * キューブ判定
+   * @param epsilon 
+   * @returns {boolean}
+   */
+  isCube(epsilon = 1e-6) {
+    const x = this.getXLength();
+    const y = this.getYLength();
+    const z = this.getZLength();
+    return Math.abs(x - y) < epsilon && Math.abs(y - z) < epsilon;
+  }
+  /**
+   * BDS ScriptAPIで使える {center, extent} 形式に変換
+   * @returns {AABB}
+   */
+  toBDS() {
+    return { center: this.center, extent: this.extent };
+  }
+  /** 
+   * オブジェクトに変換
+   */
+  toObject() {
+    return { center: this.center, extent: this.extent };
+  }
+  /**
+   * toString
+   * @returns {string}
+   */
+  toString() {
+    return `AxisAlignedBB{center=(${this.center.x}, ${this.center.y}, ${this.center.z}), extent=(${this.center.x}, ${this.center.y}, ${this.center.z})}`;
+  }
+}
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["LOWEST"] = 5] = "LOWEST";
+  Priority2[Priority2["LOW"] = 4] = "LOW";
+  Priority2[Priority2["NORMAL"] = 3] = "NORMAL";
+  Priority2[Priority2["HIGH"] = 2] = "HIGH";
+  Priority2[Priority2["HIGHEST"] = 1] = "HIGHEST";
+  Priority2[Priority2["MONITOR"] = 0] = "MONITOR";
+  return Priority2;
+})(Priority || {});
+const _EventManager = class _EventManager {
+  /** init: world.beforeEvents / world.afterEvents を全自動で subscribe して dispatch に流す */
+  static initialize() {
+    for (const name in world.afterEvents) {
+      world.afterEvents[name].subscribe((ev) => {
+        _EventManager.dispatchAfter(name, ev);
+      });
+    }
+    for (const name in world.beforeEvents) {
+      world.beforeEvents[name].subscribe((ev) => {
+        _EventManager.dispatchBefore(name, ev);
+      });
+    }
+  }
+  // ---------- register ----------
+  static registerAfter(eventName, listener) {
+    if (!this.afterListeners[eventName]) {
+      this.afterListeners[eventName] = [];
+    }
+    const arr = this.afterListeners[eventName];
+    arr.push(listener);
+    arr.sort((a, b) => (b.priority ?? Priority.NORMAL) - (a.priority ?? Priority.NORMAL));
+  }
+  static registerBefore(eventName, listener) {
+    if (!this.beforeListeners[eventName]) {
+      this.beforeListeners[eventName] = [];
+    }
+    const arr = this.beforeListeners[eventName];
+    arr.push(listener);
+    arr.sort((a, b) => (b.priority ?? Priority.NORMAL) - (a.priority ?? Priority.NORMAL));
+  }
+  // ---------- dispatch ----------
+  static dispatchAfter(eventName, event) {
+    const arr = this.afterListeners[eventName];
+    if (!arr) return;
+    for (const listener of arr) {
+      try {
+        listener.handler(event);
+      } catch (e) {
+        console.error(`[EventManager] after:${String(eventName)} handler threw:`, e);
+      }
+    }
+  }
+  static dispatchBefore(eventName, event) {
+    const arr = this.beforeListeners[eventName];
+    if (!arr) return;
+    for (const listener of arr) {
+      try {
+        listener.handler(event);
+      } catch (e) {
+        console.error(`[EventManager] before:${String(eventName)} handler threw:`, e);
+      }
+    }
+  }
+  // ---------- utility ----------
+  /** 登録済みリスナーを全部クリア（Plugin 単位で実装するなら拡張する） */
+  static clearAll() {
+    this.afterListeners = {};
+    this.beforeListeners = {};
+  }
+};
+_EventManager.afterListeners = {};
+_EventManager.beforeListeners = {};
+let EventManager = _EventManager;
+const COLOR = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+const _VLQDecoder = class _VLQDecoder {
+  static decode(str) {
+    const result = [];
+    let shift = 0;
+    let value = 0;
+    for (let i = 0; i < str.length; i++) {
+      const digit = this.BASE64_CHARS.indexOf(str[i]);
+      if (digit === -1) continue;
+      const continuation = (digit & 32) !== 0;
+      value += (digit & 31) << shift;
+      if (continuation) {
+        shift += 5;
+      } else {
+        const negative = (value & 1) !== 0;
+        value >>>= 1;
+        result.push(negative ? -value : value);
+        value = 0;
+        shift = 0;
+      }
+    }
+    return result;
+  }
+};
+_VLQDecoder.BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+let VLQDecoder = _VLQDecoder;
+class SourceMapDebugger {
+  constructor() {
+    this.decodedMappings = [];
+    this.initialized = false;
+    this.initialize();
+  }
+  initialize() {
+    if (typeof globalThis.__SOURCE_MAP__ !== "undefined") {
+      this.sourceMap = globalThis.__SOURCE_MAP__;
+      this.decodeMappings();
+      this.initialized = true;
+    }
+  }
+  decodeMappings() {
+    if (!this.sourceMap?.mappings) return;
+    const lines = this.sourceMap.mappings.split(";");
+    let generatedLine = 1;
+    let prevOriginalLine = 0;
+    let prevOriginalColumn = 0;
+    let prevSource = 0;
+    let prevName = 0;
+    for (const line of lines) {
+      if (!line) {
+        generatedLine++;
+        continue;
+      }
+      const segments = line.split(",");
+      let generatedColumn = 0;
+      for (const segment of segments) {
+        if (!segment) continue;
+        const decoded = VLQDecoder.decode(segment);
+        if (decoded.length < 1) continue;
+        generatedColumn += decoded[0];
+        const mapping = {
+          generatedLine,
+          generatedColumn,
+          originalLine: 0,
+          originalColumn: 0,
+          sourceIndex: 0
+        };
+        if (decoded.length > 1) {
+          prevSource += decoded[1];
+          mapping.sourceIndex = prevSource;
+          if (decoded.length > 2) {
+            prevOriginalLine += decoded[2];
+            mapping.originalLine = prevOriginalLine;
+            if (decoded.length > 3) {
+              prevOriginalColumn += decoded[3];
+              mapping.originalColumn = prevOriginalColumn;
+              if (decoded.length > 4) {
+                prevName += decoded[4];
+                mapping.name = this.sourceMap.names?.[prevName];
+              }
+            }
+          }
+        }
+        this.decodedMappings.push(mapping);
+      }
+      generatedLine++;
+    }
+  }
+  getOriginalPosition(line, column) {
+    if (!this.initialized || this.decodedMappings.length === 0) return null;
+    let best = null;
+    let bestDistance = Infinity;
+    for (const m of this.decodedMappings) {
+      if (m.generatedLine === line) {
+        const distance = column !== void 0 ? Math.abs(m.generatedColumn - column) : 0;
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          best = m;
+        }
+      } else if (m.generatedLine < line) {
+        if (!best || m.generatedLine > best.generatedLine) best = m;
+      }
+    }
+    if (best && this.sourceMap.sources?.[best.sourceIndex]) {
+      return {
+        source: this.sourceMap.sources[best.sourceIndex],
+        line: best.originalLine,
+        column: best.originalColumn,
+        content: this.sourceMap.sourcesContent?.[best.sourceIndex],
+        name: best.name
+      };
+    }
+    return null;
+  }
+  debug(...args) {
+    try {
+      const err = new Error();
+      const stack = err.stack || "";
+      const stackLines = stack.split("\n");
+      const output = [];
+      output.push(`${COLOR.yellow}━━━━━━━━━━━━━━━━━━━━━━${COLOR.reset}`);
+      output.push(`${COLOR.bold}${COLOR.cyan}📍 DEBUG${COLOR.reset}`);
+      let position = null;
+      for (let i = 2; i < Math.min(stackLines.length, 8); i++) {
+        const line = stackLines[i];
+        console.log(JSON.stringify(line));
+        const match = /(?:\()?(?:[A-Za-z0-9._/-]+):(\d+)(?::(\d+))?\)?$/.exec(line);
+        if (match) {
+          const lineNum = parseInt(match[1]);
+          const colNum = match[2] ? parseInt(match[2]) : void 0;
+          position = this.getOriginalPosition(lineNum, colNum);
+          if (position) break;
+        }
+      }
+      if (position) {
+        const file = position.source.replace(/^.*\//, "");
+        output.push(`${COLOR.blue}📄 ${file}:${position.line}:${position.column}${COLOR.reset}`);
+        if (position.name) output.push(`${COLOR.cyan}🏷 ${position.name}${COLOR.reset}`);
+        if (position.content) {
+          const lines = position.content.split("\n");
+          const target = position.line - 1;
+          const range = 2;
+          output.push(`${COLOR.gray}─────────────────────${COLOR.reset}`);
+          for (let i = Math.max(0, target - range); i <= Math.min(lines.length - 1, target + range); i++) {
+            const num = `${(i + 1).toString().padStart(3, " ")}`;
+            const content = lines[i];
+            if (i === target) {
+              output.push(`${COLOR.red}${COLOR.bold}→ ${num}: ${COLOR.white}${content}${COLOR.reset}`);
+            } else {
+              output.push(`${COLOR.gray}  ${num}: ${content}${COLOR.reset}`);
+            }
+          }
+        }
+      } else {
+        output.push(`${COLOR.gray}📍 Location: (source map not available)${COLOR.reset}`);
+      }
+      output.push(`${COLOR.gray}─────────────────────${COLOR.reset}`);
+      output.push(`${COLOR.bold}${COLOR.white}💾 Values:${COLOR.reset}`);
+      args.forEach((arg, i) => {
+        let val;
+        if (arg === void 0) val = "undefined";
+        else if (arg === null) val = "null";
+        else if (typeof arg === "object") {
+          try {
+            val = JSON.stringify(arg, null, 2);
+          } catch {
+            val = "[Circular or Complex Object]";
+          }
+        } else if (typeof arg === "function") {
+          val = `[Function: ${arg.name || "anonymous"}]`;
+        } else {
+          val = String(arg);
+        }
+        output.push(`${COLOR.green}[${i}]:${COLOR.reset} ${val}`);
+      });
+      output.push(`${COLOR.yellow}━━━━━━━━━━━━━━━━━━━━━━${COLOR.reset}`);
+      console.log(output.join("\n"));
+    } catch (err) {
+      console.log(`${COLOR.red}[DEBUG ERROR]${COLOR.reset}`, err);
+      console.log(args);
+    }
+  }
+}
+const debuggerInstance = new SourceMapDebugger();
+function debug(...args) {
+  debuggerInstance.debug(...args);
+}
+const _TimerScheduler = class _TimerScheduler {
+  /** スケジューラにタスクを登録 */
+  static addTask(task) {
+    this.tasks.add(task);
+    this.ensureStarted();
+  }
+  /** タスクを削除 */
+  static removeTask(task) {
+    this.tasks.delete(task);
+  }
+  /** Interval を開始（1 本だけ） */
+  static ensureStarted() {
+    if (this.started) return;
+    this.started = true;
+    system.runInterval(() => {
+      this.tick++;
+      for (const task of this.tasks) {
+        try {
+          task();
+        } catch (e) {
+          console.error("[TimerScheduler] Task error:", e);
+        }
+      }
+    }, 1);
+  }
+};
+_TimerScheduler.tasks = /* @__PURE__ */ new Set();
+_TimerScheduler.tick = 0;
+_TimerScheduler.started = false;
+let TimerScheduler = _TimerScheduler;
+class Timer {
+  constructor(onRun, onCancel) {
+    this.currentTick = 0;
+    this.stopped = false;
+    this.canceled = false;
+    this.forceCanceled = false;
+    this.onRun = onRun;
+    this.onCancel = onCancel;
+  }
+  /** 一時停止 */
+  stop() {
+    this.stopped = true;
+  }
+  /** 再開 */
+  resume() {
+    this.stopped = false;
+  }
+  /** 停止しているか */
+  isStopped() {
+    return this.stopped;
+  }
+  /** キャンセル要求 */
+  cancel(force = false) {
+    if (force) this.forceCanceled = true;
+    this.canceled = true;
+  }
+  /** タイマー内部キャンセル */
+  internalCancel(force = false) {
+    if (!this.task) return 2;
+    TimerScheduler.removeTask(this.task);
+    this.onCancel?.();
+    return force ? 1 : 0;
+  }
+}
+class RepeatingTimer extends Timer {
+  constructor(onRun, opts = {}, onCancel) {
+    super(onRun, onCancel);
+    this.period = opts.period ?? 1;
+    this.endless = opts.endless ?? true;
+    this.silenceOnStop = opts.silenceOnStop ?? true;
+    this.maxElapsedTicks = opts.maxElapsedTicks;
+    this.onFinal = opts.onFinal;
+  }
+  /** タイマー開始 */
+  start() {
+    this.task = () => {
+      if (this.forceCanceled) return this.internalCancel(true);
+      if (this.canceled) return this.internalCancel();
+      if (!this.endless && this.maxElapsedTicks !== void 0 && this.currentTick >= this.maxElapsedTicks) {
+        this.onFinal?.();
+        return this.internalCancel();
+      }
+      if (this.currentTick % this.period === 0) {
+        if (!this.stopped || this.stopped && !this.silenceOnStop)
+          this.onRun?.(this.currentTick);
+      }
+      if (!this.stopped) this.currentTick++;
+    };
+    TimerScheduler.addTask(this.task);
+  }
+}
+class DelayedTimer extends Timer {
+  constructor(onRun, opts = {}, onCancel) {
+    super(onRun, onCancel);
+    this.delay = opts.delay ?? 1;
+  }
+  start() {
+    this.task = () => {
+      if (this.forceCanceled) return this.internalCancel(true);
+      if (this.canceled) return this.internalCancel();
+      if (this.currentTick >= this.delay) {
+        this.onRun?.(this.currentTick);
+        return this.internalCancel();
+      }
+      this.currentTick++;
+    };
+    TimerScheduler.addTask(this.task);
+  }
+}
+function repeating(opts) {
+  const options = {
+    period: opts.every,
+    endless: opts.endless,
+    silenceOnStop: opts.silenceWhenStopped,
+    maxElapsedTicks: opts.max,
+    onFinal: opts.final
+  };
+  const t = new RepeatingTimer(opts.run, options, opts.cancel);
+  t.start();
+  return t;
+}
+function delayed(ticks, run, cancel) {
+  const t = new DelayedTimer(() => run(), { delay: ticks }, cancel);
+  t.start();
+  return t;
+}
+function sleep(tick) {
+  return new Promise((resolve) => {
+    new DelayedTimer(() => resolve(), { delay: tick }).start();
+  });
+}
+export {
+  AxisAlignedBB,
+  DelayedTimer,
+  EventManager,
+  Priority,
+  RepeatingTimer,
+  Vector3,
+  debug,
+  delayed,
+  keystone,
+  repeating,
+  sleep
+};